contrib/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, 2002  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 /* $FreeBSD$ */
  24
  25
  26 /* Process declarations and symbol lookup for C front end.
  27    Also constructs types; the standard scalar types at initialization,
  28    and structure, union, array and enum types when they are declared.  */
  29
  30 /* ??? not all decl nodes are given the most useful possible
  31    line numbers.  For example, the CONST_DECLs for enum values.  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "lex.h"
  43 #include "output.h"
  44 #include "except.h"
  45 #include "toplev.h"
  46 #include "../hash.h"
  47 #include "ggc.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "c-common.h"
  51 #include "diagnostic.h"
  52
  53 extern const struct attribute_spec *lang_attribute_table;
  54
  55 #ifndef BOOL_TYPE_SIZE
  56 /* `bool' has size and alignment `1', on all platforms.  */
  57 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  58 #endif
  59
  60 #ifndef HOST_PTR_PRINTF_FORMAT
  61 #define HOST_PTR_PRINTF_FORMAT HOST_PTR_PRINTF
  62 #endif
  63 #ifndef HOST_PTR_PRINTF_TYPE
  64 #define HOST_PTR_PRINTF_TYPE (void *)
  65 #endif
  66
  67 static tree grokparms                           PARAMS ((tree));
  68 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  69
  70 static void push_binding_level PARAMS ((struct binding_level *, int,
  71                                       int));
  72 static void pop_binding_level PARAMS ((void));
  73 static void suspend_binding_level PARAMS ((void));
  74 static void resume_binding_level PARAMS ((struct binding_level *));
  75 static struct binding_level *make_binding_level PARAMS ((void));
  76 static void declare_namespace_level PARAMS ((void));
  77 static int decl_jump_unsafe PARAMS ((tree));
  78 static void storedecls PARAMS ((tree));
  79 static void require_complete_types_for_parms PARAMS ((tree));
  80 static int ambi_op_p PARAMS ((enum tree_code));
  81 static int unary_op_p PARAMS ((enum tree_code));
  82 static tree store_bindings PARAMS ((tree, tree));
  83 static tree lookup_tag_reverse PARAMS ((tree, tree));
  84 static tree obscure_complex_init PARAMS ((tree, tree));
  85 static tree lookup_name_real PARAMS ((tree, int, int, int));
  86 static void push_local_name PARAMS ((tree));
  87 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  88 static tree grok_reference_init PARAMS ((tree, tree, tree));
  89 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  90                               enum overload_flags, tree,
  91                               tree, int, int, int, int, int, int, tree));
  92 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  93 static tree lookup_tag PARAMS ((enum tree_code, tree,
  94                               struct binding_level *, int));
  95 static void set_identifier_type_value_with_scope
  96         PARAMS ((tree, tree, struct binding_level *));
  97 static void record_unknown_type PARAMS ((tree, const char *));
  98 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  99 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 100 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 101                                   int));
 102 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 103 static void check_for_uninitialized_const_var PARAMS ((tree));
 104 static unsigned long typename_hash PARAMS ((hash_table_key));
 105 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
 106 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 107 static int add_binding PARAMS ((tree, tree));
 108 static void pop_binding PARAMS ((tree, tree));
 109 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 110 static tree find_binding PARAMS ((tree, tree));
 111 static tree select_decl PARAMS ((tree, int));
 112 static int lookup_flags PARAMS ((int, int));
 113 static tree qualify_lookup PARAMS ((tree, int));
 114 static tree record_builtin_java_type PARAMS ((const char *, int));
 115 static const char *tag_name PARAMS ((enum tag_types code));
 116 static void find_class_binding_level PARAMS ((void));
 117 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 118 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 119 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 120 static int walk_globals_r PARAMS ((tree, void *));
 121 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 122 static tree make_label_decl PARAMS ((tree, int));
 123 static void use_label PARAMS ((tree));
 124 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 125                                            const char *, int));
 126 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 127 static void check_switch_goto PARAMS ((struct binding_level *));
 128 static void check_previous_gotos PARAMS ((tree));
 129 static void pop_label PARAMS ((tree, tree));
 130 static void pop_labels PARAMS ((tree));
 131 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 132 static void layout_var_decl PARAMS ((tree));
 133 static void maybe_commonize_var PARAMS ((tree));
 134 static tree check_initializer PARAMS ((tree, tree));
 135 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 136 static void push_cp_function_context PARAMS ((struct function *));
 137 static void pop_cp_function_context PARAMS ((struct function *));
 138 static void mark_binding_level PARAMS ((void *));
 139 static void mark_named_label_lists PARAMS ((void *, void *));
 140 static void mark_cp_function_context PARAMS ((struct function *));
 141 static void mark_saved_scope PARAMS ((void *));
 142 static void mark_lang_function PARAMS ((struct cp_language_function *));
 143 static void save_function_data PARAMS ((tree));
 144 static void check_function_type PARAMS ((tree, tree));
 145 static void destroy_local_var PARAMS ((tree));
 146 static void begin_constructor_body PARAMS ((void));
 147 static void finish_constructor_body PARAMS ((void));
 148 static void begin_destructor_body PARAMS ((void));
 149 static void finish_destructor_body PARAMS ((void));
 150 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 151 static tree get_atexit_node PARAMS ((void));
 152 static tree get_dso_handle_node PARAMS ((void));
 153 static tree start_cleanup_fn PARAMS ((void));
 154 static void end_cleanup_fn PARAMS ((void));
 155 static tree cp_make_fname_decl PARAMS ((tree, int));
 156 static void initialize_predefined_identifiers PARAMS ((void));
 157 static tree check_special_function_return_type
 158   PARAMS ((special_function_kind, tree, tree));
 159 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 160 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 161 static void store_parm_decls PARAMS ((tree));
 162 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 163
 164 #if defined (DEBUG_CP_BINDING_LEVELS)
 165 static void indent PARAMS ((void));
 166 #endif
 167
 168 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 169 tree error_mark_list;
 170
 171 /* The following symbols are subsumed in the cp_global_trees array, and
 172    listed here individually for documentation purposes.
 173
 174    C++ extensions
 175         tree wchar_decl_node;
 176
 177         tree vtable_entry_type;
 178         tree delta_type_node;
 179         tree __t_desc_type_node;
 180         tree ti_desc_type_node;
 181         tree bltn_desc_type_node, ptr_desc_type_node;
 182         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 183         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 184         tree ptm_desc_type_node;
 185         tree base_desc_type_node;
 186
 187         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 188         tree unknown_type_node;
 189
 190    Array type `vtable_entry_type[]'
 191
 192         tree vtbl_type_node;
 193         tree vtbl_ptr_type_node;
 194
 195    Namespaces,
 196
 197         tree std_node;
 198         tree abi_node;
 199
 200    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 201    one that the user will declare, but sufficient to be called
 202    by routines that want to abort the program.
 203
 204         tree abort_fndecl;
 205
 206    The FUNCTION_DECL for the default `::operator delete'.
 207
 208         tree global_delete_fndecl;
 209
 210    Used by RTTI
 211         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 212         tree tinfo_var_id;
 213
 214 */
 215
 216 tree cp_global_trees[CPTI_MAX];
 217
 218 /* Indicates that there is a type value in some namespace, although
 219    that is not necessarily in scope at the moment.  */
 220
 221 static tree global_type_node;
 222
 223 /* Expect only namespace names now. */
 224 static int only_namespace_names;
 225
 226 /* Used only for jumps to as-yet undefined labels, since jumps to
 227    defined labels can have their validity checked immediately.  */
 228
 229 struct named_label_use_list
 230 {
 231   struct binding_level *binding_level;
 232   tree names_in_scope;
 233   tree label_decl;
 234   const char *filename_o_goto;
 235   int lineno_o_goto;
 236   struct named_label_use_list *next;
 237 };
 238
 239 #define named_label_uses cp_function_chain->x_named_label_uses
 240
 241 #define local_names cp_function_chain->x_local_names
 242
 243 /* A list of objects which have constructors or destructors
 244    which reside in the global scope.  The decl is stored in
 245    the TREE_VALUE slot and the initializer is stored
 246    in the TREE_PURPOSE slot.  */
 247 tree static_aggregates;
 248
 249 /* -- end of C++ */
 250
 251 /* A node for the integer constants 2, and 3.  */
 252
 253 tree integer_two_node, integer_three_node;
 254
 255 /* Similar, for last_function_parm_tags.  */
 256 tree last_function_parms;
 257
 258 /* A list of all LABEL_DECLs in the function that have names.  Here so
 259    we can clear out their names' definitions at the end of the
 260    function, and so we can check the validity of jumps to these labels.  */
 261
 262 struct named_label_list
 263 {
 264   struct binding_level *binding_level;
 265   tree names_in_scope;
 266   tree old_value;
 267   tree label_decl;
 268   tree bad_decls;
 269   struct named_label_list *next;
 270   unsigned int in_try_scope : 1;
 271   unsigned int in_catch_scope : 1;
 272 };
 273
 274 #define named_labels cp_function_chain->x_named_labels
 275
 276 /* Nonzero means use the ISO C94 dialect of C.  */
 277
 278 int flag_isoc94;
 279
 280 /* Nonzero means use the ISO C99 dialect of C.  */
 281
 282 int flag_isoc99;
 283
 284 /* Nonzero means we are a hosted implementation for code shared with C.  */
 285
 286 int flag_hosted = 1;
 287
 288 /* Nonzero means add default format_arg attributes for functions not
 289    in ISO C.  */
 290
 291 int flag_noniso_default_format_attributes = 1;
 292
 293 /* Nonzero if we want to conserve space in the .o files.  We do this
 294    by putting uninitialized data and runtime initialized data into
 295    .common instead of .data at the expense of not flagging multiple
 296    definitions.  */
 297 extern int flag_conserve_space;
 298 \f
 299 /* C and C++ flags are in decl2.c.  */
 300
 301 /* A expression of value 0 with the same precision as a sizetype
 302    node, but signed.  */
 303 tree signed_size_zero_node;
 304
 305 /* The name of the anonymous namespace, throughout this translation
 306    unit.  */
 307 tree anonymous_namespace_name;
 308
 309 /* The number of function bodies which we are currently processing.
 310    (Zero if we are at namespace scope, one inside the body of a
 311    function, two inside the body of a function in a local class, etc.)  */
 312 int function_depth;
 313
 314 /* States indicating how grokdeclarator() should handle declspecs marked
 315    with __attribute__((deprecated)).  An object declared as
 316    __attribute__((deprecated)) suppresses warnings of uses of other
 317    deprecated items.  */
 318
 319 enum deprecated_states {
 320   DEPRECATED_NORMAL,
 321   DEPRECATED_SUPPRESS
 322 };
 323
 324 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 325
 326 /* Set by add_implicitly_declared_members() to keep those members from
 327    being flagged as deprecated or reported as using deprecated
 328    types.  */
 329 int adding_implicit_members = 0;
 330 \f
 331 /* For each binding contour we allocate a binding_level structure
 332    which records the names defined in that contour.
 333    Contours include:
 334     0) the global one
 335     1) one for each function definition,
 336        where internal declarations of the parameters appear.
 337     2) one for each compound statement,
 338        to record its declarations.
 339
 340    The current meaning of a name can be found by searching the levels
 341    from the current one out to the global one.
 342
 343    Off to the side, may be the class_binding_level.  This exists only
 344    to catch class-local declarations.  It is otherwise nonexistent.
 345
 346    Also there may be binding levels that catch cleanups that must be
 347    run when exceptions occur.  Thus, to see whether a name is bound in
 348    the current scope, it is not enough to look in the
 349    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 350    instead.  */
 351
 352 /* Note that the information in the `names' component of the global contour
 353    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 354
 355 struct binding_level
 356   {
 357     /* A chain of _DECL nodes for all variables, constants, functions,
 358        and typedef types.  These are in the reverse of the order
 359        supplied.  There may be OVERLOADs on this list, too, but they
 360        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 361     tree names;
 362
 363     /* A list of structure, union and enum definitions, for looking up
 364        tag names.
 365        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 366        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 367        or ENUMERAL_TYPE node.
 368
 369        C++: the TREE_VALUE nodes can be simple types for
 370        component_bindings.  */
 371     tree tags;
 372
 373     /* A list of USING_DECL nodes. */
 374     tree usings;
 375
 376     /* A list of used namespaces. PURPOSE is the namespace,
 377        VALUE the common ancestor with this binding_level's namespace. */
 378     tree using_directives;
 379
 380     /* If this binding level is the binding level for a class, then
 381        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 382        is the name of an entity bound in the class.  The TREE_TYPE is
 383        the DECL bound by this name in the class.  */
 384     tree class_shadowed;
 385
 386     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 387        is used for all binding levels. In addition the TREE_VALUE is the
 388        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 389     tree type_shadowed;
 390
 391     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 392        label in this scope.  The TREE_PURPOSE is the previous value of
 393        the IDENTIFIER_LABEL VALUE.  */
 394     tree shadowed_labels;
 395
 396     /* For each level (except not the global one),
 397        a chain of BLOCK nodes for all the levels
 398        that were entered and exited one level down.  */
 399     tree blocks;
 400
 401     /* The _TYPE node for this level, if parm_flag == 2.  */
 402     tree this_class;
 403
 404     /* The binding level which this one is contained in (inherits from).  */
 405     struct binding_level *level_chain;
 406
 407     /* List of decls in `names' that have incomplete
 408        structure or union types.  */
 409     tree incomplete;
 410
 411     /* List of VAR_DECLS saved from a previous for statement.
 412        These would be dead in ISO-conforming code, but might
 413        be referenced in ARM-era code.  These are stored in a
 414        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 415     tree dead_vars_from_for;
 416
 417     /* 1 for the level that holds the parameters of a function.
 418        2 for the level that holds a class declaration.  */
 419     unsigned parm_flag : 2;
 420
 421     /* 1 means make a BLOCK for this level regardless of all else.
 422        2 for temporary binding contours created by the compiler.  */
 423     unsigned keep : 2;
 424
 425     /* Nonzero if this level "doesn't exist" for tags.  */
 426     unsigned tag_transparent : 1;
 427
 428     /* Nonzero if this level can safely have additional
 429        cleanup-needing variables added to it.  */
 430     unsigned more_cleanups_ok : 1;
 431     unsigned have_cleanups : 1;
 432
 433     /* Nonzero if this scope is for storing the decls for template
 434        parameters and generic decls; these decls will be discarded and
 435        replaced with a TEMPLATE_DECL.  */
 436     unsigned template_parms_p : 1;
 437
 438     /* Nonzero if this scope corresponds to the `<>' in a
 439        `template <>' clause.  Whenever this flag is set,
 440        TEMPLATE_PARMS_P will be set as well.  */
 441     unsigned template_spec_p : 1;
 442
 443     /* This is set for a namespace binding level.  */
 444     unsigned namespace_p : 1;
 445
 446     /* True if this level is that of a for-statement where we need to
 447        worry about ambiguous (ARM or ISO) scope rules.  */
 448     unsigned is_for_scope : 1;
 449
 450     /* True if this level corresponds to a TRY block.  Currently this
 451        information is only available while building the tree structure.  */
 452     unsigned is_try_scope : 1;
 453
 454     /* True if this level corresponds to a CATCH block.  Currently this
 455        information is only available while building the tree structure.  */
 456     unsigned is_catch_scope : 1;
 457
 458     /* Three bits left for this word.  */
 459
 460 #if defined(DEBUG_CP_BINDING_LEVELS)
 461     /* Binding depth at which this level began.  */
 462     unsigned binding_depth;
 463 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 464   };
 465
 466 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 467
 468 /* The binding level currently in effect.  */
 469
 470 #define current_binding_level                   \
 471   (cfun && cp_function_chain->bindings          \
 472    ? cp_function_chain->bindings                \
 473    : scope_chain->bindings)
 474
 475 /* The binding level of the current class, if any.  */
 476
 477 #define class_binding_level scope_chain->class_bindings
 478
 479 /* A chain of binding_level structures awaiting reuse.  */
 480
 481 static struct binding_level *free_binding_level;
 482
 483 /* The outermost binding level, for names of file scope.
 484    This is created when the compiler is started and exists
 485    through the entire run.  */
 486
 487 static struct binding_level *global_binding_level;
 488
 489 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 490
 491 static int keep_next_level_flag;
 492
 493 #if defined(DEBUG_CP_BINDING_LEVELS)
 494 static int binding_depth = 0;
 495 static int is_class_level = 0;
 496
 497 static void
 498 indent ()
 499 {
 500   register unsigned i;
 501
 502   for (i = 0; i < binding_depth*2; i++)
 503     putc (' ', stderr);
 504 }
 505 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 506
 507 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 508
 509 static void
 510 push_binding_level (newlevel, tag_transparent, keep)
 511      struct binding_level *newlevel;
 512      int tag_transparent, keep;
 513 {
 514   /* Add this level to the front of the chain (stack) of levels that
 515      are active.  */
 516   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 517   newlevel->level_chain = current_binding_level;
 518   current_binding_level = newlevel;
 519   newlevel->tag_transparent = tag_transparent;
 520   newlevel->more_cleanups_ok = 1;
 521
 522   newlevel->keep = keep;
 523 #if defined(DEBUG_CP_BINDING_LEVELS)
 524   newlevel->binding_depth = binding_depth;
 525   indent ();
 526   fprintf (stderr, "push %s level 0x%08x line %d\n",
 527            (is_class_level) ? "class" : "block", newlevel, lineno);
 528   is_class_level = 0;
 529   binding_depth++;
 530 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 531 }
 532
 533 /* Find the innermost enclosing class scope, and reset
 534    CLASS_BINDING_LEVEL appropriately.  */
 535
 536 static void
 537 find_class_binding_level ()
 538 {
 539   struct binding_level *level = current_binding_level;
 540
 541   while (level && level->parm_flag != 2)
 542     level = level->level_chain;
 543   if (level && level->parm_flag == 2)
 544     class_binding_level = level;
 545   else
 546     class_binding_level = 0;
 547 }
 548
 549 static void
 550 pop_binding_level ()
 551 {
 552   if (global_binding_level)
 553     {
 554       /* Cannot pop a level, if there are none left to pop.  */
 555       if (current_binding_level == global_binding_level)
 556         abort ();
 557     }
 558   /* Pop the current level, and free the structure for reuse.  */
 559 #if defined(DEBUG_CP_BINDING_LEVELS)
 560   binding_depth--;
 561   indent ();
 562   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 563           (is_class_level) ? "class" : "block",
 564           current_binding_level, lineno);
 565   if (is_class_level != (current_binding_level == class_binding_level))
 566     {
 567       indent ();
 568       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 569     }
 570   is_class_level = 0;
 571 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 572   {
 573     register struct binding_level *level = current_binding_level;
 574     current_binding_level = current_binding_level->level_chain;
 575     level->level_chain = free_binding_level;
 576 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 577     if (level->binding_depth != binding_depth)
 578       abort ();
 579 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 580     free_binding_level = level;
 581     find_class_binding_level ();
 582   }
 583 }
 584
 585 static void
 586 suspend_binding_level ()
 587 {
 588   if (class_binding_level)
 589     current_binding_level = class_binding_level;
 590
 591   if (global_binding_level)
 592     {
 593       /* Cannot suspend a level, if there are none left to suspend.  */
 594       if (current_binding_level == global_binding_level)
 595         abort ();
 596     }
 597   /* Suspend the current level.  */
 598 #if defined(DEBUG_CP_BINDING_LEVELS)
 599   binding_depth--;
 600   indent ();
 601   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 602           (is_class_level) ? "class" : "block",
 603           current_binding_level, lineno);
 604   if (is_class_level != (current_binding_level == class_binding_level))
 605     {
 606       indent ();
 607       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 608     }
 609   is_class_level = 0;
 610 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 611   current_binding_level = current_binding_level->level_chain;
 612   find_class_binding_level ();
 613 }
 614
 615 static void
 616 resume_binding_level (b)
 617      struct binding_level *b;
 618 {
 619   /* Resuming binding levels is meant only for namespaces,
 620      and those cannot nest into classes. */
 621   my_friendly_assert(!class_binding_level, 386);
 622   /* Also, resuming a non-directly nested namespace is a no-no.  */
 623   my_friendly_assert(b->level_chain == current_binding_level, 386);
 624   current_binding_level = b;
 625 #if defined(DEBUG_CP_BINDING_LEVELS)
 626   b->binding_depth = binding_depth;
 627   indent ();
 628   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 629            (is_class_level) ? "class" : "block", b, lineno);
 630   is_class_level = 0;
 631   binding_depth++;
 632 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 633 }
 634 \f
 635 /* Create a new `struct binding_level'.  */
 636
 637 static
 638 struct binding_level *
 639 make_binding_level ()
 640 {
 641   /* NOSTRICT */
 642   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 643 }
 644
 645 /* Nonzero if we are currently in the global binding level.  */
 646
 647 int
 648 global_bindings_p ()
 649 {
 650   return current_binding_level == global_binding_level;
 651 }
 652
 653 /* Return the innermost binding level that is not for a class scope.  */
 654
 655 static struct binding_level *
 656 innermost_nonclass_level ()
 657 {
 658   struct binding_level *b;
 659
 660   b = current_binding_level;
 661   while (b->parm_flag == 2)
 662     b = b->level_chain;
 663
 664   return b;
 665 }
 666
 667 /* Nonzero if we are currently in a toplevel binding level.  This
 668    means either the global binding level or a namespace in a toplevel
 669    binding level.  Since there are no non-toplevel namespace levels,
 670    this really means any namespace or template parameter level.  We
 671    also include a class whose context is toplevel.  */
 672
 673 int
 674 toplevel_bindings_p ()
 675 {
 676   struct binding_level *b = innermost_nonclass_level ();
 677
 678   return b->namespace_p || b->template_parms_p;
 679 }
 680
 681 /* Nonzero if this is a namespace scope, or if we are defining a class
 682    which is itself at namespace scope, or whose enclosing class is
 683    such a class, etc.  */
 684
 685 int
 686 namespace_bindings_p ()
 687 {
 688   struct binding_level *b = innermost_nonclass_level ();
 689
 690   return b->namespace_p;
 691 }
 692
 693 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 694    unconditionally.  Otherwise, use the normal logic to decide whether
 695    or not to create a BLOCK.  */
 696
 697 void
 698 keep_next_level (keep)
 699      int keep;
 700 {
 701   keep_next_level_flag = keep;
 702 }
 703
 704 /* Nonzero if the current level needs to have a BLOCK made.  */
 705
 706 int
 707 kept_level_p ()
 708 {
 709   return (current_binding_level->blocks != NULL_TREE
 710           || current_binding_level->keep
 711           || current_binding_level->names != NULL_TREE
 712           || (current_binding_level->tags != NULL_TREE
 713               && !current_binding_level->tag_transparent));
 714 }
 715
 716 static void
 717 declare_namespace_level ()
 718 {
 719   current_binding_level->namespace_p = 1;
 720 }
 721
 722 /* Returns non-zero if this scope was created to store template
 723    parameters.  */
 724
 725 int
 726 template_parm_scope_p ()
 727 {
 728   return current_binding_level->template_parms_p;
 729 }
 730
 731 /* Returns the kind of template specialization we are currently
 732    processing, given that it's declaration contained N_CLASS_SCOPES
 733    explicit scope qualifications.  */
 734
 735 tmpl_spec_kind
 736 current_tmpl_spec_kind (n_class_scopes)
 737      int n_class_scopes;
 738 {
 739   int n_template_parm_scopes = 0;
 740   int seen_specialization_p = 0;
 741   int innermost_specialization_p = 0;
 742   struct binding_level *b;
 743
 744   /* Scan through the template parameter scopes.  */
 745   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 746     {
 747       /* If we see a specialization scope inside a parameter scope,
 748          then something is wrong.  That corresponds to a declaration
 749          like:
 750
 751             template <class T> template <> ...
 752
 753          which is always illegal since [temp.expl.spec] forbids the
 754          specialization of a class member template if the enclosing
 755          class templates are not explicitly specialized as well.  */
 756       if (b->template_spec_p)
 757         {
 758           if (n_template_parm_scopes == 0)
 759             innermost_specialization_p = 1;
 760           else
 761             seen_specialization_p = 1;
 762         }
 763       else if (seen_specialization_p == 1)
 764         return tsk_invalid_member_spec;
 765
 766       ++n_template_parm_scopes;
 767     }
 768
 769   /* Handle explicit instantiations.  */
 770   if (processing_explicit_instantiation)
 771     {
 772       if (n_template_parm_scopes != 0)
 773         /* We've seen a template parameter list during an explicit
 774            instantiation.  For example:
 775
 776              template <class T> template void f(int);
 777
 778            This is erroneous.  */
 779         return tsk_invalid_expl_inst;
 780       else
 781         return tsk_expl_inst;
 782     }
 783
 784   if (n_template_parm_scopes < n_class_scopes)
 785     /* We've not seen enough template headers to match all the
 786        specialized classes present.  For example:
 787
 788          template <class T> void R<T>::S<T>::f(int);
 789
 790        This is illegal; there needs to be one set of template
 791        parameters for each class.  */
 792     return tsk_insufficient_parms;
 793   else if (n_template_parm_scopes == n_class_scopes)
 794     /* We're processing a non-template declaration (even though it may
 795        be a member of a template class.)  For example:
 796
 797          template <class T> void S<T>::f(int);
 798
 799        The `class T' maches the `S<T>', leaving no template headers
 800        corresponding to the `f'.  */
 801     return tsk_none;
 802   else if (n_template_parm_scopes > n_class_scopes + 1)
 803     /* We've got too many template headers.  For example:
 804
 805          template <> template <class T> void f (T);
 806
 807        There need to be more enclosing classes.  */
 808     return tsk_excessive_parms;
 809   else
 810     /* This must be a template.  It's of the form:
 811
 812          template <class T> template <class U> void S<T>::f(U);
 813
 814        This is a specialization if the innermost level was a
 815        specialization; otherwise it's just a definition of the
 816        template.  */
 817     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 818 }
 819
 820 void
 821 set_class_shadows (shadows)
 822      tree shadows;
 823 {
 824   class_binding_level->class_shadowed = shadows;
 825 }
 826
 827 /* Enter a new binding level.
 828    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 829    not for that of tags.  */
 830
 831 void
 832 pushlevel (tag_transparent)
 833      int tag_transparent;
 834 {
 835   struct binding_level *newlevel;
 836
 837   if (cfun && !doing_semantic_analysis_p ())
 838     return;
 839
 840   /* Reuse or create a struct for this binding level.  */
 841 #if defined(DEBUG_CP_BINDING_LEVELS)
 842   if (0)
 843 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 844   if (free_binding_level)
 845 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 846     {
 847       newlevel = free_binding_level;
 848       free_binding_level = free_binding_level->level_chain;
 849     }
 850   else
 851     newlevel = make_binding_level ();
 852
 853   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 854   GNU_xref_start_scope ((size_t) newlevel);
 855   keep_next_level_flag = 0;
 856 }
 857
 858 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 859    we're not allowed to add any more objects with cleanups to the current
 860    scope, create a new binding level.  */
 861
 862 void
 863 maybe_push_cleanup_level (type)
 864      tree type;
 865 {
 866   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 867       && current_binding_level->more_cleanups_ok == 0)
 868     {
 869       keep_next_level (2);
 870       pushlevel (1);
 871       clear_last_expr ();
 872       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 873     }
 874 }
 875
 876 /* Enter a new scope.  The KIND indicates what kind of scope is being
 877    created.  */
 878
 879 void
 880 begin_scope (sk)
 881      scope_kind sk;
 882 {
 883   pushlevel (0);
 884
 885   switch (sk)
 886     {
 887     case sk_template_spec:
 888       current_binding_level->template_spec_p = 1;
 889       /* Fall through.  */
 890
 891     case sk_template_parms:
 892       current_binding_level->template_parms_p = 1;
 893       break;
 894
 895     default:
 896       abort ();
 897     }
 898 }
 899
 900 /* Exit the current scope.  */
 901
 902 void
 903 finish_scope ()
 904 {
 905   poplevel (0, 0, 0);
 906 }
 907
 908 void
 909 note_level_for_for ()
 910 {
 911   current_binding_level->is_for_scope = 1;
 912 }
 913
 914 /* Record that the current binding level represents a try block.  */
 915
 916 void
 917 note_level_for_try ()
 918 {
 919   current_binding_level->is_try_scope = 1;
 920 }
 921
 922 /* Record that the current binding level represents a catch block.  */
 923
 924 void
 925 note_level_for_catch ()
 926 {
 927   current_binding_level->is_catch_scope = 1;
 928 }
 929
 930 /* For a binding between a name and an entity at a block scope,
 931    this is the `struct binding_level' for the block.  */
 932 #define BINDING_LEVEL(NODE) \
 933   (((struct tree_binding*)(NODE))->scope.level)
 934
 935 /* A free list of CPLUS_BINDING nodes, connected by their
 936    TREE_CHAINs.  */
 937
 938 static tree free_bindings;
 939
 940 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 941    level at which this declaration is being bound.  */
 942
 943 static void
 944 push_binding (id, decl, level)
 945      tree id;
 946      tree decl;
 947      struct binding_level* level;
 948 {
 949   tree binding;
 950
 951   if (free_bindings)
 952     {
 953       binding = free_bindings;
 954       free_bindings = TREE_CHAIN (binding);
 955     }
 956   else
 957     binding = make_node (CPLUS_BINDING);
 958
 959   /* Now, fill in the binding information.  */
 960   BINDING_VALUE (binding) = decl;
 961   BINDING_TYPE (binding) = NULL_TREE;
 962   BINDING_LEVEL (binding) = level;
 963   INHERITED_VALUE_BINDING_P (binding) = 0;
 964   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 965   BINDING_HAS_LEVEL_P (binding) = 1;
 966
 967   /* And put it on the front of the list of bindings for ID.  */
 968   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 969   IDENTIFIER_BINDING (id) = binding;
 970 }
 971
 972 /* ID is already bound in the current scope.  But, DECL is an
 973    additional binding for ID in the same scope.  This is the `struct
 974    stat' hack whereby a non-typedef class-name or enum-name can be
 975    bound at the same level as some other kind of entity.  It's the
 976    responsibility of the caller to check that inserting this name is
 977    legal here.  Returns nonzero if the new binding was successful.  */
 978 static int
 979 add_binding (id, decl)
 980      tree id;
 981      tree decl;
 982 {
 983   tree binding = IDENTIFIER_BINDING (id);
 984   int ok = 1;
 985
 986   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 987     /* The new name is the type name.  */
 988     BINDING_TYPE (binding) = decl;
 989   else if (!BINDING_VALUE (binding))
 990     /* This situation arises when push_class_level_binding moves an
 991        inherited type-binding out of the way to make room for a new
 992        value binding.  */
 993     BINDING_VALUE (binding) = decl;
 994   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 995            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 996     {
 997       /* The old binding was a type name.  It was placed in
 998          BINDING_VALUE because it was thought, at the point it was
 999          declared, to be the only entity with such a name.  Move the
1000          type name into the type slot; it is now hidden by the new
1001          binding.  */
1002       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1003       BINDING_VALUE (binding) = decl;
1004       INHERITED_VALUE_BINDING_P (binding) = 0;
1005     }
1006   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1007            && TREE_CODE (decl) == TYPE_DECL
1008            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1009            && (same_type_p (TREE_TYPE (decl),
1010                             TREE_TYPE (BINDING_VALUE (binding)))
1011                /* If either type involves template parameters, we must
1012                   wait until instantiation.  */
1013                || uses_template_parms (TREE_TYPE (decl))
1014                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
1015     /* We have two typedef-names, both naming the same type to have
1016        the same name.  This is OK because of:
1017
1018          [dcl.typedef]
1019
1020          In a given scope, a typedef specifier can be used to redefine
1021          the name of any type declared in that scope to refer to the
1022          type to which it already refers.  */
1023     ok = 0;
1024   /* There can be two block-scope declarations of the same variable,
1025      so long as they are `extern' declarations.  */
1026   else if (TREE_CODE (decl) == VAR_DECL
1027            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1028            && DECL_EXTERNAL (decl)
1029            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1030     {
1031       duplicate_decls (decl, BINDING_VALUE (binding));
1032       ok = 0;
1033     }
1034   else
1035     {
1036       error ("declaration of `%#D'", decl);
1037       cp_error_at ("conflicts with previous declaration `%#D'",
1038                    BINDING_VALUE (binding));
1039       ok = 0;
1040     }
1041
1042   return ok;
1043 }
1044
1045 /* Add DECL to the list of things declared in B.  */
1046
1047 static void
1048 add_decl_to_level (decl, b)
1049      tree decl;
1050      struct binding_level *b;
1051 {
1052   /* We build up the list in reverse order, and reverse it later if
1053      necessary.  */
1054   TREE_CHAIN (decl) = b->names;
1055   b->names = decl;
1056 }
1057
1058 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1059    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1060    doesn't really belong to this binding level, that it got here
1061    through a using-declaration.  */
1062
1063 void
1064 push_local_binding (id, decl, flags)
1065      tree id;
1066      tree decl;
1067      int flags;
1068 {
1069   struct binding_level *b;
1070
1071   /* Skip over any local classes.  This makes sense if we call
1072      push_local_binding with a friend decl of a local class.  */
1073   b = current_binding_level;
1074   while (b->parm_flag == 2)
1075     b = b->level_chain;
1076
1077   if (lookup_name_current_level (id))
1078     {
1079       /* Supplement the existing binding.  */
1080       if (!add_binding (id, decl))
1081         /* It didn't work.  Something else must be bound at this
1082            level.  Do not add DECL to the list of things to pop
1083            later.  */
1084         return;
1085     }
1086   else
1087     /* Create a new binding.  */
1088     push_binding (id, decl, b);
1089
1090   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1091     /* We must put the OVERLOAD into a TREE_LIST since the
1092        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1093        decls that got here through a using-declaration.  */
1094     decl = build_tree_list (NULL_TREE, decl);
1095
1096   /* And put DECL on the list of things declared by the current
1097      binding level.  */
1098   add_decl_to_level (decl, b);
1099 }
1100
1101 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1102    binding was successful.  */
1103
1104 int
1105 push_class_binding (id, decl)
1106      tree id;
1107      tree decl;
1108 {
1109   int result = 1;
1110   tree binding = IDENTIFIER_BINDING (id);
1111   tree context;
1112
1113   /* Note that we declared this value so that we can issue an error if
1114      this an illegal redeclaration of a name already used for some
1115      other purpose.  */
1116   note_name_declared_in_class (id, decl);
1117
1118   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1119     /* Supplement the existing binding.  */
1120     result = add_binding (id, decl);
1121   else
1122     /* Create a new binding.  */
1123     push_binding (id, decl, class_binding_level);
1124
1125   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1126      class-level declaration.  Note that we do not use DECL here
1127      because of the possibility of the `struct stat' hack; if DECL is
1128      a class-name or enum-name we might prefer a field-name, or some
1129      such.  */
1130   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1131
1132   /* If this is a binding from a base class, mark it as such.  */
1133   binding = IDENTIFIER_BINDING (id);
1134   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1135     {
1136       /* Any implicit typename must be from a base-class.  The
1137          context for an implicit typename declaration is always
1138          the derived class in which the lookup was done, so the checks
1139          based on the context of DECL below will not trigger.  */
1140       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1141         INHERITED_VALUE_BINDING_P (binding) = 1;
1142       else
1143         {
1144           if (TREE_CODE (decl) == OVERLOAD)
1145             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1146           else
1147             {
1148               my_friendly_assert (DECL_P (decl), 0);
1149               context = context_for_name_lookup (decl);
1150             }
1151
1152           if (is_properly_derived_from (current_class_type, context))
1153             INHERITED_VALUE_BINDING_P (binding) = 1;
1154           else
1155             INHERITED_VALUE_BINDING_P (binding) = 0;
1156         }
1157     }
1158   else if (BINDING_VALUE (binding) == decl)
1159     /* We only encounter a TREE_LIST when push_class_decls detects an
1160        ambiguity.  Such an ambiguity can be overridden by a definition
1161        in this class.  */
1162     INHERITED_VALUE_BINDING_P (binding) = 1;
1163
1164   return result;
1165 }
1166
1167 /* Remove the binding for DECL which should be the innermost binding
1168    for ID.  */
1169
1170 static void
1171 pop_binding (id, decl)
1172      tree id;
1173      tree decl;
1174 {
1175   tree binding;
1176
1177   if (id == NULL_TREE)
1178     /* It's easiest to write the loops that call this function without
1179        checking whether or not the entities involved have names.  We
1180        get here for such an entity.  */
1181     return;
1182
1183   /* Get the innermost binding for ID.  */
1184   binding = IDENTIFIER_BINDING (id);
1185
1186   /* The name should be bound.  */
1187   my_friendly_assert (binding != NULL_TREE, 0);
1188
1189   /* The DECL will be either the ordinary binding or the type
1190      binding for this identifier.  Remove that binding.  */
1191   if (BINDING_VALUE (binding) == decl)
1192     BINDING_VALUE (binding) = NULL_TREE;
1193   else if (BINDING_TYPE (binding) == decl)
1194     BINDING_TYPE (binding) = NULL_TREE;
1195   else
1196     abort ();
1197
1198   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1199     {
1200       /* We're completely done with the innermost binding for this
1201          identifier.  Unhook it from the list of bindings.  */
1202       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1203
1204       /* Add it to the free list.  */
1205       TREE_CHAIN (binding) = free_bindings;
1206       free_bindings = binding;
1207
1208       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1209          it.  */
1210       BINDING_LEVEL (binding) = NULL;
1211     }
1212 }
1213
1214 /* When a label goes out of scope, check to see if that label was used
1215    in a valid manner, and issue any appropriate warnings or errors.  */
1216
1217 static void
1218 pop_label (label, old_value)
1219      tree label;
1220      tree old_value;
1221 {
1222   if (!processing_template_decl && doing_semantic_analysis_p ())
1223     {
1224       if (DECL_INITIAL (label) == NULL_TREE)
1225         {
1226           cp_error_at ("label `%D' used but not defined", label);
1227           /* Avoid crashing later.  */
1228           define_label (input_filename, 1, DECL_NAME (label));
1229         }
1230       else if (warn_unused_label && !TREE_USED (label))
1231         cp_warning_at ("label `%D' defined but not used", label);
1232     }
1233
1234   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1235 }
1236
1237 /* At the end of a function, all labels declared within the function
1238    go out of scope.  BLOCK is the top-level block for the
1239    function.  */
1240
1241 static void
1242 pop_labels (block)
1243      tree block;
1244 {
1245   struct named_label_list *link;
1246
1247   /* Clear out the definitions of all label names, since their scopes
1248      end here.  */
1249   for (link = named_labels; link; link = link->next)
1250     {
1251       pop_label (link->label_decl, link->old_value);
1252       /* Put the labels into the "variables" of the top-level block,
1253          so debugger can see them.  */
1254       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1255       BLOCK_VARS (block) = link->label_decl;
1256     }
1257
1258   named_labels = NULL;
1259 }
1260
1261 /* Exit a binding level.
1262    Pop the level off, and restore the state of the identifier-decl mappings
1263    that were in effect when this level was entered.
1264
1265    If KEEP == 1, this level had explicit declarations, so
1266    and create a "block" (a BLOCK node) for the level
1267    to record its declarations and subblocks for symbol table output.
1268
1269    If FUNCTIONBODY is nonzero, this level is the body of a function,
1270    so create a block as if KEEP were set and also clear out all
1271    label names.
1272
1273    If REVERSE is nonzero, reverse the order of decls before putting
1274    them into the BLOCK.  */
1275
1276 tree
1277 poplevel (keep, reverse, functionbody)
1278      int keep;
1279      int reverse;
1280      int functionbody;
1281 {
1282   register tree link;
1283   /* The chain of decls was accumulated in reverse order.
1284      Put it into forward order, just for cleanliness.  */
1285   tree decls;
1286   int tmp = functionbody;
1287   int real_functionbody;
1288   tree tags;
1289   tree subblocks;
1290   tree block = NULL_TREE;
1291   tree decl;
1292   int leaving_for_scope;
1293
1294   if (cfun && !doing_semantic_analysis_p ())
1295     return NULL_TREE;
1296
1297   my_friendly_assert (current_binding_level->parm_flag != 2,
1298                       19990916);
1299
1300   real_functionbody = (current_binding_level->keep == 2
1301                        ? ((functionbody = 0), tmp) : functionbody);
1302   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1303   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1304
1305   my_friendly_assert (!current_binding_level->class_shadowed,
1306                       19990414);
1307
1308   /* We used to use KEEP == 2 to indicate that the new block should go
1309      at the beginning of the list of blocks at this binding level,
1310      rather than the end.  This hack is no longer used.  */
1311   my_friendly_assert (keep == 0 || keep == 1, 0);
1312
1313   GNU_xref_end_scope ((size_t) current_binding_level,
1314                       (size_t) current_binding_level->level_chain,
1315                       current_binding_level->parm_flag,
1316                       current_binding_level->keep);
1317
1318   if (current_binding_level->keep == 1)
1319     keep = 1;
1320
1321   /* Any uses of undefined labels, and any defined labels, now operate
1322      under constraints of next binding contour.  */
1323   if (cfun && !functionbody)
1324     {
1325       struct binding_level *level_chain;
1326       level_chain = current_binding_level->level_chain;
1327       if (level_chain)
1328         {
1329           struct named_label_use_list *uses;
1330           struct named_label_list *labels;
1331           for (labels = named_labels; labels; labels = labels->next)
1332             if (labels->binding_level == current_binding_level)
1333               {
1334                 tree decl;
1335                 if (current_binding_level->is_try_scope)
1336                   labels->in_try_scope = 1;
1337                 if (current_binding_level->is_catch_scope)
1338                   labels->in_catch_scope = 1;
1339                 for (decl = labels->names_in_scope; decl;
1340                      decl = TREE_CHAIN (decl))
1341                   if (decl_jump_unsafe (decl))
1342                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1343                                                    labels->bad_decls);
1344                 labels->binding_level = level_chain;
1345                 labels->names_in_scope = level_chain->names;
1346               }
1347
1348           for (uses = named_label_uses; uses; uses = uses->next)
1349             if (uses->binding_level == current_binding_level)
1350               {
1351                 uses->binding_level = level_chain;
1352                 uses->names_in_scope = level_chain->names;
1353               }
1354         }
1355     }
1356
1357   /* Get the decls in the order they were written.
1358      Usually current_binding_level->names is in reverse order.
1359      But parameter decls were previously put in forward order.  */
1360
1361   if (reverse)
1362     current_binding_level->names
1363       = decls = nreverse (current_binding_level->names);
1364   else
1365     decls = current_binding_level->names;
1366
1367   /* Output any nested inline functions within this block
1368      if they weren't already output.  */
1369   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1370     if (TREE_CODE (decl) == FUNCTION_DECL
1371         && ! TREE_ASM_WRITTEN (decl)
1372         && DECL_INITIAL (decl) != NULL_TREE
1373         && TREE_ADDRESSABLE (decl)
1374         && decl_function_context (decl) == current_function_decl)
1375       {
1376         /* If this decl was copied from a file-scope decl
1377            on account of a block-scope extern decl,
1378            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1379         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1380           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1381         else
1382           {
1383             push_function_context ();
1384             output_inline_function (decl);
1385             pop_function_context ();
1386           }
1387       }
1388
1389   /* When not in function-at-a-time mode, expand_end_bindings will
1390      warn about unused variables.  But, in function-at-a-time mode
1391      expand_end_bindings is not passed the list of variables in the
1392      current scope, and therefore no warning is emitted.  So, we
1393      explicitly warn here.  */
1394   if (!processing_template_decl)
1395     warn_about_unused_variables (getdecls ());
1396
1397   /* If there were any declarations or structure tags in that level,
1398      or if this level is a function body,
1399      create a BLOCK to record them for the life of this function.  */
1400   block = NULL_TREE;
1401   if (keep == 1 || functionbody)
1402     block = make_node (BLOCK);
1403   if (block != NULL_TREE)
1404     {
1405       BLOCK_VARS (block) = decls;
1406       BLOCK_SUBBLOCKS (block) = subblocks;
1407     }
1408
1409   /* In each subblock, record that this is its superior.  */
1410   if (keep >= 0)
1411     for (link = subblocks; link; link = TREE_CHAIN (link))
1412       BLOCK_SUPERCONTEXT (link) = block;
1413
1414   /* We still support the old for-scope rules, whereby the variables
1415      in a for-init statement were in scope after the for-statement
1416      ended.  We only use the new rules in flag_new_for_scope is
1417      nonzero.  */
1418   leaving_for_scope
1419     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1420
1421   /* Remove declarations for all the DECLs in this level.  */
1422   for (link = decls; link; link = TREE_CHAIN (link))
1423     {
1424       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1425           && DECL_NAME (link))
1426         {
1427           tree outer_binding
1428             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1429           tree ns_binding;
1430
1431           if (!outer_binding)
1432             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1433           else
1434             ns_binding = NULL_TREE;
1435
1436           if (outer_binding
1437               && (BINDING_LEVEL (outer_binding)
1438                   == current_binding_level->level_chain))
1439             /* We have something like:
1440
1441                  int i;
1442                  for (int i; ;);
1443
1444                and we are leaving the `for' scope.  There's no reason to
1445                keep the binding of the inner `i' in this case.  */
1446             pop_binding (DECL_NAME (link), link);
1447           else if ((outer_binding
1448                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1449                         == TYPE_DECL))
1450                    || (ns_binding
1451                        && TREE_CODE (ns_binding) == TYPE_DECL))
1452             /* Here, we have something like:
1453
1454                  typedef int I;
1455
1456                  void f () {
1457                    for (int I; ;);
1458                  }
1459
1460                We must pop the for-scope binding so we know what's a
1461                type and what isn't.  */
1462             pop_binding (DECL_NAME (link), link);
1463           else
1464             {
1465               /* Mark this VAR_DECL as dead so that we can tell we left it
1466                  there only for backward compatibility.  */
1467               DECL_DEAD_FOR_LOCAL (link) = 1;
1468
1469               /* Keep track of what should of have happenned when we
1470                  popped the binding.  */
1471               if (outer_binding && BINDING_VALUE (outer_binding))
1472                 DECL_SHADOWED_FOR_VAR (link)
1473                   = BINDING_VALUE (outer_binding);
1474
1475               /* Add it to the list of dead variables in the next
1476                  outermost binding to that we can remove these when we
1477                  leave that binding.  */
1478               current_binding_level->level_chain->dead_vars_from_for
1479                 = tree_cons (NULL_TREE, link,
1480                              current_binding_level->level_chain->
1481                              dead_vars_from_for);
1482
1483               /* Although we don't pop the CPLUS_BINDING, we do clear
1484                  its BINDING_LEVEL since the level is going away now.  */
1485               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1486                 = 0;
1487             }
1488         }
1489       else
1490         {
1491           /* Remove the binding.  */
1492           decl = link;
1493           if (TREE_CODE (decl) == TREE_LIST)
1494             decl = TREE_VALUE (decl);
1495           if (DECL_P (decl))
1496             pop_binding (DECL_NAME (decl), decl);
1497           else if (TREE_CODE (decl) == OVERLOAD)
1498             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1499           else
1500             abort ();
1501         }
1502     }
1503
1504   /* Remove declarations for any `for' variables from inner scopes
1505      that we kept around.  */
1506   for (link = current_binding_level->dead_vars_from_for;
1507        link; link = TREE_CHAIN (link))
1508     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1509
1510   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1511   for (link = current_binding_level->type_shadowed;
1512        link; link = TREE_CHAIN (link))
1513     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1514
1515   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1516   for (link = current_binding_level->shadowed_labels;
1517        link;
1518        link = TREE_CHAIN (link))
1519     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1520
1521   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1522      list if a `using' declaration put them there.  The debugging
1523      back-ends won't understand OVERLOAD, so we remove them here.
1524      Because the BLOCK_VARS are (temporarily) shared with
1525      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1526      popped all the bindings.  */
1527   if (block)
1528     {
1529       tree* d;
1530
1531       for (d = &BLOCK_VARS (block); *d; )
1532         {
1533           if (TREE_CODE (*d) == TREE_LIST)
1534             *d = TREE_CHAIN (*d);
1535           else
1536             d = &TREE_CHAIN (*d);
1537         }
1538     }
1539
1540   /* If the level being exited is the top level of a function,
1541      check over all the labels.  */
1542   if (functionbody)
1543     {
1544       /* Since this is the top level block of a function, the vars are
1545          the function's parameters.  Don't leave them in the BLOCK
1546          because they are found in the FUNCTION_DECL instead.  */
1547       BLOCK_VARS (block) = 0;
1548       pop_labels (block);
1549     }
1550
1551   tmp = current_binding_level->keep;
1552
1553   pop_binding_level ();
1554   if (functionbody)
1555     DECL_INITIAL (current_function_decl) = block;
1556   else if (block)
1557     current_binding_level->blocks
1558       = chainon (current_binding_level->blocks, block);
1559
1560   /* If we did not make a block for the level just exited,
1561      any blocks made for inner levels
1562      (since they cannot be recorded as subblocks in that level)
1563      must be carried forward so they will later become subblocks
1564      of something else.  */
1565   else if (subblocks)
1566     current_binding_level->blocks
1567       = chainon (current_binding_level->blocks, subblocks);
1568
1569   /* Each and every BLOCK node created here in `poplevel' is important
1570      (e.g. for proper debugging information) so if we created one
1571      earlier, mark it as "used".  */
1572   if (block)
1573     TREE_USED (block) = 1;
1574
1575   /* Take care of compiler's internal binding structures.  */
1576   if (tmp == 2)
1577     {
1578       tree scope_stmts;
1579
1580       scope_stmts
1581         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1582       if (block)
1583         {
1584           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1585           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1586         }
1587
1588       block = poplevel (keep, reverse, functionbody);
1589     }
1590
1591   return block;
1592 }
1593
1594 /* Delete the node BLOCK from the current binding level.
1595    This is used for the block inside a stmt expr ({...})
1596    so that the block can be reinserted where appropriate.  */
1597
1598 void
1599 delete_block (block)
1600      tree block;
1601 {
1602   tree t;
1603   if (current_binding_level->blocks == block)
1604     current_binding_level->blocks = TREE_CHAIN (block);
1605   for (t = current_binding_level->blocks; t;)
1606     {
1607       if (TREE_CHAIN (t) == block)
1608         TREE_CHAIN (t) = TREE_CHAIN (block);
1609       else
1610         t = TREE_CHAIN (t);
1611     }
1612   TREE_CHAIN (block) = NULL_TREE;
1613   /* Clear TREE_USED which is always set by poplevel.
1614      The flag is set again if insert_block is called.  */
1615   TREE_USED (block) = 0;
1616 }
1617
1618 /* Insert BLOCK at the end of the list of subblocks of the
1619    current binding level.  This is used when a BIND_EXPR is expanded,
1620    to handle the BLOCK node inside the BIND_EXPR.  */
1621
1622 void
1623 insert_block (block)
1624      tree block;
1625 {
1626   TREE_USED (block) = 1;
1627   current_binding_level->blocks
1628     = chainon (current_binding_level->blocks, block);
1629 }
1630
1631 /* Set the BLOCK node for the innermost scope
1632    (the one we are currently in).  */
1633
1634 void
1635 set_block (block)
1636     tree block ATTRIBUTE_UNUSED;
1637 {
1638   /* The RTL expansion machinery requires us to provide this callback,
1639      but it is not applicable in function-at-a-time mode.  */
1640   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1641 }
1642
1643 /* Do a pushlevel for class declarations.  */
1644
1645 void
1646 pushlevel_class ()
1647 {
1648   register struct binding_level *newlevel;
1649
1650   /* Reuse or create a struct for this binding level.  */
1651 #if defined(DEBUG_CP_BINDING_LEVELS)
1652   if (0)
1653 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1654   if (free_binding_level)
1655 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1656     {
1657       newlevel = free_binding_level;
1658       free_binding_level = free_binding_level->level_chain;
1659     }
1660   else
1661     newlevel = make_binding_level ();
1662
1663 #if defined(DEBUG_CP_BINDING_LEVELS)
1664   is_class_level = 1;
1665 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1666
1667   push_binding_level (newlevel, 0, 0);
1668
1669   class_binding_level = current_binding_level;
1670   class_binding_level->parm_flag = 2;
1671   class_binding_level->this_class = current_class_type;
1672 }
1673
1674 /* ...and a poplevel for class declarations.  */
1675
1676 void
1677 poplevel_class ()
1678 {
1679   register struct binding_level *level = class_binding_level;
1680   tree shadowed;
1681
1682   my_friendly_assert (level != 0, 354);
1683
1684   /* If we're leaving a toplevel class, don't bother to do the setting
1685      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1686      shouldn't even be used when current_class_type isn't set, and second,
1687      if we don't touch it here, we're able to use the cache effect if the
1688      next time we're entering a class scope, it is the same class.  */
1689   if (current_class_depth != 1)
1690     {
1691       struct binding_level* b;
1692
1693       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1694       for (shadowed = level->class_shadowed;
1695            shadowed;
1696            shadowed = TREE_CHAIN (shadowed))
1697         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1698
1699       /* Find the next enclosing class, and recreate
1700          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1701       b = level->level_chain;
1702       while (b && b->parm_flag != 2)
1703         b = b->level_chain;
1704
1705       if (b)
1706         for (shadowed = b->class_shadowed;
1707              shadowed;
1708              shadowed = TREE_CHAIN (shadowed))
1709           {
1710             tree t;
1711
1712             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1713             while (t && BINDING_LEVEL (t) != b)
1714               t = TREE_CHAIN (t);
1715
1716             if (t)
1717               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1718                 = BINDING_VALUE (t);
1719           }
1720     }
1721   else
1722     /* Remember to save what IDENTIFIER's were bound in this scope so we
1723        can recover from cache misses.  */
1724     {
1725       previous_class_type = current_class_type;
1726       previous_class_values = class_binding_level->class_shadowed;
1727     }
1728   for (shadowed = level->type_shadowed;
1729        shadowed;
1730        shadowed = TREE_CHAIN (shadowed))
1731     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1732
1733   /* Remove the bindings for all of the class-level declarations.  */
1734   for (shadowed = level->class_shadowed;
1735        shadowed;
1736        shadowed = TREE_CHAIN (shadowed))
1737     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1738
1739   GNU_xref_end_scope ((size_t) class_binding_level,
1740                       (size_t) class_binding_level->level_chain,
1741                       class_binding_level->parm_flag,
1742                       class_binding_level->keep);
1743
1744   /* Now, pop out of the binding level which we created up in the
1745      `pushlevel_class' routine.  */
1746 #if defined(DEBUG_CP_BINDING_LEVELS)
1747   is_class_level = 1;
1748 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1749
1750   pop_binding_level ();
1751 }
1752
1753 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1754    for any names in enclosing classes.  */
1755
1756 void
1757 clear_identifier_class_values ()
1758 {
1759   tree t;
1760
1761   if (!class_binding_level)
1762     return;
1763
1764   for (t = class_binding_level->class_shadowed;
1765        t;
1766        t = TREE_CHAIN (t))
1767     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1768 }
1769
1770 /* Returns non-zero if T is a virtual function table.  */
1771
1772 int
1773 vtable_decl_p (t, data)
1774      tree t;
1775      void *data ATTRIBUTE_UNUSED;
1776 {
1777   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1778 }
1779
1780 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1781    functions.  */
1782
1783 int
1784 vtype_decl_p (t, data)
1785      tree t;
1786      void *data ATTRIBUTE_UNUSED;
1787 {
1788   return (TREE_CODE (t) == TYPE_DECL
1789           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1790           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1791 }
1792
1793 /* Return the declarations that are members of the namespace NS.  */
1794
1795 tree
1796 cp_namespace_decls (ns)
1797      tree ns;
1798 {
1799   return NAMESPACE_LEVEL (ns)->names;
1800 }
1801
1802 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1803    itself, calling F for each.  The DATA is passed to F as well.  */
1804
1805 static int
1806 walk_namespaces_r (namespace, f, data)
1807      tree namespace;
1808      walk_namespaces_fn f;
1809      void *data;
1810 {
1811   tree current;
1812   int result = 0;
1813
1814   result |= (*f) (namespace, data);
1815
1816   for (current = cp_namespace_decls (namespace);
1817        current;
1818        current = TREE_CHAIN (current))
1819     {
1820       if (TREE_CODE (current) != NAMESPACE_DECL
1821           || DECL_NAMESPACE_ALIAS (current))
1822         continue;
1823
1824       /* We found a namespace.  */
1825       result |= walk_namespaces_r (current, f, data);
1826     }
1827
1828   return result;
1829 }
1830
1831 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1832    F as well.  */
1833
1834 int
1835 walk_namespaces (f, data)
1836      walk_namespaces_fn f;
1837      void *data;
1838 {
1839   return walk_namespaces_r (global_namespace, f, data);
1840 }
1841
1842 struct walk_globals_data {
1843   walk_globals_pred p;
1844   walk_globals_fn f;
1845   void *data;
1846 };
1847
1848 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1849    for which P returns non-zero, call F with its address.  If any call
1850    to F returns a non-zero value, return a non-zero value.  */
1851
1852 static int
1853 walk_globals_r (namespace, data)
1854      tree namespace;
1855      void *data;
1856 {
1857   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1858   walk_globals_pred p = wgd->p;
1859   walk_globals_fn f = wgd->f;
1860   void *d = wgd->data;
1861   tree *t;
1862   int result = 0;
1863
1864   t = &NAMESPACE_LEVEL (namespace)->names;
1865
1866   while (*t)
1867     {
1868       tree glbl = *t;
1869
1870       if ((*p) (glbl, d))
1871         result |= (*f) (t, d);
1872
1873       /* If F changed *T, then *T still points at the next item to
1874          examine.  */
1875       if (*t == glbl)
1876         t = &TREE_CHAIN (*t);
1877     }
1878
1879   return result;
1880 }
1881
1882 /* Walk the global declarations.  Whenever one is found for which P
1883    returns non-zero, call F with its address.  If any call to F
1884    returns a non-zero value, return a non-zero value.  */
1885
1886 int
1887 walk_globals (p, f, data)
1888      walk_globals_pred p;
1889      walk_globals_fn f;
1890      void *data;
1891 {
1892   struct walk_globals_data wgd;
1893   wgd.p = p;
1894   wgd.f = f;
1895   wgd.data = data;
1896
1897   return walk_namespaces (walk_globals_r, &wgd);
1898 }
1899
1900 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1901    DATA is non-NULL, this is the last time we will call
1902    wrapup_global_declarations for this NAMESPACE.  */
1903
1904 int
1905 wrapup_globals_for_namespace (namespace, data)
1906      tree namespace;
1907      void *data;
1908 {
1909   tree globals = cp_namespace_decls (namespace);
1910   int len = list_length (globals);
1911   tree *vec = (tree *) alloca (sizeof (tree) * len);
1912   int i;
1913   int result;
1914   tree decl;
1915   int last_time = (data != 0);
1916
1917   if (last_time && namespace == global_namespace)
1918     /* Let compile_file handle the global namespace.  */
1919     return 0;
1920
1921   /* Process the decls in reverse order--earliest first.
1922      Put them into VEC from back to front, then take out from front.  */
1923   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1924     vec[len - i - 1] = decl;
1925
1926   if (last_time)
1927     {
1928       check_global_declarations (vec, len);
1929       return 0;
1930     }
1931
1932   /* Temporarily mark vtables as external.  That prevents
1933      wrapup_global_declarations from writing them out; we must process
1934      them ourselves in finish_vtable_vardecl.  */
1935   for (i = 0; i < len; ++i)
1936     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1937       {
1938         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1939         DECL_EXTERNAL (vec[i]) = 1;
1940       }
1941
1942   /* Write out any globals that need to be output.  */
1943   result = wrapup_global_declarations (vec, len);
1944
1945   /* Undo the hack to DECL_EXTERNAL above.  */
1946   for (i = 0; i < len; ++i)
1947     if (vtable_decl_p (vec[i], /*data=*/0)
1948         && DECL_NOT_REALLY_EXTERN (vec[i]))
1949       {
1950         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1951         DECL_EXTERNAL (vec[i]) = 0;
1952       }
1953
1954   return result;
1955 }
1956
1957 \f
1958 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1959
1960 static void
1961 mark_binding_level (arg)
1962      void *arg;
1963 {
1964   struct binding_level *lvl = *(struct binding_level **)arg;
1965
1966   for (; lvl; lvl = lvl->level_chain)
1967     {
1968       ggc_mark_tree (lvl->names);
1969       ggc_mark_tree (lvl->tags);
1970       ggc_mark_tree (lvl->usings);
1971       ggc_mark_tree (lvl->using_directives);
1972       ggc_mark_tree (lvl->class_shadowed);
1973       ggc_mark_tree (lvl->type_shadowed);
1974       ggc_mark_tree (lvl->shadowed_labels);
1975       ggc_mark_tree (lvl->blocks);
1976       ggc_mark_tree (lvl->this_class);
1977       ggc_mark_tree (lvl->incomplete);
1978       ggc_mark_tree (lvl->dead_vars_from_for);
1979     }
1980 }
1981
1982 static void
1983 mark_named_label_lists (labs, uses)
1984      void *labs;
1985      void *uses;
1986 {
1987   struct named_label_list *l = *(struct named_label_list **)labs;
1988   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1989
1990   for (; l; l = l->next)
1991     {
1992       ggc_mark (l);
1993       mark_binding_level (l->binding_level);
1994       ggc_mark_tree (l->old_value);
1995       ggc_mark_tree (l->label_decl);
1996       ggc_mark_tree (l->bad_decls);
1997     }
1998
1999   for (; u; u = u->next)
2000     ggc_mark (u);
2001 }
2002 \f
2003 /* For debugging.  */
2004 static int no_print_functions = 0;
2005 static int no_print_builtins = 0;
2006
2007 void
2008 print_binding_level (lvl)
2009      struct binding_level *lvl;
2010 {
2011   tree t;
2012   int i = 0, len;
2013   fprintf (stderr, " blocks=");
2014   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE lvl->blocks);
2015   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2016            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2017   if (lvl->tag_transparent)
2018     fprintf (stderr, " tag-transparent");
2019   if (lvl->more_cleanups_ok)
2020     fprintf (stderr, " more-cleanups-ok");
2021   if (lvl->have_cleanups)
2022     fprintf (stderr, " have-cleanups");
2023   fprintf (stderr, "\n");
2024   if (lvl->names)
2025     {
2026       fprintf (stderr, " names:\t");
2027       /* We can probably fit 3 names to a line?  */
2028       for (t = lvl->names; t; t = TREE_CHAIN (t))
2029         {
2030           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2031             continue;
2032           if (no_print_builtins
2033               && (TREE_CODE (t) == TYPE_DECL)
2034               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2035             continue;
2036
2037           /* Function decls tend to have longer names.  */
2038           if (TREE_CODE (t) == FUNCTION_DECL)
2039             len = 3;
2040           else
2041             len = 2;
2042           i += len;
2043           if (i > 6)
2044             {
2045               fprintf (stderr, "\n\t");
2046               i = len;
2047             }
2048           print_node_brief (stderr, "", t, 0);
2049           if (t == error_mark_node)
2050             break;
2051         }
2052       if (i)
2053         fprintf (stderr, "\n");
2054     }
2055   if (lvl->tags)
2056     {
2057       fprintf (stderr, " tags:\t");
2058       i = 0;
2059       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2060         {
2061           if (TREE_PURPOSE (t) == NULL_TREE)
2062             len = 3;
2063           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2064             len = 2;
2065           else
2066             len = 4;
2067           i += len;
2068           if (i > 5)
2069             {
2070               fprintf (stderr, "\n\t");
2071               i = len;
2072             }
2073           if (TREE_PURPOSE (t) == NULL_TREE)
2074             {
2075               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2076               fprintf (stderr, ">");
2077             }
2078           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2079             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2080           else
2081             {
2082               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2083               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2084               fprintf (stderr, ">");
2085             }
2086         }
2087       if (i)
2088         fprintf (stderr, "\n");
2089     }
2090   if (lvl->class_shadowed)
2091     {
2092       fprintf (stderr, " class-shadowed:");
2093       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2094         {
2095           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2096         }
2097       fprintf (stderr, "\n");
2098     }
2099   if (lvl->type_shadowed)
2100     {
2101       fprintf (stderr, " type-shadowed:");
2102       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2103         {
2104           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2105         }
2106       fprintf (stderr, "\n");
2107     }
2108 }
2109
2110 void
2111 print_other_binding_stack (stack)
2112      struct binding_level *stack;
2113 {
2114   struct binding_level *level;
2115   for (level = stack; level != global_binding_level; level = level->level_chain)
2116     {
2117       fprintf (stderr, "binding level ");
2118       fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE level);
2119       fprintf (stderr, "\n");
2120       print_binding_level (level);
2121     }
2122 }
2123
2124 void
2125 print_binding_stack ()
2126 {
2127   struct binding_level *b;
2128   fprintf (stderr, "current_binding_level=");
2129   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE current_binding_level);
2130   fprintf (stderr, "\nclass_binding_level=");
2131   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE class_binding_level);
2132   fprintf (stderr, "\nglobal_binding_level=");
2133   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE global_binding_level);
2134   fprintf (stderr, "\n");
2135   if (class_binding_level)
2136     {
2137       for (b = class_binding_level; b; b = b->level_chain)
2138         if (b == current_binding_level)
2139           break;
2140       if (b)
2141         b = class_binding_level;
2142       else
2143         b = current_binding_level;
2144     }
2145   else
2146     b = current_binding_level;
2147   print_other_binding_stack (b);
2148   fprintf (stderr, "global:\n");
2149   print_binding_level (global_binding_level);
2150 }
2151
2152 /* Namespace binding access routines: The namespace_bindings field of
2153    the identifier is polymorphic, with three possible values:
2154    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2155    indicating the BINDING_VALUE of global_namespace. */
2156
2157 /* Check whether the a binding for the name to scope is known.
2158    Assumes that the bindings of the name are already a list
2159    of bindings. Returns the binding found, or NULL_TREE. */
2160
2161 static tree
2162 find_binding (name, scope)
2163      tree name;
2164      tree scope;
2165 {
2166   tree iter, prev = NULL_TREE;
2167
2168   scope = ORIGINAL_NAMESPACE (scope);
2169
2170   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2171        iter = TREE_CHAIN (iter))
2172     {
2173       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2174       if (BINDING_SCOPE (iter) == scope)
2175         {
2176           /* Move binding found to the front of the list, so
2177              subsequent lookups will find it faster. */
2178           if (prev)
2179             {
2180               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2181               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2182               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2183             }
2184           return iter;
2185         }
2186       prev = iter;
2187     }
2188   return NULL_TREE;
2189 }
2190
2191 /* Always returns a binding for name in scope. If the
2192    namespace_bindings is not a list, convert it to one first.
2193    If no binding is found, make a new one. */
2194
2195 tree
2196 binding_for_name (name, scope)
2197      tree name;
2198      tree scope;
2199 {
2200   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2201   tree result;
2202
2203   scope = ORIGINAL_NAMESPACE (scope);
2204
2205   if (b && TREE_CODE (b) != CPLUS_BINDING)
2206     {
2207       /* Get rid of optimization for global scope. */
2208       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2209       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2210       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2211     }
2212   if (b && (result = find_binding (name, scope)))
2213     return result;
2214   /* Not found, make a new one. */
2215   result = make_node (CPLUS_BINDING);
2216   TREE_CHAIN (result) = b;
2217   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2218   BINDING_SCOPE (result) = scope;
2219   BINDING_TYPE (result) = NULL_TREE;
2220   BINDING_VALUE (result) = NULL_TREE;
2221   return result;
2222 }
2223
2224 /* Return the binding value for name in scope, considering that
2225    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2226
2227 tree
2228 namespace_binding (name, scope)
2229      tree name;
2230      tree scope;
2231 {
2232   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2233   if (b == NULL_TREE)
2234     return NULL_TREE;
2235   if (scope == NULL_TREE)
2236     scope = global_namespace;
2237   if (TREE_CODE (b) != CPLUS_BINDING)
2238     return (scope == global_namespace) ? b : NULL_TREE;
2239   name = find_binding (name,scope);
2240   if (name == NULL_TREE)
2241     return name;
2242   return BINDING_VALUE (name);
2243 }
2244
2245 /* Set the binding value for name in scope. If modifying the binding
2246    of global_namespace is attempted, try to optimize it. */
2247
2248 void
2249 set_namespace_binding (name, scope, val)
2250      tree name;
2251      tree scope;
2252      tree val;
2253 {
2254   tree b;
2255
2256   if (scope == NULL_TREE)
2257     scope = global_namespace;
2258
2259   if (scope == global_namespace)
2260     {
2261       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2262       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2263         {
2264           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2265           return;
2266         }
2267     }
2268   b = binding_for_name (name, scope);
2269   BINDING_VALUE (b) = val;
2270 }
2271
2272 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2273    select a name that is unique to this compilation unit.  */
2274
2275 void
2276 push_namespace (name)
2277      tree name;
2278 {
2279   tree d = NULL_TREE;
2280   int need_new = 1;
2281   int implicit_use = 0;
2282   int global = 0;
2283   if (!global_namespace)
2284     {
2285       /* This must be ::. */
2286       my_friendly_assert (name == get_identifier ("::"), 377);
2287       global = 1;
2288     }
2289   else if (!name)
2290     {
2291       /* The name of anonymous namespace is unique for the translation
2292          unit.  */
2293       if (!anonymous_namespace_name)
2294         anonymous_namespace_name = get_file_function_name ('N');
2295       name = anonymous_namespace_name;
2296       d = IDENTIFIER_NAMESPACE_VALUE (name);
2297       if (d)
2298         /* Reopening anonymous namespace.  */
2299         need_new = 0;
2300       implicit_use = 1;
2301     }
2302   else
2303     {
2304       /* Check whether this is an extended namespace definition. */
2305       d = IDENTIFIER_NAMESPACE_VALUE (name);
2306       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2307         {
2308           need_new = 0;
2309           if (DECL_NAMESPACE_ALIAS (d))
2310             {
2311               error ("namespace alias `%D' not allowed here, assuming `%D'",
2312                         d, DECL_NAMESPACE_ALIAS (d));
2313               d = DECL_NAMESPACE_ALIAS (d);
2314             }
2315         }
2316     }
2317
2318   if (need_new)
2319     {
2320       /* Make a new namespace, binding the name to it. */
2321       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2322       /* The global namespace is not pushed, and the global binding
2323          level is set elsewhere.  */
2324       if (!global)
2325         {
2326           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2327           d = pushdecl (d);
2328           pushlevel (0);
2329           declare_namespace_level ();
2330           NAMESPACE_LEVEL (d) = current_binding_level;
2331         }
2332     }
2333   else
2334     resume_binding_level (NAMESPACE_LEVEL (d));
2335
2336   if (implicit_use)
2337     do_using_directive (d);
2338   /* Enter the name space. */
2339   current_namespace = d;
2340 }
2341
2342 /* Pop from the scope of the current namespace.  */
2343
2344 void
2345 pop_namespace ()
2346 {
2347   my_friendly_assert (current_namespace != global_namespace, 20010801);
2348   current_namespace = CP_DECL_CONTEXT (current_namespace);
2349   /* The binding level is not popped, as it might be re-opened later.  */
2350   suspend_binding_level ();
2351 }
2352
2353 /* Push into the scope of the namespace NS, even if it is deeply
2354    nested within another namespace.  */
2355
2356 void
2357 push_nested_namespace (ns)
2358      tree ns;
2359 {
2360   if (ns == global_namespace)
2361     push_to_top_level ();
2362   else
2363     {
2364       push_nested_namespace (CP_DECL_CONTEXT (ns));
2365       push_namespace (DECL_NAME (ns));
2366     }
2367 }
2368
2369 /* Pop back from the scope of the namespace NS, which was previously
2370    entered with push_nested_namespace.  */
2371
2372 void
2373 pop_nested_namespace (ns)
2374      tree ns;
2375 {
2376   while (ns != global_namespace)
2377     {
2378       pop_namespace ();
2379       ns = CP_DECL_CONTEXT (ns);
2380     }
2381
2382   pop_from_top_level ();
2383 }
2384
2385 \f
2386 /* Subroutines for reverting temporarily to top-level for instantiation
2387    of templates and such.  We actually need to clear out the class- and
2388    local-value slots of all identifiers, so that only the global values
2389    are at all visible.  Simply setting current_binding_level to the global
2390    scope isn't enough, because more binding levels may be pushed.  */
2391 struct saved_scope *scope_chain;
2392
2393 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2394
2395 static void
2396 mark_saved_scope (arg)
2397      void *arg;
2398 {
2399   struct saved_scope *t = *(struct saved_scope **)arg;
2400   while (t)
2401     {
2402       mark_binding_level (&t->class_bindings);
2403       ggc_mark_tree (t->old_bindings);
2404       ggc_mark_tree (t->old_namespace);
2405       ggc_mark_tree (t->decl_ns_list);
2406       ggc_mark_tree (t->class_name);
2407       ggc_mark_tree (t->class_type);
2408       ggc_mark_tree (t->access_specifier);
2409       ggc_mark_tree (t->function_decl);
2410       if (t->lang_base)
2411         ggc_mark_tree_varray (t->lang_base);
2412       ggc_mark_tree (t->lang_name);
2413       ggc_mark_tree (t->template_parms);
2414       ggc_mark_tree (t->x_previous_class_type);
2415       ggc_mark_tree (t->x_previous_class_values);
2416       ggc_mark_tree (t->x_saved_tree);
2417       ggc_mark_tree (t->incomplete);
2418       ggc_mark_tree (t->lookups);
2419
2420       mark_stmt_tree (&t->x_stmt_tree);
2421       mark_binding_level (&t->bindings);
2422       t = t->prev;
2423     }
2424 }
2425
2426 static tree
2427 store_bindings (names, old_bindings)
2428      tree names, old_bindings;
2429 {
2430   tree t;
2431   tree search_bindings = old_bindings;
2432
2433   for (t = names; t; t = TREE_CHAIN (t))
2434     {
2435       tree binding, t1, id;
2436
2437       if (TREE_CODE (t) == TREE_LIST)
2438         id = TREE_PURPOSE (t);
2439       else
2440         id = DECL_NAME (t);
2441
2442       if (!id
2443           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2444              we have no IDENTIFIER_BINDING if we have left the class
2445              scope, but cached the class-level declarations.  */
2446           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2447         continue;
2448
2449       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2450         if (TREE_VEC_ELT (t1, 0) == id)
2451           goto skip_it;
2452
2453       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2454       binding = make_tree_vec (4);
2455       TREE_VEC_ELT (binding, 0) = id;
2456       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2457       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2458       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2459       IDENTIFIER_BINDING (id) = NULL_TREE;
2460       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2461       TREE_CHAIN (binding) = old_bindings;
2462       old_bindings = binding;
2463     skip_it:
2464       ;
2465     }
2466   return old_bindings;
2467 }
2468
2469 void
2470 maybe_push_to_top_level (pseudo)
2471      int pseudo;
2472 {
2473   struct saved_scope *s;
2474   struct binding_level *b;
2475   tree old_bindings;
2476   int need_pop;
2477
2478   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2479
2480   b = scope_chain ? current_binding_level : 0;
2481
2482   /* If we're in the middle of some function, save our state.  */
2483   if (cfun)
2484     {
2485       need_pop = 1;
2486       push_function_context_to (NULL_TREE);
2487     }
2488   else
2489     need_pop = 0;
2490
2491   old_bindings = NULL_TREE;
2492   if (scope_chain && previous_class_type)
2493     old_bindings = store_bindings (previous_class_values, old_bindings);
2494
2495   /* Have to include global_binding_level, because class-level decls
2496      aren't listed anywhere useful.  */
2497   for (; b; b = b->level_chain)
2498     {
2499       tree t;
2500
2501       /* Template IDs are inserted into the global level. If they were
2502          inserted into namespace level, finish_file wouldn't find them
2503          when doing pending instantiations. Therefore, don't stop at
2504          namespace level, but continue until :: .  */
2505       if (b == global_binding_level || (pseudo && b->template_parms_p))
2506         break;
2507
2508       old_bindings = store_bindings (b->names, old_bindings);
2509       /* We also need to check class_shadowed to save class-level type
2510          bindings, since pushclass doesn't fill in b->names.  */
2511       if (b->parm_flag == 2)
2512         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2513
2514       /* Unwind type-value slots back to top level.  */
2515       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2516         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2517     }
2518   s->prev = scope_chain;
2519   s->old_bindings = old_bindings;
2520   s->bindings = b;
2521   s->need_pop_function_context = need_pop;
2522   s->function_decl = current_function_decl;
2523
2524   scope_chain = s;
2525   current_function_decl = NULL_TREE;
2526   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2527   current_lang_name = lang_name_cplusplus;
2528   current_namespace = global_namespace;
2529 }
2530
2531 void
2532 push_to_top_level ()
2533 {
2534   maybe_push_to_top_level (0);
2535 }
2536
2537 void
2538 pop_from_top_level ()
2539 {
2540   struct saved_scope *s = scope_chain;
2541   tree t;
2542
2543   /* Clear out class-level bindings cache.  */
2544   if (previous_class_type)
2545     invalidate_class_lookup_cache ();
2546
2547   VARRAY_FREE (current_lang_base);
2548
2549   scope_chain = s->prev;
2550   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2551     {
2552       tree id = TREE_VEC_ELT (t, 0);
2553
2554       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2555       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2556       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2557     }
2558
2559   /* If we were in the middle of compiling a function, restore our
2560      state.  */
2561   if (s->need_pop_function_context)
2562     pop_function_context_from (NULL_TREE);
2563   current_function_decl = s->function_decl;
2564
2565   free (s);
2566 }
2567 \f
2568 /* Push a definition of struct, union or enum tag "name".
2569    into binding_level "b".   "type" should be the type node,
2570    We assume that the tag "name" is not already defined.
2571
2572    Note that the definition may really be just a forward reference.
2573    In that case, the TYPE_SIZE will be a NULL_TREE.
2574
2575    C++ gratuitously puts all these tags in the name space.  */
2576
2577 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2578    record the shadowed value for this binding contour.  TYPE is
2579    the type that ID maps to.  */
2580
2581 static void
2582 set_identifier_type_value_with_scope (id, type, b)
2583      tree id;
2584      tree type;
2585      struct binding_level *b;
2586 {
2587   if (!b->namespace_p)
2588     {
2589       /* Shadow the marker, not the real thing, so that the marker
2590          gets restored later. */
2591       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2592       b->type_shadowed
2593         = tree_cons (id, old_type_value, b->type_shadowed);
2594     }
2595   else
2596     {
2597       tree binding = binding_for_name (id, current_namespace);
2598       BINDING_TYPE (binding) = type;
2599       /* Store marker instead of real type. */
2600       type = global_type_node;
2601     }
2602   SET_IDENTIFIER_TYPE_VALUE (id, type);
2603 }
2604
2605 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2606
2607 void
2608 set_identifier_type_value (id, type)
2609      tree id;
2610      tree type;
2611 {
2612   set_identifier_type_value_with_scope (id, type, current_binding_level);
2613 }
2614
2615 /* Return the type associated with id. */
2616
2617 tree
2618 identifier_type_value (id)
2619      tree id;
2620 {
2621   /* There is no type with that name, anywhere. */
2622   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2623     return NULL_TREE;
2624   /* This is not the type marker, but the real thing. */
2625   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2626     return REAL_IDENTIFIER_TYPE_VALUE (id);
2627   /* Have to search for it. It must be on the global level, now.
2628      Ask lookup_name not to return non-types. */
2629   id = lookup_name_real (id, 2, 1, 0);
2630   if (id)
2631     return TREE_TYPE (id);
2632   return NULL_TREE;
2633 }
2634
2635 /* Pop off extraneous binding levels left over due to syntax errors.
2636
2637    We don't pop past namespaces, as they might be valid.  */
2638
2639 void
2640 pop_everything ()
2641 {
2642 #ifdef DEBUG_CP_BINDING_LEVELS
2643   fprintf (stderr, "XXX entering pop_everything ()\n");
2644 #endif
2645   while (!toplevel_bindings_p ())
2646     {
2647       if (current_binding_level->parm_flag == 2)
2648         pop_nested_class ();
2649       else
2650         poplevel (0, 0, 0);
2651     }
2652 #ifdef DEBUG_CP_BINDING_LEVELS
2653   fprintf (stderr, "XXX leaving pop_everything ()\n");
2654 #endif
2655 }
2656
2657 /* The type TYPE is being declared.  If it is a class template, or a
2658    specialization of a class template, do any processing required and
2659    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2660    being declared a friend.  B is the binding level at which this TYPE
2661    should be bound.
2662
2663    Returns the TYPE_DECL for TYPE, which may have been altered by this
2664    processing.  */
2665
2666 static tree
2667 maybe_process_template_type_declaration (type, globalize, b)
2668      tree type;
2669      int globalize;
2670      struct binding_level* b;
2671 {
2672   tree decl = TYPE_NAME (type);
2673
2674   if (processing_template_parmlist)
2675     /* You can't declare a new template type in a template parameter
2676        list.  But, you can declare a non-template type:
2677
2678          template <class A*> struct S;
2679
2680        is a forward-declaration of `A'.  */
2681     ;
2682   else
2683     {
2684       maybe_check_template_type (type);
2685
2686       my_friendly_assert (IS_AGGR_TYPE (type)
2687                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2688
2689
2690       if (processing_template_decl)
2691         {
2692           /* This may change after the call to
2693              push_template_decl_real, but we want the original value.  */
2694           tree name = DECL_NAME (decl);
2695
2696           decl = push_template_decl_real (decl, globalize);
2697           /* If the current binding level is the binding level for the
2698              template parameters (see the comment in
2699              begin_template_parm_list) and the enclosing level is a class
2700              scope, and we're not looking at a friend, push the
2701              declaration of the member class into the class scope.  In the
2702              friend case, push_template_decl will already have put the
2703              friend into global scope, if appropriate.  */
2704           if (TREE_CODE (type) != ENUMERAL_TYPE
2705               && !globalize && b->template_parms_p
2706               && b->level_chain->parm_flag == 2)
2707             {
2708               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2709               /* Put this tag on the list of tags for the class, since
2710                  that won't happen below because B is not the class
2711                  binding level, but is instead the pseudo-global level.  */
2712               b->level_chain->tags =
2713                 tree_cons (name, type, b->level_chain->tags);
2714               if (!COMPLETE_TYPE_P (current_class_type))
2715                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2716             }
2717         }
2718     }
2719
2720   return decl;
2721 }
2722
2723 /* In C++, you don't have to write `struct S' to refer to `S'; you
2724    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2725    if the user had written `typedef struct S S'.  Create and return
2726    the TYPE_DECL for TYPE.  */
2727
2728 tree
2729 create_implicit_typedef (name, type)
2730      tree name;
2731      tree type;
2732 {
2733   tree decl;
2734
2735   decl = build_decl (TYPE_DECL, name, type);
2736   DECL_ARTIFICIAL (decl) = 1;
2737   /* There are other implicit type declarations, like the one *within*
2738      a class that allows you to write `S::S'.  We must distinguish
2739      amongst these.  */
2740   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2741   TYPE_NAME (type) = decl;
2742
2743   return decl;
2744 }
2745
2746 /* Remember a local name for name-mangling purposes.  */
2747
2748 static void
2749 push_local_name (decl)
2750      tree decl;
2751 {
2752   size_t i, nelts;
2753   tree t, name;
2754
2755   if (!local_names)
2756     VARRAY_TREE_INIT (local_names, 8, "local_names");
2757
2758   name = DECL_NAME (decl);
2759
2760   nelts = VARRAY_ACTIVE_SIZE (local_names);
2761   for (i = 0; i < nelts; i++)
2762     {
2763       t = VARRAY_TREE (local_names, i);
2764       if (DECL_NAME (t) == name)
2765         {
2766           if (!DECL_LANG_SPECIFIC (decl))
2767             retrofit_lang_decl (decl);
2768           if (DECL_LANG_SPECIFIC (t))
2769             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2770           else
2771             DECL_DISCRIMINATOR (decl) = 1;
2772
2773           VARRAY_TREE (local_names, i) = decl;
2774           return;
2775         }
2776     }
2777
2778   VARRAY_PUSH_TREE (local_names, decl);
2779 }
2780
2781 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2782    Normally put it into the inner-most non-tag-transparent scope,
2783    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2784    The latter is needed for implicit declarations.  */
2785
2786 void
2787 pushtag (name, type, globalize)
2788      tree name, type;
2789      int globalize;
2790 {
2791   register struct binding_level *b;
2792
2793   b = current_binding_level;
2794   while (b->tag_transparent
2795          || (b->parm_flag == 2
2796              && (globalize
2797                  /* We may be defining a new type in the initializer
2798                     of a static member variable. We allow this when
2799                     not pedantic, and it is particularly useful for
2800                     type punning via an anonymous union. */
2801                  || COMPLETE_TYPE_P (b->this_class))))
2802     b = b->level_chain;
2803
2804   b->tags = tree_cons (name, type, b->tags);
2805
2806   if (name)
2807     {
2808       /* Do C++ gratuitous typedefing.  */
2809       if (IDENTIFIER_TYPE_VALUE (name) != type)
2810         {
2811           register tree d = NULL_TREE;
2812           int in_class = 0;
2813           tree context = TYPE_CONTEXT (type);
2814
2815           if (! context)
2816             {
2817               tree cs = current_scope ();
2818
2819               if (! globalize)
2820                 context = cs;
2821               else if (cs != NULL_TREE && TYPE_P (cs))
2822                 /* When declaring a friend class of a local class, we want
2823                    to inject the newly named class into the scope
2824                    containing the local class, not the namespace scope.  */
2825                 context = decl_function_context (get_type_decl (cs));
2826             }
2827           if (!context)
2828             context = current_namespace;
2829
2830           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2831               || b->parm_flag == 2)
2832             in_class = 1;
2833
2834           if (current_lang_name == lang_name_java)
2835             TYPE_FOR_JAVA (type) = 1;
2836
2837           d = create_implicit_typedef (name, type);
2838           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2839           if (! in_class)
2840             set_identifier_type_value_with_scope (name, type, b);
2841
2842           d = maybe_process_template_type_declaration (type,
2843                                                        globalize, b);
2844
2845           if (b->parm_flag == 2)
2846             {
2847               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2848                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2849                    class.  But if it's a member template class, we
2850                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2851                    is done later.  */
2852                 finish_member_declaration (d);
2853               else
2854                 pushdecl_class_level (d);
2855             }
2856           else
2857             d = pushdecl_with_scope (d, b);
2858
2859           /* FIXME what if it gets a name from typedef?  */
2860           if (ANON_AGGRNAME_P (name))
2861             DECL_IGNORED_P (d) = 1;
2862
2863           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2864
2865           /* If this is a local class, keep track of it.  We need this
2866              information for name-mangling, and so that it is possible to find
2867              all function definitions in a translation unit in a convenient
2868              way.  (It's otherwise tricky to find a member function definition
2869              it's only pointed to from within a local class.)  */
2870           if (TYPE_CONTEXT (type)
2871               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2872               && !processing_template_decl)
2873             VARRAY_PUSH_TREE (local_classes, type);
2874         }
2875       if (b->parm_flag == 2)
2876         {
2877           if (!COMPLETE_TYPE_P (current_class_type))
2878             CLASSTYPE_TAGS (current_class_type) = b->tags;
2879         }
2880     }
2881
2882   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2883     /* Use the canonical TYPE_DECL for this node.  */
2884     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2885   else
2886     {
2887       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2888          will be the tagged type we just added to the current
2889          binding level.  This fake NULL-named TYPE_DECL node helps
2890          dwarfout.c to know when it needs to output a
2891          representation of a tagged type, and it also gives us a
2892          convenient place to record the "scope start" address for
2893          the tagged type.  */
2894
2895       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2896       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2897     }
2898 }
2899
2900 /* Counter used to create anonymous type names.  */
2901
2902 static int anon_cnt = 0;
2903
2904 /* Return an IDENTIFIER which can be used as a name for
2905    anonymous structs and unions.  */
2906
2907 tree
2908 make_anon_name ()
2909 {
2910   char buf[32];
2911
2912   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2913   return get_identifier (buf);
2914 }
2915
2916 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2917    This keeps dbxout from getting confused.  */
2918
2919 void
2920 clear_anon_tags ()
2921 {
2922   register struct binding_level *b;
2923   register tree tags;
2924   static int last_cnt = 0;
2925
2926   /* Fast out if no new anon names were declared.  */
2927   if (last_cnt == anon_cnt)
2928     return;
2929
2930   b = current_binding_level;
2931   while (b->tag_transparent)
2932     b = b->level_chain;
2933   tags = b->tags;
2934   while (tags)
2935     {
2936       /* A NULL purpose means we have already processed all tags
2937          from here to the end of the list.  */
2938       if (TREE_PURPOSE (tags) == NULL_TREE)
2939         break;
2940       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2941         TREE_PURPOSE (tags) = NULL_TREE;
2942       tags = TREE_CHAIN (tags);
2943     }
2944   last_cnt = anon_cnt;
2945 }
2946 \f
2947 /* Subroutine of duplicate_decls: return truthvalue of whether
2948    or not types of these decls match.
2949
2950    For C++, we must compare the parameter list so that `int' can match
2951    `int&' in a parameter position, but `int&' is not confused with
2952    `const int&'.  */
2953
2954 int
2955 decls_match (newdecl, olddecl)
2956      tree newdecl, olddecl;
2957 {
2958   int types_match;
2959
2960   if (newdecl == olddecl)
2961     return 1;
2962
2963   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2964     /* If the two DECLs are not even the same kind of thing, we're not
2965        interested in their types.  */
2966     return 0;
2967
2968   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2969     {
2970       tree f1 = TREE_TYPE (newdecl);
2971       tree f2 = TREE_TYPE (olddecl);
2972       tree p1 = TYPE_ARG_TYPES (f1);
2973       tree p2 = TYPE_ARG_TYPES (f2);
2974
2975       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2976           && ! (DECL_EXTERN_C_P (newdecl)
2977                 && DECL_EXTERN_C_P (olddecl)))
2978         return 0;
2979
2980       if (TREE_CODE (f1) != TREE_CODE (f2))
2981         return 0;
2982
2983       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2984         {
2985           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2986               && (DECL_BUILT_IN (olddecl)
2987 #ifndef NO_IMPLICIT_EXTERN_C
2988                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2989                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2990 #endif
2991               ))
2992             {
2993               types_match = self_promoting_args_p (p1);
2994               if (p1 == void_list_node)
2995                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2996             }
2997 #ifndef NO_IMPLICIT_EXTERN_C
2998           else if (p1 == NULL_TREE
2999                    && (DECL_EXTERN_C_P (olddecl)
3000                        && DECL_IN_SYSTEM_HEADER (olddecl)
3001                        && !DECL_CLASS_SCOPE_P (olddecl))
3002                    && (DECL_EXTERN_C_P (newdecl)
3003                        && DECL_IN_SYSTEM_HEADER (newdecl)
3004                        && !DECL_CLASS_SCOPE_P (newdecl)))
3005             {
3006               types_match = self_promoting_args_p (p2);
3007               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3008             }
3009 #endif
3010           else
3011             types_match = compparms (p1, p2);
3012         }
3013       else
3014         types_match = 0;
3015     }
3016   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3017     {
3018       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3019                                 DECL_TEMPLATE_PARMS (olddecl)))
3020         return 0;
3021
3022       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3023           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3024         return 0;
3025
3026       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3027         types_match = 1;
3028       else
3029         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3030                                    DECL_TEMPLATE_RESULT (newdecl));
3031     }
3032   else
3033     {
3034       if (TREE_TYPE (newdecl) == error_mark_node)
3035         types_match = TREE_TYPE (olddecl) == error_mark_node;
3036       else if (TREE_TYPE (olddecl) == NULL_TREE)
3037         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3038       else if (TREE_TYPE (newdecl) == NULL_TREE)
3039         types_match = 0;
3040       else
3041         types_match = comptypes (TREE_TYPE (newdecl),
3042                                  TREE_TYPE (olddecl),
3043                                  COMPARE_REDECLARATION);
3044     }
3045
3046   return types_match;
3047 }
3048
3049 /* If NEWDECL is `static' and an `extern' was seen previously,
3050    warn about it.  OLDDECL is the previous declaration.
3051
3052    Note that this does not apply to the C++ case of declaring
3053    a variable `extern const' and then later `const'.
3054
3055    Don't complain about built-in functions, since they are beyond
3056    the user's control.  */
3057
3058 static void
3059 warn_extern_redeclared_static (newdecl, olddecl)
3060      tree newdecl, olddecl;
3061 {
3062   static const char *const explicit_extern_static_warning
3063     = "`%D' was declared `extern' and later `static'";
3064   static const char *const implicit_extern_static_warning
3065     = "`%D' was declared implicitly `extern' and later `static'";
3066
3067   tree name;
3068
3069   if (TREE_CODE (newdecl) == TYPE_DECL
3070       || TREE_CODE (newdecl) == TEMPLATE_DECL
3071       || TREE_CODE (newdecl) == CONST_DECL)
3072     return;
3073
3074   /* Don't get confused by static member functions; that's a different
3075      use of `static'.  */
3076   if (TREE_CODE (newdecl) == FUNCTION_DECL
3077       && DECL_STATIC_FUNCTION_P (newdecl))
3078     return;
3079
3080   /* If the old declaration was `static', or the new one isn't, then
3081      then everything is OK.  */
3082   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3083     return;
3084
3085   /* It's OK to declare a builtin function as `static'.  */
3086   if (TREE_CODE (olddecl) == FUNCTION_DECL
3087       && DECL_ARTIFICIAL (olddecl))
3088     return;
3089
3090   name = DECL_ASSEMBLER_NAME (newdecl);
3091   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3092               ? implicit_extern_static_warning
3093               : explicit_extern_static_warning, newdecl);
3094   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3095 }
3096
3097 /* Handle when a new declaration NEWDECL has the same name as an old
3098    one OLDDECL in the same binding contour.  Prints an error message
3099    if appropriate.
3100
3101    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3102    Otherwise, return 0.  */
3103
3104 int
3105 duplicate_decls (newdecl, olddecl)
3106      tree newdecl, olddecl;
3107 {
3108   unsigned olddecl_uid = DECL_UID (olddecl);
3109   int olddecl_friend = 0, types_match = 0;
3110   int new_defines_function = 0;
3111
3112   if (newdecl == olddecl)
3113     return 1;
3114
3115   types_match = decls_match (newdecl, olddecl);
3116
3117   /* If either the type of the new decl or the type of the old decl is an
3118      error_mark_node, then that implies that we have already issued an
3119      error (earlier) for some bogus type specification, and in that case,
3120      it is rather pointless to harass the user with yet more error message
3121      about the same declaration, so just pretend the types match here.  */
3122   if (TREE_TYPE (newdecl) == error_mark_node
3123       || TREE_TYPE (olddecl) == error_mark_node)
3124     types_match = 1;
3125
3126   if (DECL_P (olddecl)
3127       && TREE_CODE (newdecl) == FUNCTION_DECL
3128       && TREE_CODE (olddecl) == FUNCTION_DECL
3129       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3130     {
3131       if (DECL_DECLARED_INLINE_P (newdecl)
3132           && DECL_UNINLINABLE (newdecl)
3133           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3134         /* Already warned elsewhere.  */;
3135       else if (DECL_DECLARED_INLINE_P (olddecl)
3136                && DECL_UNINLINABLE (olddecl)
3137                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3138         /* Already warned.  */;
3139       else if (DECL_DECLARED_INLINE_P (newdecl)
3140                && DECL_UNINLINABLE (olddecl)
3141                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3142         {
3143           warning_with_decl (newdecl,
3144                              "function `%s' redeclared as inline");
3145           warning_with_decl (olddecl,
3146                              "previous declaration of function `%s' with attribute noinline");
3147         }
3148       else if (DECL_DECLARED_INLINE_P (olddecl)
3149                && DECL_UNINLINABLE (newdecl)
3150                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3151         {
3152           warning_with_decl (newdecl,
3153                              "function `%s' redeclared with attribute noinline");
3154           warning_with_decl (olddecl,
3155                              "previous declaration of function `%s' was inline");
3156         }
3157     }
3158
3159   /* Check for redeclaration and other discrepancies. */
3160   if (TREE_CODE (olddecl) == FUNCTION_DECL
3161       && DECL_ARTIFICIAL (olddecl))
3162     {
3163       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3164         {
3165           /* If you declare a built-in or predefined function name as static,
3166              the old definition is overridden, but optionally warn this was a
3167              bad choice of name.  */
3168           if (! TREE_PUBLIC (newdecl))
3169             {
3170               if (warn_shadow)
3171                 warning ("shadowing %s function `%#D'",
3172                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3173                             olddecl);
3174               /* Discard the old built-in function.  */
3175               return 0;
3176             }
3177           /* If the built-in is not ansi, then programs can override
3178              it even globally without an error.  */
3179           else if (! DECL_BUILT_IN (olddecl))
3180             warning ("library function `%#D' redeclared as non-function `%#D'",
3181                         olddecl, newdecl);
3182           else
3183             {
3184               error ("declaration of `%#D'", newdecl);
3185               error ("conflicts with built-in declaration `%#D'",
3186                         olddecl);
3187             }
3188           return 0;
3189         }
3190       else if (!types_match)
3191         {
3192           if ((DECL_EXTERN_C_P (newdecl)
3193                && DECL_EXTERN_C_P (olddecl))
3194               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3195                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3196             {
3197               /* A near match; override the builtin.  */
3198
3199               if (TREE_PUBLIC (newdecl))
3200                 {
3201                   warning ("new declaration `%#D'", newdecl);
3202                   warning ("ambiguates built-in declaration `%#D'",
3203                               olddecl);
3204                 }
3205               else if (warn_shadow)
3206                 warning ("shadowing %s function `%#D'",
3207                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3208                             olddecl);
3209             }
3210           else
3211             /* Discard the old built-in function.  */
3212             return 0;
3213         }
3214
3215       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3216         {
3217           /* If a builtin function is redeclared as `static', merge
3218              the declarations, but make the original one static.  */
3219           DECL_THIS_STATIC (olddecl) = 1;
3220           TREE_PUBLIC (olddecl) = 0;
3221
3222           /* Make the old declaration consistent with the new one so
3223              that all remnants of the builtin-ness of this function
3224              will be banished.  */
3225           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3226           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3227           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3228           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3229                                        newdecl);
3230         }
3231     }
3232   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3233     {
3234       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3235            && TREE_CODE (newdecl) != TYPE_DECL
3236            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3237                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3238           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3239               && TREE_CODE (olddecl) != TYPE_DECL
3240               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3241                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3242                         == TYPE_DECL))))
3243         {
3244           /* We do nothing special here, because C++ does such nasty
3245              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3246              get shadowed, and know that if we need to find a TYPE_DECL
3247              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3248              slot of the identifier.  */
3249           return 0;
3250         }
3251
3252       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3253            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3254           || (TREE_CODE (olddecl) == FUNCTION_DECL
3255               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3256         return 0;
3257
3258       error ("`%#D' redeclared as different kind of symbol", newdecl);
3259       if (TREE_CODE (olddecl) == TREE_LIST)
3260         olddecl = TREE_VALUE (olddecl);
3261       cp_error_at ("previous declaration of `%#D'", olddecl);
3262
3263       /* New decl is completely inconsistent with the old one =>
3264          tell caller to replace the old one.  */
3265
3266       return 0;
3267     }
3268   else if (!types_match)
3269     {
3270       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3271         /* These are certainly not duplicate declarations; they're
3272            from different scopes.  */
3273         return 0;
3274
3275       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3276         {
3277           /* The name of a class template may not be declared to refer to
3278              any other template, class, function, object, namespace, value,
3279              or type in the same scope.  */
3280           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3281               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3282             {
3283               error ("declaration of template `%#D'", newdecl);
3284               cp_error_at ("conflicts with previous declaration `%#D'",
3285                            olddecl);
3286             }
3287           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3288                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3289                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3290                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3291                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3292                                            DECL_TEMPLATE_PARMS (olddecl)))
3293             {
3294               error ("new declaration `%#D'", newdecl);
3295               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3296             }
3297           return 0;
3298         }
3299       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3300         {
3301           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3302             {
3303               error ("declaration of C function `%#D' conflicts with",
3304                         newdecl);
3305               cp_error_at ("previous declaration `%#D' here", olddecl);
3306             }
3307           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3308                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3309             {
3310               error ("new declaration `%#D'", newdecl);
3311               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3312             }
3313           else
3314             return 0;
3315         }
3316
3317       /* Already complained about this, so don't do so again.  */
3318       else if (current_class_type == NULL_TREE
3319           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3320         {
3321           error ("conflicting types for `%#D'", newdecl);
3322           cp_error_at ("previous declaration as `%#D'", olddecl);
3323         }
3324     }
3325   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3326             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3327                  && (!DECL_TEMPLATE_INFO (newdecl)
3328                      || (DECL_TI_TEMPLATE (newdecl)
3329                          != DECL_TI_TEMPLATE (olddecl))))
3330                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3331                     && (!DECL_TEMPLATE_INFO (olddecl)
3332                         || (DECL_TI_TEMPLATE (olddecl)
3333                             != DECL_TI_TEMPLATE (newdecl))))))
3334     /* It's OK to have a template specialization and a non-template
3335        with the same type, or to have specializations of two
3336        different templates with the same type.  Note that if one is a
3337        specialization, and the other is an instantiation of the same
3338        template, that we do not exit at this point.  That situation
3339        can occur if we instantiate a template class, and then
3340        specialize one of its methods.  This situation is legal, but
3341        the declarations must be merged in the usual way.  */
3342     return 0;
3343   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3344            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3345                 && !DECL_USE_TEMPLATE (newdecl))
3346                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3347                    && !DECL_USE_TEMPLATE (olddecl))))
3348     /* One of the declarations is a template instantiation, and the
3349        other is not a template at all.  That's OK.  */
3350     return 0;
3351   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3352            && DECL_NAMESPACE_ALIAS (newdecl)
3353            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3354     /* Redeclaration of namespace alias, ignore it. */
3355     return 1;
3356   else
3357     {
3358       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3359       if (errmsg)
3360         {
3361           error (errmsg, newdecl);
3362           if (DECL_NAME (olddecl) != NULL_TREE)
3363             cp_error_at ((DECL_INITIAL (olddecl)
3364                           && namespace_bindings_p ())
3365                          ? "`%#D' previously defined here"
3366                          : "`%#D' previously declared here", olddecl);
3367         }
3368       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3369                && DECL_INITIAL (olddecl) != NULL_TREE
3370                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3371                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3372         {
3373           /* Prototype decl follows defn w/o prototype.  */
3374           cp_warning_at ("prototype for `%#D'", newdecl);
3375           cp_warning_at ("follows non-prototype definition here", olddecl);
3376         }
3377       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3378                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3379         {
3380           /* extern "C" int foo ();
3381              int foo () { bar (); }
3382              is OK.  */
3383           if (current_lang_depth () == 0)
3384             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3385           else
3386             {
3387               cp_error_at ("previous declaration of `%#D' with %L linkage",
3388                            olddecl, DECL_LANGUAGE (olddecl));
3389               error ("conflicts with new declaration with %L linkage",
3390                         DECL_LANGUAGE (newdecl));
3391             }
3392         }
3393
3394       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3395         ;
3396       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3397         {
3398           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3399           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3400           int i = 1;
3401
3402           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3403             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3404
3405           for (; t1 && t1 != void_list_node;
3406                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3407             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3408               {
3409                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3410                                            TREE_PURPOSE (t2)))
3411                   {
3412                     if (pedantic)
3413                       {
3414                         pedwarn ("default argument given for parameter %d of `%#D'",
3415                                     i, newdecl);
3416                         cp_pedwarn_at ("after previous specification in `%#D'",
3417                                        olddecl);
3418                       }
3419                   }
3420                 else
3421                   {
3422                     error ("default argument given for parameter %d of `%#D'",
3423                               i, newdecl);
3424                     cp_error_at ("after previous specification in `%#D'",
3425                                  olddecl);
3426                   }
3427               }
3428
3429           if (DECL_DECLARED_INLINE_P (newdecl)
3430               && ! DECL_DECLARED_INLINE_P (olddecl)
3431               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3432             {
3433               warning ("`%#D' was used before it was declared inline",
3434                           newdecl);
3435               cp_warning_at ("previous non-inline declaration here",
3436                              olddecl);
3437             }
3438         }
3439     }
3440
3441   /* If new decl is `static' and an `extern' was seen previously,
3442      warn about it.  */
3443   warn_extern_redeclared_static (newdecl, olddecl);
3444
3445   /* We have committed to returning 1 at this point.  */
3446   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3447     {
3448       /* Now that functions must hold information normally held
3449          by field decls, there is extra work to do so that
3450          declaration information does not get destroyed during
3451          definition.  */
3452       if (DECL_VINDEX (olddecl))
3453         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3454       if (DECL_VIRTUAL_CONTEXT (olddecl))
3455         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3456       if (DECL_CONTEXT (olddecl))
3457         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3458       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3459         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3460       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3461       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3462       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3463       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3464       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3465       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3466       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3467         SET_OVERLOADED_OPERATOR_CODE
3468           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3469       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3470
3471       /* Optionally warn about more than one declaration for the same
3472          name, but don't warn about a function declaration followed by a
3473          definition.  */
3474       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3475           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3476           /* Don't warn about extern decl followed by definition. */
3477           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3478           /* Don't warn about friends, let add_friend take care of it. */
3479           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3480         {
3481           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3482           cp_warning_at ("previous declaration of `%D'", olddecl);
3483         }
3484     }
3485
3486   /* Deal with C++: must preserve virtual function table size.  */
3487   if (TREE_CODE (olddecl) == TYPE_DECL)
3488     {
3489       register tree newtype = TREE_TYPE (newdecl);
3490       register tree oldtype = TREE_TYPE (olddecl);
3491
3492       if (newtype != error_mark_node && oldtype != error_mark_node
3493           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3494         {
3495           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3496           CLASSTYPE_FRIEND_CLASSES (newtype)
3497             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3498         }
3499
3500       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3501     }
3502
3503   /* Copy all the DECL_... slots specified in the new decl
3504      except for any that we copy here from the old type.  */
3505   DECL_ATTRIBUTES (newdecl)
3506     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3507
3508   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3509     {
3510       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3511       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3512         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3513                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3514
3515       /* If the new declaration is a definition, update the file and
3516          line information on the declaration.  */
3517       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3518           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3519         {
3520           DECL_SOURCE_LINE (olddecl)
3521             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3522             = DECL_SOURCE_LINE (newdecl);
3523           DECL_SOURCE_FILE (olddecl)
3524             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3525             = DECL_SOURCE_FILE (newdecl);
3526         }
3527
3528       return 1;
3529     }
3530
3531   if (types_match)
3532     {
3533       /* Automatically handles default parameters.  */
3534       tree oldtype = TREE_TYPE (olddecl);
3535       tree newtype;
3536
3537       /* Merge the data types specified in the two decls.  */
3538       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3539
3540       /* If common_type produces a non-typedef type, just use the old type.  */
3541       if (TREE_CODE (newdecl) == TYPE_DECL
3542           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3543         newtype = oldtype;
3544
3545       if (TREE_CODE (newdecl) == VAR_DECL)
3546         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3547       /* Do this after calling `common_type' so that default
3548          parameters don't confuse us.  */
3549       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3550           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3551               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3552         {
3553           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3554                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3555           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3556                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3557
3558           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3559               && DECL_SOURCE_LINE (olddecl) != 0
3560               && flag_exceptions
3561               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3562                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3563             {
3564               error ("declaration of `%F' throws different exceptions",
3565                         newdecl);
3566               cp_error_at ("than previous declaration `%F'", olddecl);
3567             }
3568         }
3569       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3570
3571       /* Lay the type out, unless already done.  */
3572       if (! same_type_p (newtype, oldtype)
3573           && TREE_TYPE (newdecl) != error_mark_node
3574           && !(processing_template_decl && uses_template_parms (newdecl)))
3575         layout_type (TREE_TYPE (newdecl));
3576
3577       if ((TREE_CODE (newdecl) == VAR_DECL
3578            || TREE_CODE (newdecl) == PARM_DECL
3579            || TREE_CODE (newdecl) == RESULT_DECL
3580            || TREE_CODE (newdecl) == FIELD_DECL
3581            || TREE_CODE (newdecl) == TYPE_DECL)
3582           && !(processing_template_decl && uses_template_parms (newdecl)))
3583         layout_decl (newdecl, 0);
3584
3585       /* Merge the type qualifiers.  */
3586       if (TREE_READONLY (newdecl))
3587         TREE_READONLY (olddecl) = 1;
3588       if (TREE_THIS_VOLATILE (newdecl))
3589         TREE_THIS_VOLATILE (olddecl) = 1;
3590
3591       /* Merge the initialization information.  */
3592       if (DECL_INITIAL (newdecl) == NULL_TREE
3593           && DECL_INITIAL (olddecl) != NULL_TREE)
3594         {
3595           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3596           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3597           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3598           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3599               && DECL_LANG_SPECIFIC (newdecl)
3600               && DECL_LANG_SPECIFIC (olddecl))
3601             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3602         }
3603
3604       /* Merge the section attribute.
3605          We want to issue an error if the sections conflict but that must be
3606          done later in decl_attributes since we are called before attributes
3607          are assigned.  */
3608       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3609         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3610
3611       /* Keep the old rtl since we can safely use it.  */
3612       COPY_DECL_RTL (olddecl, newdecl);
3613
3614       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3615         {
3616           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3617             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3618           DECL_NO_LIMIT_STACK (newdecl)
3619             |= DECL_NO_LIMIT_STACK (olddecl);
3620         }
3621     }
3622   /* If cannot merge, then use the new type and qualifiers,
3623      and don't preserve the old rtl.  */
3624   else
3625     {
3626       /* Clean out any memory we had of the old declaration.  */
3627       tree oldstatic = value_member (olddecl, static_aggregates);
3628       if (oldstatic)
3629         TREE_VALUE (oldstatic) = error_mark_node;
3630
3631       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3632       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3633       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3634       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3635     }
3636
3637   /* Merge the storage class information.  */
3638   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3639   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3640   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3641   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3642   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3643   if (! DECL_EXTERNAL (olddecl))
3644     DECL_EXTERNAL (newdecl) = 0;
3645
3646   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3647     {
3648       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3649       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3650       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3651       DECL_TEMPLATE_INSTANTIATED (newdecl)
3652         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3653       /* Don't really know how much of the language-specific
3654          values we should copy from old to new.  */
3655       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3656       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3657       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3658       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3659       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3660         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3661       olddecl_friend = DECL_FRIEND_P (olddecl);
3662
3663       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3664       if (TREE_CODE (newdecl) == FUNCTION_DECL
3665           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3666         DECL_BEFRIENDING_CLASSES (newdecl)
3667           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3668                      DECL_BEFRIENDING_CLASSES (olddecl));
3669     }
3670
3671   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3672     {
3673       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3674           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3675         {
3676           /* If newdecl is not a specialization, then it is not a
3677              template-related function at all.  And that means that we
3678              shoud have exited above, returning 0.  */
3679           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3680                               0);
3681
3682           if (TREE_USED (olddecl))
3683             /* From [temp.expl.spec]:
3684
3685                If a template, a member template or the member of a class
3686                template is explicitly specialized then that
3687                specialization shall be declared before the first use of
3688                that specialization that would cause an implicit
3689                instantiation to take place, in every translation unit in
3690                which such a use occurs.  */
3691             error ("explicit specialization of %D after first use",
3692                       olddecl);
3693
3694           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3695         }
3696       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3697
3698       /* If either decl says `inline', this fn is inline, unless its
3699          definition was passed already.  */
3700       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3701         DECL_INLINE (olddecl) = 1;
3702       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3703
3704       DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3705         = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3706
3707       /* Preserve abstractness on cloned [cd]tors.  */
3708       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3709
3710       if (! types_match)
3711         {
3712           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3713           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3714           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3715         }
3716       if (! types_match || new_defines_function)
3717         {
3718           /* These need to be copied so that the names are available.
3719              Note that if the types do match, we'll preserve inline
3720              info and other bits, but if not, we won't.  */
3721           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3722           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3723         }
3724       if (new_defines_function)
3725         /* If defining a function declared with other language
3726            linkage, use the previously declared language linkage.  */
3727         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3728       else if (types_match)
3729         {
3730           /* If redeclaring a builtin function, and not a definition,
3731              it stays built in.  */
3732           if (DECL_BUILT_IN (olddecl))
3733             {
3734               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3735               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3736               /* If we're keeping the built-in definition, keep the rtl,
3737                  regardless of declaration matches.  */
3738               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3739             }
3740           else
3741             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3742
3743           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3744           /* Don't clear out the arguments if we're redefining a function.  */
3745           if (DECL_ARGUMENTS (olddecl))
3746             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3747         }
3748     }
3749   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3750     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3751
3752   /* Now preserve various other info from the definition.  */
3753   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3754   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3755   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3756   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3757
3758   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3759     {
3760       int function_size;
3761
3762       function_size = sizeof (struct tree_decl);
3763
3764       memcpy ((char *) olddecl + sizeof (struct tree_common),
3765               (char *) newdecl + sizeof (struct tree_common),
3766               function_size - sizeof (struct tree_common));
3767
3768       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3769         {
3770           /* If newdecl is a template instantiation, it is possible that
3771              the following sequence of events has occurred:
3772
3773              o A friend function was declared in a class template.  The
3774              class template was instantiated.
3775
3776              o The instantiation of the friend declaration was
3777              recorded on the instantiation list, and is newdecl.
3778
3779              o Later, however, instantiate_class_template called pushdecl
3780              on the newdecl to perform name injection.  But, pushdecl in
3781              turn called duplicate_decls when it discovered that another
3782              declaration of a global function with the same name already
3783              existed.
3784
3785              o Here, in duplicate_decls, we decided to clobber newdecl.
3786
3787              If we're going to do that, we'd better make sure that
3788              olddecl, and not newdecl, is on the list of
3789              instantiations so that if we try to do the instantiation
3790              again we won't get the clobbered declaration.  */
3791
3792           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3793           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3794
3795           for (; decls; decls = TREE_CHAIN (decls))
3796             if (TREE_VALUE (decls) == newdecl)
3797               TREE_VALUE (decls) = olddecl;
3798         }
3799     }
3800   else
3801     {
3802       memcpy ((char *) olddecl + sizeof (struct tree_common),
3803               (char *) newdecl + sizeof (struct tree_common),
3804               sizeof (struct tree_decl) - sizeof (struct tree_common)
3805               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3806     }
3807
3808   DECL_UID (olddecl) = olddecl_uid;
3809   if (olddecl_friend)
3810     DECL_FRIEND_P (olddecl) = 1;
3811
3812   /* NEWDECL contains the merged attribute lists.
3813      Update OLDDECL to be the same.  */
3814   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3815
3816   return 1;
3817 }
3818
3819 /* Record a decl-node X as belonging to the current lexical scope.
3820    Check for errors (such as an incompatible declaration for the same
3821    name already seen in the same scope).
3822
3823    Returns either X or an old decl for the same name.
3824    If an old decl is returned, it may have been smashed
3825    to agree with what X says.  */
3826
3827 tree
3828 pushdecl (x)
3829      tree x;
3830 {
3831   register tree t;
3832   register tree name;
3833   int need_new_binding;
3834
3835   /* We shouldn't be calling pushdecl when we're generating RTL for a
3836      function that we already did semantic analysis on previously.  */
3837   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3838                       19990913);
3839
3840   need_new_binding = 1;
3841
3842   if (DECL_TEMPLATE_PARM_P (x))
3843     /* Template parameters have no context; they are not X::T even
3844        when declared within a class or namespace.  */
3845     ;
3846   else
3847     {
3848       if (current_function_decl && x != current_function_decl
3849           /* A local declaration for a function doesn't constitute
3850              nesting.  */
3851           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3852           /* A local declaration for an `extern' variable is in the
3853              scope of the current namespace, not the current
3854              function.  */
3855           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3856           && !DECL_CONTEXT (x))
3857         DECL_CONTEXT (x) = current_function_decl;
3858
3859       /* If this is the declaration for a namespace-scope function,
3860          but the declaration itself is in a local scope, mark the
3861          declaration.  */
3862       if (TREE_CODE (x) == FUNCTION_DECL
3863           && DECL_NAMESPACE_SCOPE_P (x)
3864           && current_function_decl
3865           && x != current_function_decl)
3866         DECL_LOCAL_FUNCTION_P (x) = 1;
3867     }
3868
3869   name = DECL_NAME (x);
3870   if (name)
3871     {
3872       int different_binding_level = 0;
3873
3874       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3875         name = TREE_OPERAND (name, 0);
3876
3877       /* In case this decl was explicitly namespace-qualified, look it
3878          up in its namespace context.  */
3879       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3880           && namespace_bindings_p ())
3881         t = namespace_binding (name, DECL_CONTEXT (x));
3882       else
3883         t = lookup_name_current_level (name);
3884
3885       /* [basic.link] If there is a visible declaration of an entity
3886          with linkage having the same name and type, ignoring entities
3887          declared outside the innermost enclosing namespace scope, the
3888          block scope declaration declares that same entity and
3889          receives the linkage of the previous declaration.  */
3890       if (! t && current_function_decl && x != current_function_decl
3891           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3892           && DECL_EXTERNAL (x))
3893         {
3894           /* Look in block scope.  */
3895           t = IDENTIFIER_VALUE (name);
3896           /* Or in the innermost namespace.  */
3897           if (! t)
3898             t = namespace_binding (name, DECL_CONTEXT (x));
3899           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3900              OVERLOAD, which is OK.  */
3901           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3902             t = NULL_TREE;
3903           if (t)
3904             different_binding_level = 1;
3905         }
3906
3907       /* If we are declaring a function, and the result of name-lookup
3908          was an OVERLOAD, look for an overloaded instance that is
3909          actually the same as the function we are declaring.  (If
3910          there is one, we have to merge our declaration with the
3911          previous declaration.)  */
3912       if (t && TREE_CODE (t) == OVERLOAD)
3913         {
3914           tree match;
3915
3916           if (TREE_CODE (x) == FUNCTION_DECL)
3917             for (match = t; match; match = OVL_NEXT (match))
3918               {
3919                 if (decls_match (OVL_CURRENT (match), x))
3920                   break;
3921               }
3922           else
3923             /* Just choose one.  */
3924             match = t;
3925
3926           if (match)
3927             t = OVL_CURRENT (match);
3928           else
3929             t = NULL_TREE;
3930         }
3931
3932       if (t == error_mark_node)
3933         {
3934           /* error_mark_node is 0 for a while during initialization!  */
3935           t = NULL_TREE;
3936           cp_error_at ("`%#D' used prior to declaration", x);
3937         }
3938       else if (t != NULL_TREE)
3939         {
3940           if (different_binding_level)
3941             {
3942               if (decls_match (x, t))
3943                 /* The standard only says that the local extern
3944                    inherits linkage from the previous decl; in
3945                    particular, default args are not shared.  It would
3946                    be nice to propagate inlining info, though.  FIXME.  */
3947                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3948             }
3949           else if (TREE_CODE (t) == PARM_DECL)
3950             {
3951               if (DECL_CONTEXT (t) == NULL_TREE)
3952                 /* This is probaby caused by too many errors, but calling
3953                    abort will say that if errors have occurred.  */
3954                 abort ();
3955
3956               /* Check for duplicate params.  */
3957               if (duplicate_decls (x, t))
3958                 return t;
3959             }
3960           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3961                     || DECL_FUNCTION_TEMPLATE_P (x))
3962                    && is_overloaded_fn (t))
3963             /* Don't do anything just yet. */;
3964           else if (t == wchar_decl_node)
3965             {
3966               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3967                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3968                             TREE_TYPE (x));
3969
3970               /* Throw away the redeclaration.  */
3971               return t;
3972             }
3973           else if (TREE_CODE (t) != TREE_CODE (x))
3974             {
3975               if (duplicate_decls (x, t))
3976                 return t;
3977             }
3978           else if (duplicate_decls (x, t))
3979             {
3980               if (TREE_CODE (t) == TYPE_DECL)
3981                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3982               else if (TREE_CODE (t) == FUNCTION_DECL)
3983                 check_default_args (t);
3984
3985               return t;
3986             }
3987           else if (DECL_MAIN_P (x))
3988             {
3989               /* A redeclaration of main, but not a duplicate of the
3990                  previous one.
3991
3992                  [basic.start.main]
3993
3994                  This function shall not be overloaded.  */
3995               cp_error_at ("invalid redeclaration of `%D'", t);
3996               error ("as `%D'", x);
3997               /* We don't try to push this declaration since that
3998                  causes a crash.  */
3999               return x;
4000             }
4001         }
4002
4003       check_template_shadow (x);
4004
4005       /* If this is a function conjured up by the backend, massage it
4006          so it looks friendly.  */
4007       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4008         {
4009           retrofit_lang_decl (x);
4010           SET_DECL_LANGUAGE (x, lang_c);
4011         }
4012
4013       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4014         {
4015           t = push_overloaded_decl (x, PUSH_LOCAL);
4016           if (t != x)
4017             return t;
4018           if (!namespace_bindings_p ())
4019             /* We do not need to create a binding for this name;
4020                push_overloaded_decl will have already done so if
4021                necessary.  */
4022             need_new_binding = 0;
4023         }
4024       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4025         {
4026           t = push_overloaded_decl (x, PUSH_GLOBAL);
4027           if (t == x)
4028             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4029           return t;
4030         }
4031
4032       /* If declaring a type as a typedef, copy the type (unless we're
4033          at line 0), and install this TYPE_DECL as the new type's typedef
4034          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4035       if (TREE_CODE (x) == TYPE_DECL)
4036         {
4037           tree type = TREE_TYPE (x);
4038           if (DECL_SOURCE_LINE (x) == 0)
4039             {
4040               if (TYPE_NAME (type) == 0)
4041                 TYPE_NAME (type) = x;
4042             }
4043           else if (type != error_mark_node && TYPE_NAME (type) != x
4044                    /* We don't want to copy the type when all we're
4045                       doing is making a TYPE_DECL for the purposes of
4046                       inlining.  */
4047                    && (!TYPE_NAME (type)
4048                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4049             {
4050               DECL_ORIGINAL_TYPE (x) = type;
4051               type = build_type_copy (type);
4052               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4053               TYPE_NAME (type) = x;
4054               TREE_TYPE (x) = type;
4055             }
4056
4057           if (type != error_mark_node
4058               && TYPE_NAME (type)
4059               && TYPE_IDENTIFIER (type))
4060             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4061                                                   current_binding_level);
4062
4063         }
4064
4065       /* Multiple external decls of the same identifier ought to match.
4066
4067          We get warnings about inline functions where they are defined.
4068          We get warnings about other functions from push_overloaded_decl.
4069
4070          Avoid duplicate warnings where they are used.  */
4071       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4072         {
4073           tree decl;
4074
4075           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4076           if (decl && TREE_CODE (decl) == OVERLOAD)
4077             decl = OVL_FUNCTION (decl);
4078
4079           if (decl && decl != error_mark_node
4080               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4081               /* If different sort of thing, we already gave an error.  */
4082               && TREE_CODE (decl) == TREE_CODE (x)
4083               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4084             {
4085               pedwarn ("type mismatch with previous external decl", x);
4086               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4087             }
4088         }
4089
4090       /* This name is new in its binding level.
4091          Install the new declaration and return it.  */
4092       if (namespace_bindings_p ())
4093         {
4094           /* Install a global value.  */
4095
4096           /* If the first global decl has external linkage,
4097              warn if we later see static one.  */
4098           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4099             TREE_PUBLIC (name) = 1;
4100
4101           /* Bind the name for the entity.  */
4102           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4103                 && t != NULL_TREE)
4104               && (TREE_CODE (x) == TYPE_DECL
4105                   || TREE_CODE (x) == VAR_DECL
4106                   || TREE_CODE (x) == NAMESPACE_DECL
4107                   || TREE_CODE (x) == CONST_DECL
4108                   || TREE_CODE (x) == TEMPLATE_DECL))
4109             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4110
4111           /* Don't forget if the function was used via an implicit decl.  */
4112           if (IDENTIFIER_IMPLICIT_DECL (name)
4113               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4114             TREE_USED (x) = 1;
4115
4116           /* Don't forget if its address was taken in that way.  */
4117           if (IDENTIFIER_IMPLICIT_DECL (name)
4118               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4119             TREE_ADDRESSABLE (x) = 1;
4120
4121           /* Warn about mismatches against previous implicit decl.  */
4122           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4123               /* If this real decl matches the implicit, don't complain.  */
4124               && ! (TREE_CODE (x) == FUNCTION_DECL
4125                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4126             warning
4127               ("`%D' was previously implicitly declared to return `int'", x);
4128
4129           /* If new decl is `static' and an `extern' was seen previously,
4130              warn about it.  */
4131           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4132             warn_extern_redeclared_static (x, t);
4133         }
4134       else
4135         {
4136           /* Here to install a non-global value.  */
4137           tree oldlocal = IDENTIFIER_VALUE (name);
4138           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4139
4140           if (need_new_binding)
4141             {
4142               push_local_binding (name, x, 0);
4143               /* Because push_local_binding will hook X on to the
4144                  current_binding_level's name list, we don't want to
4145                  do that again below.  */
4146               need_new_binding = 0;
4147             }
4148
4149           /* If this is a TYPE_DECL, push it into the type value slot.  */
4150           if (TREE_CODE (x) == TYPE_DECL)
4151             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4152                                                   current_binding_level);
4153
4154           /* Clear out any TYPE_DECL shadowed by a namespace so that
4155              we won't think this is a type.  The C struct hack doesn't
4156              go through namespaces.  */
4157           if (TREE_CODE (x) == NAMESPACE_DECL)
4158             set_identifier_type_value_with_scope (name, NULL_TREE,
4159                                                   current_binding_level);
4160
4161           if (oldlocal)
4162             {
4163               tree d = oldlocal;
4164
4165               while (oldlocal
4166                      && TREE_CODE (oldlocal) == VAR_DECL
4167                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4168                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4169
4170               if (oldlocal == NULL_TREE)
4171                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4172             }
4173
4174           /* If this is an extern function declaration, see if we
4175              have a global definition or declaration for the function.  */
4176           if (oldlocal == NULL_TREE
4177               && DECL_EXTERNAL (x)
4178               && oldglobal != NULL_TREE
4179               && TREE_CODE (x) == FUNCTION_DECL
4180               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4181             {
4182               /* We have one.  Their types must agree.  */
4183               if (decls_match (x, oldglobal))
4184                 /* OK */;
4185               else
4186                 {
4187                   warning ("extern declaration of `%#D' doesn't match", x);
4188                   cp_warning_at ("global declaration `%#D'", oldglobal);
4189                 }
4190             }
4191           /* If we have a local external declaration,
4192              and no file-scope declaration has yet been seen,
4193              then if we later have a file-scope decl it must not be static.  */
4194           if (oldlocal == NULL_TREE
4195               && oldglobal == NULL_TREE
4196               && DECL_EXTERNAL (x)
4197               && TREE_PUBLIC (x))
4198             TREE_PUBLIC (name) = 1;
4199
4200           /* Warn if shadowing an argument at the top level of the body.  */
4201           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4202               /* Inline decls shadow nothing.  */
4203               && !DECL_FROM_INLINE (x)
4204               && TREE_CODE (oldlocal) == PARM_DECL)
4205             {
4206               bool err = false;
4207
4208               /* Don't complain if it's from an enclosing function.  */
4209               if (DECL_CONTEXT (oldlocal) == current_function_decl
4210                   && TREE_CODE (x) != PARM_DECL)
4211                 {
4212                   /* Go to where the parms should be and see if we find
4213                      them there.  */
4214                   struct binding_level *b = current_binding_level->level_chain;
4215
4216                   /* ARM $8.3 */
4217                   if (b->parm_flag == 1)
4218                     {
4219                       error ("declaration of `%#D' shadows a parameter",
4220                                 name);
4221                       err = true;
4222                     }
4223                 }
4224
4225               if (warn_shadow && !err)
4226                 shadow_warning ("a parameter", name, oldlocal);
4227             }
4228
4229           /* Maybe warn if shadowing something else.  */
4230           else if (warn_shadow && !DECL_EXTERNAL (x)
4231               /* No shadow warnings for internally generated vars.  */
4232               && ! DECL_ARTIFICIAL (x)
4233               /* No shadow warnings for vars made for inlining.  */
4234               && ! DECL_FROM_INLINE (x))
4235             {
4236               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4237                        && current_class_ptr
4238                        && !TREE_STATIC (name))
4239                 warning ("declaration of `%s' shadows a member of `this'",
4240                             IDENTIFIER_POINTER (name));
4241               else if (oldlocal != NULL_TREE
4242                        && TREE_CODE (oldlocal) == VAR_DECL)
4243                 shadow_warning ("a previous local", name, oldlocal);
4244               else if (oldglobal != NULL_TREE
4245                        && TREE_CODE (oldglobal) == VAR_DECL)
4246                 /* XXX shadow warnings in outer-more namespaces */
4247                 shadow_warning ("a global declaration", name, oldglobal);
4248             }
4249         }
4250
4251       if (TREE_CODE (x) == FUNCTION_DECL)
4252         check_default_args (x);
4253
4254       /* Keep count of variables in this level with incomplete type.  */
4255       if (TREE_CODE (x) == VAR_DECL
4256           && TREE_TYPE (x) != error_mark_node
4257           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4258                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4259               /* RTTI TD entries are created while defining the type_info.  */
4260               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4261                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4262         {
4263           if (namespace_bindings_p ())
4264             namespace_scope_incomplete
4265               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4266           else
4267             current_binding_level->incomplete
4268               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4269         }
4270     }
4271
4272   if (need_new_binding)
4273     add_decl_to_level (x,
4274                        DECL_NAMESPACE_SCOPE_P (x)
4275                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4276                        : current_binding_level);
4277
4278   return x;
4279 }
4280
4281 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4282    caller to set DECL_CONTEXT properly.  */
4283
4284 static tree
4285 pushdecl_with_scope (x, level)
4286      tree x;
4287      struct binding_level *level;
4288 {
4289   register struct binding_level *b;
4290   tree function_decl = current_function_decl;
4291
4292   current_function_decl = NULL_TREE;
4293   if (level->parm_flag == 2)
4294     {
4295       b = class_binding_level;
4296       class_binding_level = level;
4297       pushdecl_class_level (x);
4298       class_binding_level = b;
4299     }
4300   else
4301     {
4302       b = current_binding_level;
4303       current_binding_level = level;
4304       x = pushdecl (x);
4305       current_binding_level = b;
4306     }
4307   current_function_decl = function_decl;
4308   return x;
4309 }
4310
4311 /* Like pushdecl, only it places X in the current namespace,
4312    if appropriate.  */
4313
4314 tree
4315 pushdecl_namespace_level (x)
4316      tree x;
4317 {
4318   register struct binding_level *b = current_binding_level;
4319   register tree t;
4320
4321   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4322
4323   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4324      what we want.  */
4325   if (TREE_CODE (x) == TYPE_DECL)
4326     {
4327       tree name = DECL_NAME (x);
4328       tree newval;
4329       tree *ptr = (tree *)0;
4330       for (; b != global_binding_level; b = b->level_chain)
4331         {
4332           tree shadowed = b->type_shadowed;
4333           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4334             if (TREE_PURPOSE (shadowed) == name)
4335               {
4336                 ptr = &TREE_VALUE (shadowed);
4337                 /* Can't break out of the loop here because sometimes
4338                    a binding level will have duplicate bindings for
4339                    PT names.  It's gross, but I haven't time to fix it.  */
4340               }
4341         }
4342       newval = TREE_TYPE (x);
4343       if (ptr == (tree *)0)
4344         {
4345           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4346              up here if this is changed to an assertion.  --KR  */
4347           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4348         }
4349       else
4350         {
4351           *ptr = newval;
4352         }
4353     }
4354   return t;
4355 }
4356
4357 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4358    if appropriate.  */
4359
4360 tree
4361 pushdecl_top_level (x)
4362      tree x;
4363 {
4364   push_to_top_level ();
4365   x = pushdecl_namespace_level (x);
4366   pop_from_top_level ();
4367   return x;
4368 }
4369
4370 /* Make the declaration of X appear in CLASS scope.  */
4371
4372 void
4373 pushdecl_class_level (x)
4374      tree x;
4375 {
4376   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4377      scope looks for the pre-mangled name.  */
4378   register tree name;
4379
4380   if (TREE_CODE (x) == OVERLOAD)
4381     x = OVL_CURRENT (x);
4382   name = DECL_NAME (x);
4383
4384   if (name)
4385     {
4386       push_class_level_binding (name, x);
4387       if (TREE_CODE (x) == TYPE_DECL)
4388         set_identifier_type_value (name, TREE_TYPE (x));
4389     }
4390   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4391     {
4392       tree f;
4393
4394       for (f = TYPE_FIELDS (TREE_TYPE (x));
4395            f;
4396            f = TREE_CHAIN (f))
4397         pushdecl_class_level (f);
4398     }
4399 }
4400
4401 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4402    DECL, or a modified version thereof.  */
4403
4404 tree
4405 maybe_push_decl (decl)
4406      tree decl;
4407 {
4408   tree type = TREE_TYPE (decl);
4409
4410   /* Add this decl to the current binding level, but not if it comes
4411      from another scope, e.g. a static member variable.  TEM may equal
4412      DECL or it may be a previous decl of the same name.  */
4413   if (decl == error_mark_node
4414       || (TREE_CODE (decl) != PARM_DECL
4415           && DECL_CONTEXT (decl) != NULL_TREE
4416           /* Definitions of namespace members outside their namespace are
4417              possible. */
4418           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4419       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4420       || TREE_CODE (type) == UNKNOWN_TYPE
4421       /* The declaration of a template specialization does not affect
4422          the functions available for overload resolution, so we do not
4423          call pushdecl.  */
4424       || (TREE_CODE (decl) == FUNCTION_DECL
4425           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4426     return decl;
4427   else
4428     return pushdecl (decl);
4429 }
4430
4431 /* Make the declaration(s) of X appear in CLASS scope
4432    under the name NAME.  */
4433
4434 void
4435 push_class_level_binding (name, x)
4436      tree name;
4437      tree x;
4438 {
4439   tree binding;
4440   /* The class_binding_level will be NULL if x is a template
4441      parameter name in a member template.  */
4442   if (!class_binding_level)
4443     return;
4444
4445   /* Make sure that this new member does not have the same name
4446      as a template parameter.  */
4447   if (TYPE_BEING_DEFINED (current_class_type))
4448     check_template_shadow (x);
4449
4450   /* If this declaration shadows a declaration from an enclosing
4451      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4452      we leave this class.  Record the shadowed declaration here.  */
4453   binding = IDENTIFIER_BINDING (name);
4454   if (binding
4455       && ((TREE_CODE (x) == OVERLOAD
4456            && BINDING_VALUE (binding)
4457            && is_overloaded_fn (BINDING_VALUE (binding)))
4458           || INHERITED_VALUE_BINDING_P (binding)))
4459     {
4460       tree shadow;
4461       tree old_decl;
4462
4463       /* If the old binding was from a base class, and was for a tag
4464          name, slide it over to make room for the new binding.  The
4465          old binding is still visible if explicitly qualified with a
4466          class-key.  */
4467       if (INHERITED_VALUE_BINDING_P (binding)
4468           && BINDING_VALUE (binding)
4469           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4470           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4471           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4472         {
4473           old_decl = BINDING_TYPE (binding);
4474           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4475           BINDING_VALUE (binding) = NULL_TREE;
4476           INHERITED_VALUE_BINDING_P (binding) = 0;
4477         }
4478       else
4479         old_decl = BINDING_VALUE (binding);
4480
4481       /* Find the previous binding of name on the class-shadowed
4482          list, and update it.  */
4483       for (shadow = class_binding_level->class_shadowed;
4484            shadow;
4485            shadow = TREE_CHAIN (shadow))
4486         if (TREE_PURPOSE (shadow) == name
4487             && TREE_TYPE (shadow) == old_decl)
4488           {
4489             BINDING_VALUE (binding) = x;
4490             INHERITED_VALUE_BINDING_P (binding) = 0;
4491             TREE_TYPE (shadow) = x;
4492             IDENTIFIER_CLASS_VALUE (name) = x;
4493             return;
4494           }
4495     }
4496
4497   /* If we didn't replace an existing binding, put the binding on the
4498      stack of bindings for the identifier, and update the shadowed list.  */
4499   if (push_class_binding (name, x))
4500     {
4501       class_binding_level->class_shadowed
4502         = tree_cons (name, NULL,
4503                      class_binding_level->class_shadowed);
4504       /* Record the value we are binding NAME to so that we can know
4505          what to pop later.  */
4506       TREE_TYPE (class_binding_level->class_shadowed) = x;
4507     }
4508 }
4509
4510 /* Insert another USING_DECL into the current binding level, returning
4511    this declaration. If this is a redeclaration, do nothing, and
4512    return NULL_TREE if this not in namespace scope (in namespace
4513    scope, a using decl might extend any previous bindings).  */
4514
4515 tree
4516 push_using_decl (scope, name)
4517      tree scope;
4518      tree name;
4519 {
4520   tree decl;
4521
4522   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4523   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4524   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4525     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4526       break;
4527   if (decl)
4528     return namespace_bindings_p () ? decl : NULL_TREE;
4529   decl = build_lang_decl (USING_DECL, name, void_type_node);
4530   DECL_INITIAL (decl) = scope;
4531   TREE_CHAIN (decl) = current_binding_level->usings;
4532   current_binding_level->usings = decl;
4533   return decl;
4534 }
4535
4536 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4537    changed (i.e. there was already a directive), or the fresh
4538    TREE_LIST otherwise.  */
4539
4540 tree
4541 push_using_directive (used)
4542      tree used;
4543 {
4544   tree ud = current_binding_level->using_directives;
4545   tree iter, ancestor;
4546
4547   /* Check if we already have this. */
4548   if (purpose_member (used, ud) != NULL_TREE)
4549     return NULL_TREE;
4550
4551   /* Recursively add all namespaces used. */
4552   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4553     push_using_directive (TREE_PURPOSE (iter));
4554
4555   ancestor = namespace_ancestor (current_decl_namespace (), used);
4556   ud = current_binding_level->using_directives;
4557   ud = tree_cons (used, ancestor, ud);
4558   current_binding_level->using_directives = ud;
4559   return ud;
4560 }
4561
4562 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4563    other definitions already in place.  We get around this by making
4564    the value of the identifier point to a list of all the things that
4565    want to be referenced by that name.  It is then up to the users of
4566    that name to decide what to do with that list.
4567
4568    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4569    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4570
4571    FLAGS is a bitwise-or of the following values:
4572      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4573                  namespace scope.
4574      PUSH_USING: DECL is being pushed as the result of a using
4575                  declaration.
4576
4577    The value returned may be a previous declaration if we guessed wrong
4578    about what language DECL should belong to (C or C++).  Otherwise,
4579    it's always DECL (and never something that's not a _DECL).  */
4580
4581 tree
4582 push_overloaded_decl (decl, flags)
4583      tree decl;
4584      int flags;
4585 {
4586   tree name = DECL_NAME (decl);
4587   tree old;
4588   tree new_binding;
4589   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4590
4591   if (doing_global)
4592     old = namespace_binding (name, DECL_CONTEXT (decl));
4593   else
4594     old = lookup_name_current_level (name);
4595
4596   if (old)
4597     {
4598       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4599         {
4600           tree t = TREE_TYPE (old);
4601           if (IS_AGGR_TYPE (t) && warn_shadow
4602               && (! DECL_IN_SYSTEM_HEADER (decl)
4603                   || ! DECL_IN_SYSTEM_HEADER (old)))
4604             warning ("`%#D' hides constructor for `%#T'", decl, t);
4605           old = NULL_TREE;
4606         }
4607       else if (is_overloaded_fn (old))
4608         {
4609           tree tmp;
4610
4611           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4612             {
4613               tree fn = OVL_CURRENT (tmp);
4614
4615               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4616                   && !(flags & PUSH_USING)
4617                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4618                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4619                 error ("`%#D' conflicts with previous using declaration `%#D'",
4620                           decl, fn);
4621
4622               if (duplicate_decls (decl, fn))
4623                 return fn;
4624             }
4625         }
4626       else if (old == error_mark_node)
4627         /* Ignore the undefined symbol marker.  */
4628         old = NULL_TREE;
4629       else
4630         {
4631           cp_error_at ("previous non-function declaration `%#D'", old);
4632           error ("conflicts with function declaration `%#D'", decl);
4633           return decl;
4634         }
4635     }
4636
4637   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4638     {
4639       if (old && TREE_CODE (old) != OVERLOAD)
4640         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4641       else
4642         new_binding = ovl_cons (decl, old);
4643       if (flags & PUSH_USING)
4644         OVL_USED (new_binding) = 1;
4645     }
4646   else
4647     /* NAME is not ambiguous.  */
4648     new_binding = decl;
4649
4650   if (doing_global)
4651     set_namespace_binding (name, current_namespace, new_binding);
4652   else
4653     {
4654       /* We only create an OVERLOAD if there was a previous binding at
4655          this level, or if decl is a template. In the former case, we
4656          need to remove the old binding and replace it with the new
4657          binding.  We must also run through the NAMES on the binding
4658          level where the name was bound to update the chain.  */
4659
4660       if (TREE_CODE (new_binding) == OVERLOAD && old)
4661         {
4662           tree *d;
4663
4664           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4665                *d;
4666                d = &TREE_CHAIN (*d))
4667             if (*d == old
4668                 || (TREE_CODE (*d) == TREE_LIST
4669                     && TREE_VALUE (*d) == old))
4670               {
4671                 if (TREE_CODE (*d) == TREE_LIST)
4672                   /* Just replace the old binding with the new.  */
4673                   TREE_VALUE (*d) = new_binding;
4674                 else
4675                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4676                   *d = tree_cons (NULL_TREE, new_binding,
4677                                   TREE_CHAIN (*d));
4678
4679                 /* And update the CPLUS_BINDING node.  */
4680                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4681                   = new_binding;
4682                 return decl;
4683               }
4684
4685           /* We should always find a previous binding in this case.  */
4686           abort ();
4687         }
4688
4689       /* Install the new binding.  */
4690       push_local_binding (name, new_binding, flags);
4691     }
4692
4693   return decl;
4694 }
4695 \f
4696 /* Generate an implicit declaration for identifier FUNCTIONID
4697    as a function of type int ().  Print a warning if appropriate.  */
4698
4699 tree
4700 implicitly_declare (functionid)
4701      tree functionid;
4702 {
4703   register tree decl;
4704
4705   /* We used to reuse an old implicit decl here,
4706      but this loses with inline functions because it can clobber
4707      the saved decl chains.  */
4708   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4709
4710   DECL_EXTERNAL (decl) = 1;
4711   TREE_PUBLIC (decl) = 1;
4712
4713   /* ISO standard says implicit declarations are in the innermost block.
4714      So we record the decl in the standard fashion.  */
4715   pushdecl (decl);
4716   rest_of_decl_compilation (decl, NULL, 0, 0);
4717
4718   if (warn_implicit
4719       /* Only one warning per identifier.  */
4720       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4721     {
4722       pedwarn ("implicit declaration of function `%#D'", decl);
4723     }
4724
4725   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4726
4727   return decl;
4728 }
4729
4730 /* Return zero if the declaration NEWDECL is valid
4731    when the declaration OLDDECL (assumed to be for the same name)
4732    has already been seen.
4733    Otherwise return an error message format string with a %s
4734    where the identifier should go.  */
4735
4736 static const char *
4737 redeclaration_error_message (newdecl, olddecl)
4738      tree newdecl, olddecl;
4739 {
4740   if (TREE_CODE (newdecl) == TYPE_DECL)
4741     {
4742       /* Because C++ can put things into name space for free,
4743          constructs like "typedef struct foo { ... } foo"
4744          would look like an erroneous redeclaration.  */
4745       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4746         return 0;
4747       else
4748         return "redefinition of `%#D'";
4749     }
4750   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4751     {
4752       /* If this is a pure function, its olddecl will actually be
4753          the original initialization to `0' (which we force to call
4754          abort()).  Don't complain about redefinition in this case.  */
4755       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4756         return 0;
4757
4758       /* If both functions come from different namespaces, this is not
4759          a redeclaration - this is a conflict with a used function. */
4760       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4761           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4762         return "`%D' conflicts with used function";
4763
4764       /* We'll complain about linkage mismatches in
4765          warn_extern_redeclared_static.  */
4766
4767       /* Defining the same name twice is no good.  */
4768       if (DECL_INITIAL (olddecl) != NULL_TREE
4769           && DECL_INITIAL (newdecl) != NULL_TREE)
4770         {
4771           if (DECL_NAME (olddecl) == NULL_TREE)
4772             return "`%#D' not declared in class";
4773           else
4774             return "redefinition of `%#D'";
4775         }
4776       return 0;
4777     }
4778   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4779     {
4780       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4781            && (DECL_TEMPLATE_RESULT (newdecl)
4782                != DECL_TEMPLATE_RESULT (olddecl))
4783            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4784            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4785           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4786               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4787               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4788         return "redefinition of `%#D'";
4789       return 0;
4790     }
4791   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4792     {
4793       /* Objects declared at top level:  */
4794       /* If at least one is a reference, it's ok.  */
4795       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4796         return 0;
4797       /* Reject two definitions.  */
4798       return "redefinition of `%#D'";
4799     }
4800   else
4801     {
4802       /* Objects declared with block scope:  */
4803       /* Reject two definitions, and reject a definition
4804          together with an external reference.  */
4805       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4806         return "redeclaration of `%#D'";
4807       return 0;
4808     }
4809 }
4810 \f
4811 /* Create a new label, named ID.  */
4812
4813 static tree
4814 make_label_decl (id, local_p)
4815      tree id;
4816      int local_p;
4817 {
4818   tree decl;
4819
4820   decl = build_decl (LABEL_DECL, id, void_type_node);
4821   if (expanding_p)
4822     /* Make sure every label has an rtx.  */
4823     label_rtx (decl);
4824
4825   DECL_CONTEXT (decl) = current_function_decl;
4826   DECL_MODE (decl) = VOIDmode;
4827   C_DECLARED_LABEL_FLAG (decl) = local_p;
4828
4829   /* Say where one reference is to the label, for the sake of the
4830      error if it is not defined.  */
4831   DECL_SOURCE_LINE (decl) = lineno;
4832   DECL_SOURCE_FILE (decl) = input_filename;
4833
4834   /* Record the fact that this identifier is bound to this label.  */
4835   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4836
4837   return decl;
4838 }
4839
4840 /* Record this label on the list of used labels so that we can check
4841    at the end of the function to see whether or not the label was
4842    actually defined, and so we can check when the label is defined whether
4843    this use is valid.  */
4844
4845 static void
4846 use_label (decl)
4847      tree decl;
4848 {
4849   if (named_label_uses == NULL
4850       || named_label_uses->names_in_scope != current_binding_level->names
4851       || named_label_uses->label_decl != decl)
4852     {
4853       struct named_label_use_list *new_ent;
4854       new_ent = ((struct named_label_use_list *)
4855                  ggc_alloc (sizeof (struct named_label_use_list)));
4856       new_ent->label_decl = decl;
4857       new_ent->names_in_scope = current_binding_level->names;
4858       new_ent->binding_level = current_binding_level;
4859       new_ent->lineno_o_goto = lineno;
4860       new_ent->filename_o_goto = input_filename;
4861       new_ent->next = named_label_uses;
4862       named_label_uses = new_ent;
4863     }
4864 }
4865
4866 /* Look for a label named ID in the current function.  If one cannot
4867    be found, create one.  (We keep track of used, but undefined,
4868    labels, and complain about them at the end of a function.)  */
4869
4870 tree
4871 lookup_label (id)
4872      tree id;
4873 {
4874   tree decl;
4875   struct named_label_list *ent;
4876
4877   /* You can't use labels at global scope.  */
4878   if (current_function_decl == NULL_TREE)
4879     {
4880       error ("label `%s' referenced outside of any function",
4881              IDENTIFIER_POINTER (id));
4882       return NULL_TREE;
4883     }
4884
4885   /* See if we've already got this label.  */
4886   decl = IDENTIFIER_LABEL_VALUE (id);
4887   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4888     return decl;
4889
4890   /* Record this label on the list of labels used in this function.
4891      We do this before calling make_label_decl so that we get the
4892      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4893   ent = ((struct named_label_list *)
4894          ggc_alloc_cleared (sizeof (struct named_label_list)));
4895   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4896   ent->next = named_labels;
4897   named_labels = ent;
4898
4899   /* We need a new label.  */
4900   decl = make_label_decl (id, /*local_p=*/0);
4901
4902   /* Now fill in the information we didn't have before.  */
4903   ent->label_decl = decl;
4904
4905   return decl;
4906 }
4907
4908 /* Declare a local label named ID.  */
4909
4910 tree
4911 declare_local_label (id)
4912      tree id;
4913 {
4914   tree decl;
4915
4916   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4917      this scope we can restore the old value of
4918      IDENTIFIER_TYPE_VALUE.  */
4919   current_binding_level->shadowed_labels
4920     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4921                  current_binding_level->shadowed_labels);
4922   /* Look for the label.  */
4923   decl = make_label_decl (id, /*local_p=*/1);
4924   /* Now fill in the information we didn't have before.  */
4925   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4926
4927   return decl;
4928 }
4929
4930 /* Returns nonzero if it is ill-formed to jump past the declaration of
4931    DECL.  Returns 2 if it's also a real problem.  */
4932
4933 static int
4934 decl_jump_unsafe (decl)
4935      tree decl;
4936 {
4937   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4938     return 0;
4939
4940   if (DECL_INITIAL (decl) == NULL_TREE
4941       && pod_type_p (TREE_TYPE (decl)))
4942     return 0;
4943
4944   /* This is really only important if we're crossing an initialization.
4945      The POD stuff is just pedantry; why should it matter if the class
4946      contains a field of pointer to member type?  */
4947   if (DECL_INITIAL (decl)
4948       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4949     return 2;
4950   return 1;
4951 }
4952
4953 /* Check that a single previously seen jump to a newly defined label
4954    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4955    the jump context; NAMES are the names in scope in LEVEL at the jump
4956    context; FILE and LINE are the source position of the jump or 0.  */
4957
4958 static void
4959 check_previous_goto_1 (decl, level, names, file, line)
4960      tree decl;
4961      struct binding_level *level;
4962      tree names;
4963      const char *file;
4964      int line;
4965 {
4966   int identified = 0;
4967   int saw_eh = 0;
4968   struct binding_level *b = current_binding_level;
4969   for (; b; b = b->level_chain)
4970     {
4971       tree new_decls = b->names;
4972       tree old_decls = (b == level ? names : NULL_TREE);
4973       for (; new_decls != old_decls;
4974            new_decls = TREE_CHAIN (new_decls))
4975         {
4976           int problem = decl_jump_unsafe (new_decls);
4977           if (! problem)
4978             continue;
4979
4980           if (! identified)
4981             {
4982               if (decl)
4983                 pedwarn ("jump to label `%D'", decl);
4984               else
4985                 pedwarn ("jump to case label");
4986
4987               if (file)
4988                 pedwarn_with_file_and_line (file, line, "  from here");
4989               identified = 1;
4990             }
4991
4992           if (problem > 1)
4993             cp_error_at ("  crosses initialization of `%#D'",
4994                          new_decls);
4995           else
4996             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4997                            new_decls);
4998         }
4999
5000       if (b == level)
5001         break;
5002       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
5003         {
5004           if (! identified)
5005             {
5006               if (decl)
5007                 pedwarn ("jump to label `%D'", decl);
5008               else
5009                 pedwarn ("jump to case label");
5010
5011               if (file)
5012                 pedwarn_with_file_and_line (file, line, "  from here");
5013               identified = 1;
5014             }
5015           if (b->is_try_scope)
5016             error ("  enters try block");
5017           else
5018             error ("  enters catch block");
5019           saw_eh = 1;
5020         }
5021     }
5022 }
5023
5024 static void
5025 check_previous_goto (use)
5026      struct named_label_use_list *use;
5027 {
5028   check_previous_goto_1 (use->label_decl, use->binding_level,
5029                          use->names_in_scope, use->filename_o_goto,
5030                          use->lineno_o_goto);
5031 }
5032
5033 static void
5034 check_switch_goto (level)
5035      struct binding_level *level;
5036 {
5037   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5038 }
5039
5040 /* Check that any previously seen jumps to a newly defined label DECL
5041    are OK.  Called by define_label.  */
5042
5043 static void
5044 check_previous_gotos (decl)
5045      tree decl;
5046 {
5047   struct named_label_use_list **usep;
5048
5049   if (! TREE_USED (decl))
5050     return;
5051
5052   for (usep = &named_label_uses; *usep; )
5053     {
5054       struct named_label_use_list *use = *usep;
5055       if (use->label_decl == decl)
5056         {
5057           check_previous_goto (use);
5058           *usep = use->next;
5059         }
5060       else
5061         usep = &(use->next);
5062     }
5063 }
5064
5065 /* Check that a new jump to a label DECL is OK.  Called by
5066    finish_goto_stmt.  */
5067
5068 void
5069 check_goto (decl)
5070      tree decl;
5071 {
5072   int identified = 0;
5073   tree bad;
5074   struct named_label_list *lab;
5075
5076   /* We can't know where a computed goto is jumping.  So we assume
5077      that it's OK.  */
5078   if (! DECL_P (decl))
5079     return;
5080
5081   /* If the label hasn't been defined yet, defer checking.  */
5082   if (! DECL_INITIAL (decl))
5083     {
5084       use_label (decl);
5085       return;
5086     }
5087
5088   for (lab = named_labels; lab; lab = lab->next)
5089     if (decl == lab->label_decl)
5090       break;
5091
5092   /* If the label is not on named_labels it's a gcc local label, so
5093      it must be in an outer scope, so jumping to it is always OK.  */
5094   if (lab == 0)
5095     return;
5096
5097   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5098       && !identified)
5099     {
5100       cp_pedwarn_at ("jump to label `%D'", decl);
5101       pedwarn ("  from here");
5102       identified = 1;
5103     }
5104
5105   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5106     {
5107       tree b = TREE_VALUE (bad);
5108       int u = decl_jump_unsafe (b);
5109
5110       if (u > 1 && DECL_ARTIFICIAL (b))
5111         /* Can't skip init of __exception_info.  */
5112         cp_error_at ("  enters catch block", b);
5113       else if (u > 1)
5114         cp_error_at ("  skips initialization of `%#D'", b);
5115       else
5116         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5117     }
5118
5119   if (lab->in_try_scope)
5120     error ("  enters try block");
5121   else if (lab->in_catch_scope)
5122     error ("  enters catch block");
5123 }
5124
5125 /* Define a label, specifying the location in the source file.
5126    Return the LABEL_DECL node for the label, if the definition is valid.
5127    Otherwise return 0.  */
5128
5129 tree
5130 define_label (filename, line, name)
5131      const char *filename;
5132      int line;
5133      tree name;
5134 {
5135   tree decl = lookup_label (name);
5136   struct named_label_list *ent;
5137   register struct binding_level *p;
5138
5139   for (ent = named_labels; ent; ent = ent->next)
5140     if (ent->label_decl == decl)
5141       break;
5142
5143   /* After labels, make any new cleanups in the function go into their
5144      own new (temporary) binding contour.  */
5145   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5146     p->more_cleanups_ok = 0;
5147
5148   if (name == get_identifier ("wchar_t"))
5149     pedwarn ("label named wchar_t");
5150
5151   if (DECL_INITIAL (decl) != NULL_TREE)
5152     {
5153       error ("duplicate label `%D'", decl);
5154       return 0;
5155     }
5156   else
5157     {
5158       /* Mark label as having been defined.  */
5159       DECL_INITIAL (decl) = error_mark_node;
5160       /* Say where in the source.  */
5161       DECL_SOURCE_FILE (decl) = filename;
5162       DECL_SOURCE_LINE (decl) = line;
5163       if (ent)
5164         {
5165           ent->names_in_scope = current_binding_level->names;
5166           ent->binding_level = current_binding_level;
5167         }
5168       check_previous_gotos (decl);
5169       return decl;
5170     }
5171 }
5172
5173 struct cp_switch
5174 {
5175   struct binding_level *level;
5176   struct cp_switch *next;
5177   /* The SWITCH_STMT being built.  */
5178   tree switch_stmt;
5179   /* A splay-tree mapping the low element of a case range to the high
5180      element, or NULL_TREE if there is no high element.  Used to
5181      determine whether or not a new case label duplicates an old case
5182      label.  We need a tree, rather than simply a hash table, because
5183      of the GNU case range extension.  */
5184   splay_tree cases;
5185 };
5186
5187 /* A stack of the currently active switch statements.  The innermost
5188    switch statement is on the top of the stack.  There is no need to
5189    mark the stack for garbage collection because it is only active
5190    during the processing of the body of a function, and we never
5191    collect at that point.  */
5192
5193 static struct cp_switch *switch_stack;
5194
5195 /* Called right after a switch-statement condition is parsed.
5196    SWITCH_STMT is the switch statement being parsed.  */
5197
5198 void
5199 push_switch (switch_stmt)
5200      tree switch_stmt;
5201 {
5202   struct cp_switch *p
5203     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5204   p->level = current_binding_level;
5205   p->next = switch_stack;
5206   p->switch_stmt = switch_stmt;
5207   p->cases = splay_tree_new (case_compare, NULL, NULL);
5208   switch_stack = p;
5209 }
5210
5211 void
5212 pop_switch ()
5213 {
5214   struct cp_switch *cs;
5215
5216   cs = switch_stack;
5217   splay_tree_delete (cs->cases);
5218   switch_stack = switch_stack->next;
5219   free (cs);
5220 }
5221
5222 /* Note that we've seen a definition of a case label, and complain if this
5223    is a bad place for one.  */
5224
5225 tree
5226 finish_case_label (low_value, high_value)
5227      tree low_value;
5228      tree high_value;
5229 {
5230   tree cond, r;
5231   register struct binding_level *p;
5232
5233   if (! switch_stack)
5234     {
5235       if (high_value)
5236         error ("case label not within a switch statement");
5237       else if (low_value)
5238         error ("case label `%E' not within a switch statement",
5239                   low_value);
5240       else
5241         error ("`default' label not within a switch statement");
5242       return NULL_TREE;
5243     }
5244
5245   if (processing_template_decl)
5246     {
5247       tree label;
5248
5249       /* For templates, just add the case label; we'll do semantic
5250          analysis at instantiation-time.  */
5251       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5252       return add_stmt (build_case_label (low_value, high_value, label));
5253     }
5254
5255   /* Find the condition on which this switch statement depends.  */
5256   cond = SWITCH_COND (switch_stack->switch_stmt);
5257   if (cond && TREE_CODE (cond) == TREE_LIST)
5258     cond = TREE_VALUE (cond);
5259
5260   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5261   if (r == error_mark_node)
5262     r = NULL_TREE;
5263
5264   check_switch_goto (switch_stack->level);
5265
5266   /* After labels, make any new cleanups in the function go into their
5267      own new (temporary) binding contour.  */
5268   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5269     p->more_cleanups_ok = 0;
5270
5271   return r;
5272 }
5273 \f
5274 /* Return the list of declarations of the current level.
5275    Note that this list is in reverse order unless/until
5276    you nreverse it; and when you do nreverse it, you must
5277    store the result back using `storedecls' or you will lose.  */
5278
5279 tree
5280 getdecls ()
5281 {
5282   return current_binding_level->names;
5283 }
5284
5285 /* Return the list of type-tags (for structs, etc) of the current level.  */
5286
5287 tree
5288 gettags ()
5289 {
5290   return current_binding_level->tags;
5291 }
5292
5293 /* Store the list of declarations of the current level.
5294    This is done for the parameter declarations of a function being defined,
5295    after they are modified in the light of any missing parameters.  */
5296
5297 static void
5298 storedecls (decls)
5299      tree decls;
5300 {
5301   current_binding_level->names = decls;
5302 }
5303
5304 /* Similarly, store the list of tags of the current level.  */
5305
5306 void
5307 storetags (tags)
5308      tree tags;
5309 {
5310   current_binding_level->tags = tags;
5311 }
5312 \f
5313 /* Given NAME, an IDENTIFIER_NODE,
5314    return the structure (or union or enum) definition for that name.
5315    Searches binding levels from BINDING_LEVEL up to the global level.
5316    If THISLEVEL_ONLY is nonzero, searches only the specified context
5317    (but skips any tag-transparent contexts to find one that is
5318    meaningful for tags).
5319    FORM says which kind of type the caller wants;
5320    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5321    If the wrong kind of type is found, and it's not a template, an error is
5322    reported.  */
5323
5324 static tree
5325 lookup_tag (form, name, binding_level, thislevel_only)
5326      enum tree_code form;
5327      tree name;
5328      struct binding_level *binding_level;
5329      int thislevel_only;
5330 {
5331   register struct binding_level *level;
5332   /* Non-zero if, we should look past a template parameter level, even
5333      if THISLEVEL_ONLY.  */
5334   int allow_template_parms_p = 1;
5335
5336   for (level = binding_level; level; level = level->level_chain)
5337     {
5338       register tree tail;
5339       if (ANON_AGGRNAME_P (name))
5340         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5341           {
5342             /* There's no need for error checking here, because
5343                anon names are unique throughout the compilation.  */
5344             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5345               return TREE_VALUE (tail);
5346           }
5347       else if (level->namespace_p)
5348         /* Do namespace lookup. */
5349         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5350           {
5351             tree old = binding_for_name (name, tail);
5352
5353             /* If we just skipped past a template parameter level,
5354                even though THISLEVEL_ONLY, and we find a template
5355                class declaration, then we use the _TYPE node for the
5356                template.  See the example below.  */
5357             if (thislevel_only && !allow_template_parms_p
5358                 && old && BINDING_VALUE (old)
5359                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5360               old = TREE_TYPE (BINDING_VALUE (old));
5361             else
5362               old = BINDING_TYPE (old);
5363
5364             /* If it has an original type, it is a typedef, and we
5365                should not return it.  */
5366             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5367               old = NULL_TREE;
5368             if (old && TREE_CODE (old) != form
5369                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5370               {
5371                 error ("`%#D' redeclared as %C", old, form);
5372                 return NULL_TREE;
5373               }
5374             if (old)
5375               return old;
5376             if (thislevel_only || tail == global_namespace)
5377               return NULL_TREE;
5378           }
5379       else
5380         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5381           {
5382             if (TREE_PURPOSE (tail) == name)
5383               {
5384                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5385                 /* Should tighten this up; it'll probably permit
5386                    UNION_TYPE and a struct template, for example.  */
5387                 if (code != form
5388                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5389                   {
5390                     /* Definition isn't the kind we were looking for.  */
5391                     error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5392                               form);
5393                     return NULL_TREE;
5394                   }
5395                 return TREE_VALUE (tail);
5396               }
5397           }
5398       if (thislevel_only && ! level->tag_transparent)
5399         {
5400           if (level->template_parms_p && allow_template_parms_p)
5401             {
5402               /* We must deal with cases like this:
5403
5404                    template <class T> struct S;
5405                    template <class T> struct S {};
5406
5407                  When looking up `S', for the second declaration, we
5408                  would like to find the first declaration.  But, we
5409                  are in the pseudo-global level created for the
5410                  template parameters, rather than the (surrounding)
5411                  namespace level.  Thus, we keep going one more level,
5412                  even though THISLEVEL_ONLY is non-zero.  */
5413               allow_template_parms_p = 0;
5414               continue;
5415             }
5416           else
5417             return NULL_TREE;
5418         }
5419     }
5420   return NULL_TREE;
5421 }
5422
5423 #if 0
5424 void
5425 set_current_level_tags_transparency (tags_transparent)
5426      int tags_transparent;
5427 {
5428   current_binding_level->tag_transparent = tags_transparent;
5429 }
5430 #endif
5431
5432 /* Given a type, find the tag that was defined for it and return the tag name.
5433    Otherwise return 0.  However, the value can never be 0
5434    in the cases in which this is used.
5435
5436    C++: If NAME is non-zero, this is the new name to install.  This is
5437    done when replacing anonymous tags with real tag names.  */
5438
5439 static tree
5440 lookup_tag_reverse (type, name)
5441      tree type;
5442      tree name;
5443 {
5444   register struct binding_level *level;
5445
5446   for (level = current_binding_level; level; level = level->level_chain)
5447     {
5448       register tree tail;
5449       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5450         {
5451           if (TREE_VALUE (tail) == type)
5452             {
5453               if (name)
5454                 TREE_PURPOSE (tail) = name;
5455               return TREE_PURPOSE (tail);
5456             }
5457         }
5458     }
5459   return NULL_TREE;
5460 }
5461 \f
5462 /* Look up NAME in the NAMESPACE.  */
5463
5464 tree
5465 lookup_namespace_name (namespace, name)
5466      tree namespace, name;
5467 {
5468   tree val;
5469   tree template_id = NULL_TREE;
5470
5471   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5472
5473   if (TREE_CODE (name) == NAMESPACE_DECL)
5474     /* This happens for A::B<int> when B is a namespace. */
5475     return name;
5476   else if (TREE_CODE (name) == TEMPLATE_DECL)
5477     {
5478       /* This happens for A::B where B is a template, and there are no
5479          template arguments.  */
5480       error ("invalid use of `%D'", name);
5481       return error_mark_node;
5482     }
5483
5484   namespace = ORIGINAL_NAMESPACE (namespace);
5485
5486   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5487     {
5488       template_id = name;
5489       name = TREE_OPERAND (name, 0);
5490       if (TREE_CODE (name) == OVERLOAD)
5491         name = DECL_NAME (OVL_CURRENT (name));
5492       else if (DECL_P (name))
5493         name = DECL_NAME (name);
5494     }
5495
5496   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5497
5498   val = make_node (CPLUS_BINDING);
5499   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5500     return error_mark_node;
5501
5502   if (BINDING_VALUE (val))
5503     {
5504       val = BINDING_VALUE (val);
5505
5506       if (template_id)
5507         {
5508           if (DECL_CLASS_TEMPLATE_P (val))
5509             val = lookup_template_class (val,
5510                                          TREE_OPERAND (template_id, 1),
5511                                          /*in_decl=*/NULL_TREE,
5512                                          /*context=*/NULL_TREE,
5513                                          /*entering_scope=*/0,
5514                                          /*complain=*/1);
5515           else if (DECL_FUNCTION_TEMPLATE_P (val)
5516                    || TREE_CODE (val) == OVERLOAD)
5517             val = lookup_template_function (val,
5518                                             TREE_OPERAND (template_id, 1));
5519           else
5520             {
5521               error ("`%D::%D' is not a template",
5522                         namespace, name);
5523               return error_mark_node;
5524             }
5525         }
5526
5527       /* If we have a single function from a using decl, pull it out.  */
5528       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5529         val = OVL_FUNCTION (val);
5530       return val;
5531     }
5532
5533   error ("`%D' undeclared in namespace `%D'", name, namespace);
5534   return error_mark_node;
5535 }
5536
5537 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5538
5539 static unsigned long
5540 typename_hash (k)
5541      hash_table_key k;
5542 {
5543   unsigned long hash;
5544   tree t;
5545
5546   t = (tree) k;
5547   hash = (((unsigned long) TYPE_CONTEXT (t))
5548           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5549
5550   return hash;
5551 }
5552
5553 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5554
5555 static bool
5556 typename_compare (k1, k2)
5557      hash_table_key k1;
5558      hash_table_key k2;
5559 {
5560   tree t1;
5561   tree t2;
5562   tree d1;
5563   tree d2;
5564
5565   t1 = (tree) k1;
5566   t2 = (tree) k2;
5567   d1 = TYPE_NAME (t1);
5568   d2 = TYPE_NAME (t2);
5569
5570   return (DECL_NAME (d1) == DECL_NAME (d2)
5571           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5572           && ((TREE_TYPE (t1) != NULL_TREE)
5573               == (TREE_TYPE (t2) != NULL_TREE))
5574           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5575           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5576 }
5577
5578 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5579    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5580    is non-NULL, this type is being created by the implicit typename
5581    extension, and BASE_TYPE is a type named `t' in some base class of
5582    `T' which depends on template parameters.
5583
5584    Returns the new TYPENAME_TYPE.  */
5585
5586 tree
5587 build_typename_type (context, name, fullname, base_type)
5588      tree context;
5589      tree name;
5590      tree fullname;
5591      tree base_type;
5592 {
5593   tree t;
5594   tree d;
5595   struct hash_entry *e;
5596
5597   static struct hash_table ht;
5598
5599   if (!ht.table)
5600     {
5601       static struct hash_table *h = &ht;
5602
5603       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5604       ggc_add_tree_hash_table_root (&h, 1);
5605     }
5606
5607   /* Build the TYPENAME_TYPE.  */
5608   t = make_aggr_type (TYPENAME_TYPE);
5609   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5610   TYPENAME_TYPE_FULLNAME (t) = fullname;
5611   TREE_TYPE (t) = base_type;
5612
5613   /* Build the corresponding TYPE_DECL.  */
5614   d = build_decl (TYPE_DECL, name, t);
5615   TYPE_NAME (TREE_TYPE (d)) = d;
5616   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5617   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5618   DECL_ARTIFICIAL (d) = 1;
5619
5620   /* See if we already have this type.  */
5621   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5622   if (e)
5623     t = (tree) e->key;
5624   else
5625     /* Insert the type into the table.  */
5626     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5627
5628   return t;
5629 }
5630
5631 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5632    unless an error occurs, in which case error_mark_node is returned.
5633    If COMPLAIN zero, don't complain about any errors that occur.  */
5634
5635 tree
5636 make_typename_type (context, name, complain)
5637      tree context, name;
5638      int complain;
5639 {
5640   tree fullname;
5641
5642   if (TYPE_P (name))
5643     {
5644       if (!(TYPE_LANG_SPECIFIC (name)
5645             && (CLASSTYPE_IS_TEMPLATE (name)
5646                 || CLASSTYPE_USE_TEMPLATE (name))))
5647         name = TYPE_IDENTIFIER (name);
5648       else
5649         /* Create a TEMPLATE_ID_EXPR for the type.  */
5650         name = build_nt (TEMPLATE_ID_EXPR,
5651                          CLASSTYPE_TI_TEMPLATE (name),
5652                          CLASSTYPE_TI_ARGS (name));
5653     }
5654   else if (TREE_CODE (name) == TYPE_DECL)
5655     name = DECL_NAME (name);
5656
5657   fullname = name;
5658
5659   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5660     {
5661       name = TREE_OPERAND (name, 0);
5662       if (TREE_CODE (name) == TEMPLATE_DECL)
5663         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5664     }
5665   if (TREE_CODE (name) == TEMPLATE_DECL)
5666     {
5667       error ("`%D' used without template parameters", name);
5668       return error_mark_node;
5669     }
5670   if (TREE_CODE (name) != IDENTIFIER_NODE)
5671     abort ();
5672
5673   if (TREE_CODE (context) == NAMESPACE_DECL)
5674     {
5675       /* We can get here from typename_sub0 in the explicit_template_type
5676          expansion.  Just fail.  */
5677       if (complain)
5678         error ("no class template named `%#T' in `%#T'",
5679                   name, context);
5680       return error_mark_node;
5681     }
5682
5683   if (! uses_template_parms (context)
5684       || currently_open_class (context))
5685     {
5686       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5687         {
5688           tree tmpl = NULL_TREE;
5689           if (IS_AGGR_TYPE (context))
5690             tmpl = lookup_field (context, name, 0, 0);
5691           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5692             {
5693               if (complain)
5694                 error ("no class template named `%#T' in `%#T'",
5695                           name, context);
5696               return error_mark_node;
5697             }
5698
5699           return lookup_template_class (tmpl,
5700                                         TREE_OPERAND (fullname, 1),
5701                                         NULL_TREE, context,
5702                                         /*entering_scope=*/0,
5703                                         /*complain=*/1);
5704         }
5705       else
5706         {
5707           tree t;
5708
5709           if (!IS_AGGR_TYPE (context))
5710             {
5711               if (complain)
5712                 error ("no type named `%#T' in `%#T'", name, context);
5713               return error_mark_node;
5714             }
5715
5716           t = lookup_field (context, name, 0, 1);
5717           if (t)
5718             return TREE_TYPE (t);
5719         }
5720     }
5721
5722   /* If the CONTEXT is not a template type, then either the field is
5723      there now or its never going to be.  */
5724   if (!uses_template_parms (context))
5725     {
5726       if (complain)
5727         error ("no type named `%#T' in `%#T'", name, context);
5728       return error_mark_node;
5729     }
5730
5731
5732   return build_typename_type (context, name, fullname,  NULL_TREE);
5733 }
5734
5735 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5736    unless an error occurs, in which case error_mark_node is returned.
5737    If COMPLAIN zero, don't complain about any errors that occur.  */
5738
5739 tree
5740 make_unbound_class_template (context, name, complain)
5741      tree context, name;
5742      int complain;
5743 {
5744   tree t;
5745   tree d;
5746
5747   if (TYPE_P (name))
5748     name = TYPE_IDENTIFIER (name);
5749   else if (DECL_P (name))
5750     name = DECL_NAME (name);
5751   if (TREE_CODE (name) != IDENTIFIER_NODE)
5752     abort ();
5753
5754   if (!uses_template_parms (context)
5755       || currently_open_class (context))
5756     {
5757       tree tmpl = NULL_TREE;
5758
5759       if (IS_AGGR_TYPE (context))
5760         tmpl = lookup_field (context, name, 0, 0);
5761
5762       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5763         {
5764           if (complain)
5765             error ("no class template named `%#T' in `%#T'", name, context);
5766           return error_mark_node;
5767         }
5768
5769       if (!enforce_access (context, tmpl))
5770         return error_mark_node;
5771
5772       return tmpl;
5773     }
5774
5775   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5776   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5777   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5778   TREE_TYPE (t) = NULL_TREE;
5779
5780   /* Build the corresponding TEMPLATE_DECL.  */
5781   d = build_decl (TEMPLATE_DECL, name, t);
5782   TYPE_NAME (TREE_TYPE (d)) = d;
5783   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5784   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5785   DECL_ARTIFICIAL (d) = 1;
5786
5787   return t;
5788 }
5789
5790 /* Select the right _DECL from multiple choices. */
5791
5792 static tree
5793 select_decl (binding, flags)
5794      tree binding;
5795      int flags;
5796 {
5797   tree val;
5798   val = BINDING_VALUE (binding);
5799
5800   /* When we implicitly declare some builtin entity, we mark it
5801      DECL_ANTICIPATED, so that we know to ignore it until it is
5802      really declared.  */
5803   if (val && DECL_P (val)
5804       && DECL_LANG_SPECIFIC (val)
5805       && DECL_ANTICIPATED (val))
5806     return NULL_TREE;
5807
5808   if (LOOKUP_NAMESPACES_ONLY (flags))
5809     {
5810       /* We are not interested in types. */
5811       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5812         return val;
5813       return NULL_TREE;
5814     }
5815
5816   /* If we could have a type and
5817      we have nothing or we need a type and have none.  */
5818   if (BINDING_TYPE (binding)
5819       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5820                    && TREE_CODE (val) != TYPE_DECL)))
5821     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5822   /* Don't return non-types if we really prefer types. */
5823   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5824            && (TREE_CODE (val) != TEMPLATE_DECL
5825                || !DECL_CLASS_TEMPLATE_P (val)))
5826     val = NULL_TREE;
5827
5828   return val;
5829 }
5830
5831 /* Unscoped lookup of a global: iterate over current namespaces,
5832    considering using-directives.  If SPACESP is non-NULL, store a list
5833    of the namespaces we've considered in it.  */
5834
5835 tree
5836 unqualified_namespace_lookup (name, flags, spacesp)
5837      tree name;
5838      int flags;
5839      tree *spacesp;
5840 {
5841   tree b = make_node (CPLUS_BINDING);
5842   tree initial = current_decl_namespace ();
5843   tree scope = initial;
5844   tree siter;
5845   struct binding_level *level;
5846   tree val = NULL_TREE;
5847
5848   if (spacesp)
5849     *spacesp = NULL_TREE;
5850
5851   for (; !val; scope = CP_DECL_CONTEXT (scope))
5852     {
5853       if (spacesp)
5854         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5855       val = binding_for_name (name, scope);
5856
5857       /* Initialize binding for this context. */
5858       BINDING_VALUE (b) = BINDING_VALUE (val);
5859       BINDING_TYPE (b) = BINDING_TYPE (val);
5860
5861       /* Add all _DECLs seen through local using-directives. */
5862       for (level = current_binding_level;
5863            !level->namespace_p;
5864            level = level->level_chain)
5865         if (!lookup_using_namespace (name, b, level->using_directives,
5866                                      scope, flags, spacesp))
5867           /* Give up because of error. */
5868           return error_mark_node;
5869
5870       /* Add all _DECLs seen through global using-directives. */
5871       /* XXX local and global using lists should work equally. */
5872       siter = initial;
5873       while (1)
5874         {
5875           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5876                                        scope, flags, spacesp))
5877             /* Give up because of error. */
5878             return error_mark_node;
5879           if (siter == scope) break;
5880           siter = CP_DECL_CONTEXT (siter);
5881         }
5882
5883       val = select_decl (b, flags);
5884       if (scope == global_namespace)
5885         break;
5886     }
5887   return val;
5888 }
5889
5890 /* Combine prefer_type and namespaces_only into flags.  */
5891
5892 static int
5893 lookup_flags (prefer_type, namespaces_only)
5894   int prefer_type, namespaces_only;
5895 {
5896   if (namespaces_only)
5897     return LOOKUP_PREFER_NAMESPACES;
5898   if (prefer_type > 1)
5899     return LOOKUP_PREFER_TYPES;
5900   if (prefer_type > 0)
5901     return LOOKUP_PREFER_BOTH;
5902   return 0;
5903 }
5904
5905 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5906    ignore it or not.  Subroutine of lookup_name_real.  */
5907
5908 static tree
5909 qualify_lookup (val, flags)
5910      tree val;
5911      int flags;
5912 {
5913   if (val == NULL_TREE)
5914     return val;
5915   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5916     return val;
5917   if ((flags & LOOKUP_PREFER_TYPES)
5918       && (TREE_CODE (val) == TYPE_DECL
5919           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5920               && DECL_CLASS_TEMPLATE_P (val))))
5921     return val;
5922   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5923     return NULL_TREE;
5924   return val;
5925 }
5926
5927 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5928    that.  */
5929
5930 static void
5931 warn_about_implicit_typename_lookup (typename, binding)
5932      tree typename;
5933      tree binding;
5934 {
5935   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5936   tree name = DECL_NAME (typename);
5937
5938   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5939          && CLASSTYPE_TEMPLATE_INFO (subtype)
5940          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5941       && ! (TREE_CODE (binding) == TYPE_DECL
5942             && same_type_p (TREE_TYPE (binding), subtype)))
5943     {
5944       warning ("lookup of `%D' finds `%#D'",
5945                   name, binding);
5946       warning ("  instead of `%D' from dependent base class",
5947                   typename);
5948       warning ("  (use `typename %T::%D' if that's what you meant)",
5949                   constructor_name (current_class_type), name);
5950     }
5951 }
5952
5953 /* Look up NAME in the current binding level and its superiors in the
5954    namespace of variables, functions and typedefs.  Return a ..._DECL
5955    node of some kind representing its definition if there is only one
5956    such declaration, or return a TREE_LIST with all the overloaded
5957    definitions if there are many, or return 0 if it is undefined.
5958
5959    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5960    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5961    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5962    Otherwise we prefer non-TYPE_DECLs.
5963
5964    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5965    using IDENTIFIER_CLASS_VALUE.  */
5966
5967 static tree
5968 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5969      tree name;
5970      int prefer_type, nonclass, namespaces_only;
5971 {
5972   tree t;
5973   tree val = NULL_TREE;
5974   int yylex = 0;
5975   tree from_obj = NULL_TREE;
5976   int flags;
5977   int val_is_implicit_typename = 0;
5978
5979   /* Hack: copy flag set by parser, if set. */
5980   if (only_namespace_names)
5981     namespaces_only = 1;
5982
5983   if (prefer_type == -2)
5984     {
5985       extern int looking_for_typename;
5986       tree type = NULL_TREE;
5987
5988       yylex = 1;
5989       prefer_type = looking_for_typename;
5990
5991       flags = lookup_flags (prefer_type, namespaces_only);
5992       /* If the next thing is '<', class templates are types. */
5993       if (looking_for_template)
5994         flags |= LOOKUP_TEMPLATES_EXPECTED;
5995
5996       if (got_scope)
5997         type = got_scope;
5998       else if (got_object != error_mark_node)
5999         type = got_object;
6000
6001       if (type)
6002         {
6003           if (type == error_mark_node)
6004             return error_mark_node;
6005           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6006             type = TREE_TYPE (type);
6007
6008           if (TYPE_P (type))
6009             type = complete_type (type);
6010
6011           if (TREE_CODE (type) == VOID_TYPE)
6012             type = global_namespace;
6013           if (TREE_CODE (type) == NAMESPACE_DECL)
6014             {
6015               val = make_node (CPLUS_BINDING);
6016               flags |= LOOKUP_COMPLAIN;
6017               if (!qualified_lookup_using_namespace (name, type, val, flags))
6018                 return NULL_TREE;
6019               val = select_decl (val, flags);
6020             }
6021           else if (! IS_AGGR_TYPE (type)
6022                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6023                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6024                    || TREE_CODE (type) == TYPENAME_TYPE)
6025             /* Someone else will give an error about this if needed.  */
6026             val = NULL_TREE;
6027           else if (type == current_class_type)
6028             val = IDENTIFIER_CLASS_VALUE (name);
6029           else
6030             {
6031               val = lookup_member (type, name, 0, prefer_type);
6032               type_access_control (type, val);
6033
6034               /* Restore the containing TYPENAME_TYPE if we looked
6035                  through it before.  */
6036               if (got_scope && got_scope != type
6037                   && val && TREE_CODE (val) == TYPE_DECL
6038                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6039                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
6040             }
6041         }
6042       else
6043         val = NULL_TREE;
6044
6045       if (got_scope)
6046         goto done;
6047       else if (got_object && val)
6048         {
6049           from_obj = val;
6050           val = NULL_TREE;
6051         }
6052     }
6053   else
6054     {
6055       flags = lookup_flags (prefer_type, namespaces_only);
6056       /* If we're not parsing, we need to complain. */
6057       flags |= LOOKUP_COMPLAIN;
6058     }
6059
6060   /* First, look in non-namespace scopes.  */
6061
6062   if (current_class_type == NULL_TREE)
6063     nonclass = 1;
6064
6065   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6066     {
6067       tree binding;
6068
6069       if (!LOCAL_BINDING_P (t) && nonclass)
6070         /* We're not looking for class-scoped bindings, so keep going.  */
6071         continue;
6072
6073       /* If this is the kind of thing we're looking for, we're done.  */
6074       if (qualify_lookup (BINDING_VALUE (t), flags))
6075         binding = BINDING_VALUE (t);
6076       else if ((flags & LOOKUP_PREFER_TYPES)
6077                && qualify_lookup (BINDING_TYPE (t), flags))
6078         binding = BINDING_TYPE (t);
6079       else
6080         binding = NULL_TREE;
6081
6082       /* Handle access control on types from enclosing or base classes.  */
6083       if (binding && ! yylex
6084           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6085         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6086
6087       if (binding
6088           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6089         {
6090           if (val_is_implicit_typename && !yylex)
6091             warn_about_implicit_typename_lookup (val, binding);
6092           val = binding;
6093           val_is_implicit_typename
6094             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6095           if (!val_is_implicit_typename)
6096             break;
6097         }
6098     }
6099
6100   /* Now lookup in namespace scopes.  */
6101   if (!val || val_is_implicit_typename)
6102     {
6103       t = unqualified_namespace_lookup (name, flags, 0);
6104       if (t)
6105         {
6106           if (val_is_implicit_typename && !yylex)
6107             warn_about_implicit_typename_lookup (val, t);
6108           val = t;
6109         }
6110     }
6111
6112  done:
6113   if (val)
6114     {
6115       /* This should only warn about types used in qualified-ids.  */
6116       if (from_obj && from_obj != val)
6117         {
6118           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6119               && TREE_CODE (val) == TYPE_DECL
6120               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6121             pedwarn ("\
6122 lookup of `%D' in the scope of `%#T' (`%#D') \
6123 does not match lookup in the current scope (`%#D')",
6124                         name, got_object, from_obj, val);
6125
6126           /* We don't change val to from_obj if got_object depends on
6127              template parms because that breaks implicit typename for
6128              destructor calls.  */
6129           if (! uses_template_parms (got_object))
6130             val = from_obj;
6131         }
6132
6133       /* If we have a single function from a using decl, pull it out.  */
6134       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6135         val = OVL_FUNCTION (val);
6136     }
6137   else if (from_obj)
6138     val = from_obj;
6139
6140   return val;
6141 }
6142
6143 tree
6144 lookup_name_nonclass (name)
6145      tree name;
6146 {
6147   return lookup_name_real (name, 0, 1, 0);
6148 }
6149
6150 tree
6151 lookup_function_nonclass (name, args)
6152      tree name;
6153      tree args;
6154 {
6155   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6156 }
6157
6158 tree
6159 lookup_name_namespace_only (name)
6160      tree name;
6161 {
6162   /* type-or-namespace, nonclass, namespace_only */
6163   return lookup_name_real (name, 1, 1, 1);
6164 }
6165
6166 tree
6167 lookup_name (name, prefer_type)
6168      tree name;
6169      int prefer_type;
6170 {
6171   return lookup_name_real (name, prefer_type, 0, 0);
6172 }
6173
6174 /* Similar to `lookup_name' but look only in the innermost non-class
6175    binding level.  */
6176
6177 tree
6178 lookup_name_current_level (name)
6179      tree name;
6180 {
6181   struct binding_level *b;
6182   tree t = NULL_TREE;
6183
6184   b = current_binding_level;
6185   while (b->parm_flag == 2)
6186     b = b->level_chain;
6187
6188   if (b->namespace_p)
6189     {
6190       t = IDENTIFIER_NAMESPACE_VALUE (name);
6191
6192       /* extern "C" function() */
6193       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6194         t = TREE_VALUE (t);
6195     }
6196   else if (IDENTIFIER_BINDING (name)
6197            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6198     {
6199       while (1)
6200         {
6201           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6202             return IDENTIFIER_VALUE (name);
6203
6204           if (b->keep == 2)
6205             b = b->level_chain;
6206           else
6207             break;
6208         }
6209     }
6210
6211   return t;
6212 }
6213
6214 /* Like lookup_name_current_level, but for types.  */
6215
6216 tree
6217 lookup_type_current_level (name)
6218      tree name;
6219 {
6220   register tree t = NULL_TREE;
6221
6222   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6223
6224   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6225       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6226     {
6227       struct binding_level *b = current_binding_level;
6228       while (1)
6229         {
6230           if (purpose_member (name, b->type_shadowed))
6231             return REAL_IDENTIFIER_TYPE_VALUE (name);
6232           if (b->keep == 2)
6233             b = b->level_chain;
6234           else
6235             break;
6236         }
6237     }
6238
6239   return t;
6240 }
6241
6242 void
6243 begin_only_namespace_names ()
6244 {
6245   only_namespace_names = 1;
6246 }
6247
6248 void
6249 end_only_namespace_names ()
6250 {
6251   only_namespace_names = 0;
6252 }
6253 \f
6254 /* Push the declarations of builtin types into the namespace.
6255    RID_INDEX is the index of the builtin type
6256    in the array RID_POINTERS.  NAME is the name used when looking
6257    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6258
6259 void
6260 record_builtin_type (rid_index, name, type)
6261      enum rid rid_index;
6262      const char *name;
6263      tree type;
6264 {
6265   tree rname = NULL_TREE, tname = NULL_TREE;
6266   tree tdecl = NULL_TREE;
6267
6268   if ((int) rid_index < (int) RID_MAX)
6269     rname = ridpointers[(int) rid_index];
6270   if (name)
6271     tname = get_identifier (name);
6272
6273   TYPE_BUILT_IN (type) = 1;
6274
6275   if (tname)
6276     {
6277       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6278       set_identifier_type_value (tname, NULL_TREE);
6279       if ((int) rid_index < (int) RID_MAX)
6280         /* Built-in types live in the global namespace. */
6281         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6282     }
6283   if (rname != NULL_TREE)
6284     {
6285       if (tname != NULL_TREE)
6286         {
6287           set_identifier_type_value (rname, NULL_TREE);
6288           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6289         }
6290       else
6291         {
6292           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6293           set_identifier_type_value (rname, NULL_TREE);
6294         }
6295     }
6296 }
6297
6298 /* Record one of the standard Java types.
6299  * Declare it as having the given NAME.
6300  * If SIZE > 0, it is the size of one of the integral types;
6301  * otherwise it is the negative of the size of one of the other types.  */
6302
6303 static tree
6304 record_builtin_java_type (name, size)
6305      const char *name;
6306      int size;
6307 {
6308   tree type, decl;
6309   if (size > 0)
6310     type = make_signed_type (size);
6311   else if (size > -32)
6312     { /* "__java_char" or ""__java_boolean". */
6313       type = make_unsigned_type (-size);
6314       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6315     }
6316   else
6317     { /* "__java_float" or ""__java_double". */
6318       type = make_node (REAL_TYPE);
6319       TYPE_PRECISION (type) = - size;
6320       layout_type (type);
6321     }
6322   record_builtin_type (RID_MAX, name, type);
6323   decl = TYPE_NAME (type);
6324
6325   /* Suppress generate debug symbol entries for these types,
6326      since for normal C++ they are just clutter.
6327      However, push_lang_context undoes this if extern "Java" is seen. */
6328   DECL_IGNORED_P (decl) = 1;
6329
6330   TYPE_FOR_JAVA (type) = 1;
6331   return type;
6332 }
6333
6334 /* Push a type into the namespace so that the back-ends ignore it. */
6335
6336 static void
6337 record_unknown_type (type, name)
6338      tree type;
6339      const char *name;
6340 {
6341   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6342   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6343   DECL_IGNORED_P (decl) = 1;
6344   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6345   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6346   TYPE_ALIGN (type) = 1;
6347   TYPE_USER_ALIGN (type) = 0;
6348   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6349 }
6350
6351 /* An string for which we should create an IDENTIFIER_NODE at
6352    startup.  */
6353
6354 typedef struct predefined_identifier
6355 {
6356   /* The name of the identifier.  */
6357   const char *const name;
6358   /* The place where the IDENTIFIER_NODE should be stored.  */
6359   tree *const node;
6360   /* Non-zero if this is the name of a constructor or destructor.  */
6361   const int ctor_or_dtor_p;
6362 } predefined_identifier;
6363
6364 /* Create all the predefined identifiers.  */
6365
6366 static void
6367 initialize_predefined_identifiers ()
6368 {
6369   const predefined_identifier *pid;
6370
6371   /* A table of identifiers to create at startup.  */
6372   static const predefined_identifier predefined_identifiers[] = {
6373     { "C++", &lang_name_cplusplus, 0 },
6374     { "C", &lang_name_c, 0 },
6375     { "Java", &lang_name_java, 0 },
6376     { CTOR_NAME, &ctor_identifier, 1 },
6377     { "__base_ctor", &base_ctor_identifier, 1 },
6378     { "__comp_ctor", &complete_ctor_identifier, 1 },
6379     { DTOR_NAME, &dtor_identifier, 1 },
6380     { "__comp_dtor", &complete_dtor_identifier, 1 },
6381     { "__base_dtor", &base_dtor_identifier, 1 },
6382     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6383     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6384     { "nelts", &nelts_identifier, 0 },
6385     { THIS_NAME, &this_identifier, 0 },
6386     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6387     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6388     { "_vptr", &vptr_identifier, 0 },
6389     { "__vtt_parm", &vtt_parm_identifier, 0 },
6390     { "std", &std_identifier, 0 },
6391     { NULL, NULL, 0 }
6392   };
6393
6394   for (pid = predefined_identifiers; pid->name; ++pid)
6395     {
6396       *pid->node = get_identifier (pid->name);
6397       if (pid->ctor_or_dtor_p)
6398         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6399     }
6400 }
6401
6402 /* Create the predefined scalar types of C,
6403    and some nodes representing standard constants (0, 1, (void *)0).
6404    Initialize the global binding level.
6405    Make definitions for built-in primitive functions.  */
6406
6407 void
6408 cxx_init_decl_processing ()
6409 {
6410   tree void_ftype;
6411   tree void_ftype_ptr;
6412
6413   /* Create all the identifiers we need.  */
6414   initialize_predefined_identifiers ();
6415
6416   /* Fill in back-end hooks.  */
6417   init_lang_status = &push_cp_function_context;
6418   free_lang_status = &pop_cp_function_context;
6419   mark_lang_status = &mark_cp_function_context;
6420   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6421
6422   cp_parse_init ();
6423   init_decl2 ();
6424   init_pt ();
6425
6426   /* Create the global variables.  */
6427   push_to_top_level ();
6428
6429   /* Enter the global namespace. */
6430   my_friendly_assert (global_namespace == NULL_TREE, 375);
6431   push_namespace (get_identifier ("::"));
6432   global_namespace = current_namespace;
6433   current_lang_name = NULL_TREE;
6434
6435   /* Adjust various flags based on command-line settings.  */
6436   if (! flag_permissive && ! pedantic)
6437     flag_pedantic_errors = 1;
6438   if (!flag_no_inline)
6439     {
6440       flag_inline_trees = 1;
6441       flag_no_inline = 1;
6442     }
6443   if (flag_inline_functions)
6444     {
6445       flag_inline_trees = 2;
6446       flag_inline_functions = 0;
6447     }
6448
6449   /* In C++, we never create builtin functions whose name does not
6450      begin with `__'.  Users should be using headers to get prototypes
6451      in C++.  It would be nice if we could warn when `-fbuiltin' is
6452      used explicitly, but we do not have that information.  */
6453   flag_no_builtin = 1;
6454
6455   /* Initially, C.  */
6456   current_lang_name = lang_name_c;
6457
6458   current_function_decl = NULL_TREE;
6459   current_binding_level = NULL_BINDING_LEVEL;
6460   free_binding_level = NULL_BINDING_LEVEL;
6461
6462   build_common_tree_nodes (flag_signed_char);
6463
6464   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6465   TREE_TYPE (error_mark_list) = error_mark_node;
6466
6467   /* Make the binding_level structure for global names.  */
6468   pushlevel (0);
6469   global_binding_level = current_binding_level;
6470   /* The global level is the namespace level of ::.  */
6471   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6472   declare_namespace_level ();
6473
6474   /* Create the `std' namespace.  */
6475   push_namespace (std_identifier);
6476   std_node = current_namespace;
6477   pop_namespace ();
6478
6479   lang_attribute_table = cp_attribute_table;
6480
6481   c_common_nodes_and_builtins ();
6482
6483   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6484   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6485   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6486   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6487   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6488   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6489   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6490   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6491
6492   integer_two_node = build_int_2 (2, 0);
6493   TREE_TYPE (integer_two_node) = integer_type_node;
6494   integer_three_node = build_int_2 (3, 0);
6495   TREE_TYPE (integer_three_node) = integer_type_node;
6496
6497   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6498   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6499   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6500   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6501   TYPE_PRECISION (boolean_type_node) = 1;
6502   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6503   boolean_false_node = build_int_2 (0, 0);
6504   TREE_TYPE (boolean_false_node) = boolean_type_node;
6505   boolean_true_node = build_int_2 (1, 0);
6506   TREE_TYPE (boolean_true_node) = boolean_type_node;
6507
6508   signed_size_zero_node = build_int_2 (0, 0);
6509   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6510
6511   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6512
6513 #if 0
6514   record_builtin_type (RID_MAX, NULL, string_type_node);
6515 #endif
6516
6517   delta_type_node = ptrdiff_type_node;
6518   vtable_index_type = ptrdiff_type_node;
6519
6520   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6521   lang_type_promotes_to = convert_type_from_ellipsis;
6522
6523   void_ftype = build_function_type (void_type_node, void_list_node);
6524   void_ftype_ptr = build_function_type (void_type_node,
6525                                         tree_cons (NULL_TREE,
6526                                                    ptr_type_node,
6527                                                    void_list_node));
6528   void_ftype_ptr
6529     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6530
6531   /* C++ extensions */
6532
6533   unknown_type_node = make_node (UNKNOWN_TYPE);
6534   record_unknown_type (unknown_type_node, "unknown type");
6535
6536   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6537   TREE_TYPE (unknown_type_node) = unknown_type_node;
6538
6539   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6540      result.  */
6541   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6542   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6543
6544   {
6545     /* Make sure we get a unique function type, so we can give
6546        its pointer type a name.  (This wins for gdb.) */
6547     tree vfunc_type = make_node (FUNCTION_TYPE);
6548     TREE_TYPE (vfunc_type) = integer_type_node;
6549     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6550     layout_type (vfunc_type);
6551
6552     vtable_entry_type = build_pointer_type (vfunc_type);
6553   }
6554   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6555
6556   vtbl_type_node
6557     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6558   layout_type (vtbl_type_node);
6559   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6560   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6561   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6562   layout_type (vtbl_ptr_type_node);
6563   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6564
6565   push_namespace (get_identifier ("__cxxabiv1"));
6566   abi_node = current_namespace;
6567   pop_namespace ();
6568
6569   global_type_node = make_node (LANG_TYPE);
6570   record_unknown_type (global_type_node, "global type");
6571
6572   /* Now, C++.  */
6573   current_lang_name = lang_name_cplusplus;
6574
6575   {
6576     tree bad_alloc_type_node, newtype, deltype;
6577     tree ptr_ftype_sizetype;
6578
6579     push_namespace (std_identifier);
6580     bad_alloc_type_node = xref_tag
6581       (class_type_node, get_identifier ("bad_alloc"), 1);
6582     pop_namespace ();
6583     ptr_ftype_sizetype
6584       = build_function_type (ptr_type_node,
6585                              tree_cons (NULL_TREE,
6586                                         c_size_type_node,
6587                                         void_list_node));
6588     newtype = build_exception_variant
6589       (ptr_ftype_sizetype, add_exception_specifier
6590        (NULL_TREE, bad_alloc_type_node, -1));
6591     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6592     push_cp_library_fn (NEW_EXPR, newtype);
6593     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6594     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6595     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6596   }
6597
6598   abort_fndecl
6599     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6600
6601   /* Perform other language dependent initializations.  */
6602   init_class_processing ();
6603   init_init_processing ();
6604   init_search_processing ();
6605   init_rtti_processing ();
6606
6607   if (flag_exceptions)
6608     init_exception_processing ();
6609
6610   if (! supports_one_only ())
6611     flag_weak = 0;
6612
6613   make_fname_decl = cp_make_fname_decl;
6614   start_fname_decls ();
6615
6616   /* Show we use EH for cleanups.  */
6617   using_eh_for_cleanups ();
6618
6619   /* Maintain consistency.  Perhaps we should just complain if they
6620      say -fwritable-strings?  */
6621   if (flag_writable_strings)
6622     flag_const_strings = 0;
6623
6624   /* Add GC roots for all of our global variables.  */
6625   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6626   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6627   ggc_add_tree_root (&integer_three_node, 1);
6628   ggc_add_tree_root (&integer_two_node, 1);
6629   ggc_add_tree_root (&signed_size_zero_node, 1);
6630   ggc_add_tree_root (&size_one_node, 1);
6631   ggc_add_tree_root (&size_zero_node, 1);
6632   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6633                 mark_binding_level);
6634   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6635   ggc_add_tree_root (&static_ctors, 1);
6636   ggc_add_tree_root (&static_dtors, 1);
6637   ggc_add_tree_root (&lastiddecl, 1);
6638
6639   ggc_add_tree_root (&last_function_parms, 1);
6640   ggc_add_tree_root (&error_mark_list, 1);
6641
6642   ggc_add_tree_root (&global_namespace, 1);
6643   ggc_add_tree_root (&global_type_node, 1);
6644   ggc_add_tree_root (&anonymous_namespace_name, 1);
6645
6646   ggc_add_tree_root (&got_object, 1);
6647   ggc_add_tree_root (&got_scope, 1);
6648
6649   ggc_add_tree_root (&current_lang_name, 1);
6650   ggc_add_tree_root (&static_aggregates, 1);
6651   ggc_add_tree_root (&free_bindings, 1);
6652 }
6653
6654 /* Generate an initializer for a function naming variable from
6655    NAME. NAME may be NULL, in which case we generate a special
6656    ERROR_MARK node which should be replaced later. */
6657
6658 tree
6659 cp_fname_init (name)
6660      const char *name;
6661 {
6662   tree domain = NULL_TREE;
6663   tree type;
6664   tree init = NULL_TREE;
6665   size_t length = 0;
6666
6667   if (name)
6668     {
6669       length = strlen (name);
6670       domain = build_index_type (size_int (length));
6671       init = build_string (length + 1, name);
6672     }
6673
6674   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6675   type = build_cplus_array_type (type, domain);
6676
6677   if (init)
6678     TREE_TYPE (init) = type;
6679   else
6680     /* We don't know the value until instantiation time. Make
6681        something which will be digested now, but replaced later. */
6682     init = build (ERROR_MARK, type);
6683
6684   return init;
6685 }
6686
6687 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6688    decl, NAME is the initialization string and TYPE_DEP indicates whether
6689    NAME depended on the type of the function. We make use of that to detect
6690    __PRETTY_FUNCTION__ inside a template fn. This is being done
6691    lazily at the point of first use, so we musn't push the decl now.  */
6692
6693 static tree
6694 cp_make_fname_decl (id, type_dep)
6695      tree id;
6696      int type_dep;
6697 {
6698   const char *const name = (type_dep && processing_template_decl
6699                       ? NULL : fname_as_string (type_dep));
6700   tree init = cp_fname_init (name);
6701   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6702
6703   /* As we don't push the decl here, we must set the context. */
6704   DECL_CONTEXT (decl) = current_function_decl;
6705   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6706
6707   TREE_STATIC (decl) = 1;
6708   TREE_READONLY (decl) = 1;
6709   DECL_ARTIFICIAL (decl) = 1;
6710   DECL_INITIAL (decl) = init;
6711
6712   TREE_USED (decl) = 1;
6713
6714   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6715
6716   return decl;
6717 }
6718
6719 /* Entry point for the benefit of c_common_nodes_and_builtins.
6720
6721    Make a definition for a builtin function named NAME and whose data type
6722    is TYPE.  TYPE should be a function type with argument types.
6723
6724    CLASS and CODE tell later passes how to compile calls to this function.
6725    See tree.h for possible values.
6726
6727    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6728    the name to be called if we can't opencode the function.  */
6729
6730 tree
6731 builtin_function (name, type, code, class, libname)
6732      const char *name;
6733      tree type;
6734      int code;
6735      enum built_in_class class;
6736      const char *libname;
6737 {
6738   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6739   DECL_BUILT_IN_CLASS (decl) = class;
6740   DECL_FUNCTION_CODE (decl) = code;
6741
6742   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6743
6744   /* All builtins that don't begin with an `_' should go in the `std'
6745      namespace.  */
6746   if (name[0] != '_')
6747     {
6748       push_namespace (std_identifier);
6749       DECL_CONTEXT (decl) = std_node;
6750     }
6751   pushdecl (decl);
6752   if (name[0] != '_')
6753     pop_namespace ();
6754
6755   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6756      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6757      function in the namespace.  */
6758   if (libname)
6759     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6760   make_decl_rtl (decl, NULL);
6761
6762   /* Warn if a function in the namespace for users
6763      is used without an occasion to consider it declared.  */
6764   if (name[0] != '_' || name[1] != '_')
6765     DECL_ANTICIPATED (decl) = 1;
6766
6767   /* Possibly apply some default attributes to this built-in function.  */
6768   decl_attributes (&decl, NULL_TREE, 0);
6769
6770   return decl;
6771 }
6772
6773 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6774    function.  Not called directly.  */
6775
6776 static tree
6777 build_library_fn_1 (name, operator_code, type)
6778      tree name;
6779      enum tree_code operator_code;
6780      tree type;
6781 {
6782   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6783   DECL_EXTERNAL (fn) = 1;
6784   TREE_PUBLIC (fn) = 1;
6785   DECL_ARTIFICIAL (fn) = 1;
6786   TREE_NOTHROW (fn) = 1;
6787   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6788   SET_DECL_LANGUAGE (fn, lang_c);
6789   return fn;
6790 }
6791
6792 /* Returns the _DECL for a library function with C linkage.
6793    We assume that such functions never throw; if this is incorrect,
6794    callers should unset TREE_NOTHROW.  */
6795
6796 tree
6797 build_library_fn (name, type)
6798      tree name;
6799      tree type;
6800 {
6801   return build_library_fn_1 (name, ERROR_MARK, type);
6802 }
6803
6804 /* Returns the _DECL for a library function with C++ linkage.  */
6805
6806 static tree
6807 build_cp_library_fn (name, operator_code, type)
6808      tree name;
6809      enum tree_code operator_code;
6810      tree type;
6811 {
6812   tree fn = build_library_fn_1 (name, operator_code, type);
6813   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6814   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6815   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6816   set_mangled_name_for_decl (fn);
6817   return fn;
6818 }
6819
6820 /* Like build_library_fn, but takes a C string instead of an
6821    IDENTIFIER_NODE.  */
6822
6823 tree
6824 build_library_fn_ptr (name, type)
6825      const char *name;
6826      tree type;
6827 {
6828   return build_library_fn (get_identifier (name), type);
6829 }
6830
6831 /* Like build_cp_library_fn, but takes a C string instead of an
6832    IDENTIFIER_NODE.  */
6833
6834 tree
6835 build_cp_library_fn_ptr (name, type)
6836      const char *name;
6837      tree type;
6838 {
6839   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6840 }
6841
6842 /* Like build_library_fn, but also pushes the function so that we will
6843    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6844
6845 tree
6846 push_library_fn (name, type)
6847      tree name, type;
6848 {
6849   tree fn = build_library_fn (name, type);
6850   pushdecl_top_level (fn);
6851   return fn;
6852 }
6853
6854 /* Like build_cp_library_fn, but also pushes the function so that it
6855    will be found by normal lookup.  */
6856
6857 static tree
6858 push_cp_library_fn (operator_code, type)
6859      enum tree_code operator_code;
6860      tree type;
6861 {
6862   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6863                                  operator_code,
6864                                  type);
6865   pushdecl (fn);
6866   return fn;
6867 }
6868
6869 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6870    a FUNCTION_TYPE.  */
6871
6872 tree
6873 push_void_library_fn (name, parmtypes)
6874      tree name, parmtypes;
6875 {
6876   tree type = build_function_type (void_type_node, parmtypes);
6877   return push_library_fn (name, type);
6878 }
6879
6880 /* Like push_library_fn, but also note that this function throws
6881    and does not return.  Used for __throw_foo and the like.  */
6882
6883 tree
6884 push_throw_library_fn (name, type)
6885      tree name, type;
6886 {
6887   tree fn = push_library_fn (name, type);
6888   TREE_THIS_VOLATILE (fn) = 1;
6889   TREE_NOTHROW (fn) = 0;
6890   return fn;
6891 }
6892
6893 /* Apply default attributes to a function, if a system function with default
6894    attributes.  */
6895
6896 void
6897 insert_default_attributes (decl)
6898      tree decl;
6899 {
6900   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6901     return;
6902   if (!TREE_PUBLIC (decl))
6903     return;
6904   c_common_insert_default_attributes (decl);
6905 }
6906 \f
6907 /* When we call finish_struct for an anonymous union, we create
6908    default copy constructors and such.  But, an anonymous union
6909    shouldn't have such things; this function undoes the damage to the
6910    anonymous union type T.
6911
6912    (The reason that we create the synthesized methods is that we don't
6913    distinguish `union { int i; }' from `typedef union { int i; } U'.
6914    The first is an anonymous union; the second is just an ordinary
6915    union type.)  */
6916
6917 void
6918 fixup_anonymous_aggr (t)
6919      tree t;
6920 {
6921   tree *q;
6922
6923   /* Wipe out memory of synthesized methods */
6924   TYPE_HAS_CONSTRUCTOR (t) = 0;
6925   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6926   TYPE_HAS_INIT_REF (t) = 0;
6927   TYPE_HAS_CONST_INIT_REF (t) = 0;
6928   TYPE_HAS_ASSIGN_REF (t) = 0;
6929   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6930
6931   /* Splice the implicitly generated functions out of the TYPE_METHODS
6932      list.  */
6933   q = &TYPE_METHODS (t);
6934   while (*q)
6935     {
6936       if (DECL_ARTIFICIAL (*q))
6937         *q = TREE_CHAIN (*q);
6938       else
6939         q = &TREE_CHAIN (*q);
6940     }
6941
6942   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6943   if (TYPE_METHODS (t))
6944     cp_error_at ("an anonymous union cannot have function members", t);
6945
6946   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6947      assignment operators (because they cannot have these methods themselves).
6948      For anonymous unions this is already checked because they are not allowed
6949      in any union, otherwise we have to check it.  */
6950   if (TREE_CODE (t) != UNION_TYPE)
6951     {
6952       tree field, type;
6953
6954       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6955         if (TREE_CODE (field) == FIELD_DECL)
6956           {
6957             type = TREE_TYPE (field);
6958             if (CLASS_TYPE_P (type))
6959               {
6960                 if (TYPE_NEEDS_CONSTRUCTING (type))
6961                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6962                                field);
6963                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6964                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6965                                field);
6966                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6967                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6968                                field);
6969               }
6970           }
6971     }
6972 }
6973
6974 /* Make sure that a declaration with no declarator is well-formed, i.e.
6975    just defines a tagged type or anonymous union.
6976
6977    Returns the type defined, if any.  */
6978
6979 tree
6980 check_tag_decl (declspecs)
6981      tree declspecs;
6982 {
6983   int found_type = 0;
6984   int saw_friend = 0;
6985   int saw_typedef = 0;
6986   tree ob_modifier = NULL_TREE;
6987   register tree link;
6988   register tree t = NULL_TREE;
6989
6990   for (link = declspecs; link; link = TREE_CHAIN (link))
6991     {
6992       register tree value = TREE_VALUE (link);
6993
6994       if (TYPE_P (value)
6995           || TREE_CODE (value) == TYPE_DECL
6996           || (TREE_CODE (value) == IDENTIFIER_NODE
6997               && IDENTIFIER_GLOBAL_VALUE (value)
6998               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6999         {
7000           ++found_type;
7001
7002           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7003             {
7004               if (! in_system_header)
7005                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7006               return NULL_TREE;
7007             }
7008
7009           if (TYPE_P (value)
7010               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7011                   || TREE_CODE (value) == ENUMERAL_TYPE))
7012             {
7013               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7014               t = value;
7015             }
7016         }
7017       else if (value == ridpointers[(int) RID_TYPEDEF])
7018         saw_typedef = 1;
7019       else if (value == ridpointers[(int) RID_FRIEND])
7020         {
7021           if (current_class_type == NULL_TREE
7022               || current_scope () != current_class_type)
7023             ob_modifier = value;
7024           else
7025             saw_friend = 1;
7026         }
7027       else if (value == ridpointers[(int) RID_STATIC]
7028                || value == ridpointers[(int) RID_EXTERN]
7029                || value == ridpointers[(int) RID_AUTO]
7030                || value == ridpointers[(int) RID_REGISTER]
7031                || value == ridpointers[(int) RID_INLINE]
7032                || value == ridpointers[(int) RID_VIRTUAL]
7033                || value == ridpointers[(int) RID_CONST]
7034                || value == ridpointers[(int) RID_VOLATILE]
7035                || value == ridpointers[(int) RID_EXPLICIT])
7036         ob_modifier = value;
7037     }
7038
7039   if (found_type > 1)
7040     error ("multiple types in one declaration");
7041
7042   if (t == NULL_TREE && ! saw_friend)
7043     pedwarn ("declaration does not declare anything");
7044
7045   /* Check for an anonymous union.  */
7046   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7047            && TYPE_ANONYMOUS_P (t))
7048     {
7049       /* 7/3 In a simple-declaration, the optional init-declarator-list
7050          can be omitted only when declaring a class (clause 9) or
7051          enumeration (7.2), that is, when the decl-specifier-seq contains
7052          either a class-specifier, an elaborated-type-specifier with
7053          a class-key (9.1), or an enum-specifier.  In these cases and
7054          whenever a class-specifier or enum-specifier is present in the
7055          decl-specifier-seq, the identifiers in these specifiers are among
7056          the names being declared by the declaration (as class-name,
7057          enum-names, or enumerators, depending on the syntax).  In such
7058          cases, and except for the declaration of an unnamed bit-field (9.6),
7059          the decl-specifier-seq shall introduce one or more names into the
7060          program, or shall redeclare a name introduced by a previous
7061          declaration.  [Example:
7062              enum { };            // ill-formed
7063              typedef class { };   // ill-formed
7064          --end example]  */
7065       if (saw_typedef)
7066         {
7067           error ("missing type-name in typedef-declaration");
7068           return NULL_TREE;
7069         }
7070       /* Anonymous unions are objects, so they can have specifiers.  */;
7071       SET_ANON_AGGR_TYPE_P (t);
7072
7073       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7074         pedwarn ("ISO C++ prohibits anonymous structs");
7075     }
7076
7077   else if (ob_modifier)
7078     {
7079       if (ob_modifier == ridpointers[(int) RID_INLINE]
7080           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7081         error ("`%D' can only be specified for functions", ob_modifier);
7082       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7083         error ("`%D' can only be specified inside a class", ob_modifier);
7084       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7085         error ("`%D' can only be specified for constructors",
7086                   ob_modifier);
7087       else
7088         error ("`%D' can only be specified for objects and functions",
7089                   ob_modifier);
7090     }
7091
7092   return t;
7093 }
7094
7095 /* Called when a declaration is seen that contains no names to declare.
7096    If its type is a reference to a structure, union or enum inherited
7097    from a containing scope, shadow that tag name for the current scope
7098    with a forward reference.
7099    If its type defines a new named structure or union
7100    or defines an enum, it is valid but we need not do anything here.
7101    Otherwise, it is an error.
7102
7103    C++: may have to grok the declspecs to learn about static,
7104    complain for anonymous unions.  */
7105
7106 void
7107 shadow_tag (declspecs)
7108      tree declspecs;
7109 {
7110   tree t = check_tag_decl (declspecs);
7111
7112   if (t)
7113     maybe_process_partial_specialization (t);
7114
7115   /* This is where the variables in an anonymous union are
7116      declared.  An anonymous union declaration looks like:
7117      union { ... } ;
7118      because there is no declarator after the union, the parser
7119      sends that declaration here.  */
7120   if (t && ANON_AGGR_TYPE_P (t))
7121     {
7122       fixup_anonymous_aggr (t);
7123
7124       if (TYPE_FIELDS (t))
7125         {
7126           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7127                                       NULL);
7128           finish_anon_union (decl);
7129         }
7130     }
7131 }
7132 \f
7133 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7134
7135 tree
7136 groktypename (typename)
7137      tree typename;
7138 {
7139   tree specs, attrs;
7140   tree type;
7141   if (TREE_CODE (typename) != TREE_LIST)
7142     return typename;
7143   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7144   type = grokdeclarator (TREE_VALUE (typename), specs,
7145                          TYPENAME, 0, &attrs);
7146   if (attrs)
7147     cplus_decl_attributes (&type, attrs, 0);
7148   return type;
7149 }
7150
7151 /* Decode a declarator in an ordinary declaration or data definition.
7152    This is called as soon as the type information and variable name
7153    have been parsed, before parsing the initializer if any.
7154    Here we create the ..._DECL node, fill in its type,
7155    and put it on the list of decls for the current context.
7156    The ..._DECL node is returned as the value.
7157
7158    Exception: for arrays where the length is not specified,
7159    the type is left null, to be filled in by `cp_finish_decl'.
7160
7161    Function definitions do not come here; they go to start_function
7162    instead.  However, external and forward declarations of functions
7163    do go through here.  Structure field declarations are done by
7164    grokfield and not through here.  */
7165
7166 tree
7167 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7168      tree declarator, declspecs;
7169      int initialized;
7170      tree attributes, prefix_attributes;
7171 {
7172   tree decl;
7173   register tree type, tem;
7174   tree context;
7175   extern int have_extern_spec;
7176   extern int used_extern_spec;
7177
7178 #if 0
7179   /* See code below that used this.  */
7180   int init_written = initialized;
7181 #endif
7182
7183   /* This should only be done once on the top most decl.  */
7184   if (have_extern_spec && !used_extern_spec)
7185     {
7186       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7187                              declspecs);
7188       used_extern_spec = 1;
7189     }
7190
7191   /* An object declared as __attribute__((deprecated)) suppresses
7192      warnings of uses of other deprecated items.  */
7193   if (lookup_attribute ("deprecated", attributes))
7194     deprecated_state = DEPRECATED_SUPPRESS;
7195
7196   attributes = chainon (attributes, prefix_attributes);
7197
7198   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7199                          &attributes);
7200
7201   deprecated_state = DEPRECATED_NORMAL;
7202
7203   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7204     return NULL_TREE;
7205
7206   type = TREE_TYPE (decl);
7207
7208   if (type == error_mark_node)
7209     return NULL_TREE;
7210
7211   context = DECL_CONTEXT (decl);
7212
7213   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7214       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7215     {
7216       /* When parsing the initializer, lookup should use the object's
7217          namespace. */
7218       push_decl_namespace (context);
7219     }
7220
7221   /* We are only interested in class contexts, later. */
7222   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7223     context = NULL_TREE;
7224
7225   if (initialized)
7226     /* Is it valid for this decl to have an initializer at all?
7227        If not, set INITIALIZED to zero, which will indirectly
7228        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7229     switch (TREE_CODE (decl))
7230       {
7231       case TYPE_DECL:
7232         /* typedef foo = bar  means give foo the same type as bar.
7233            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7234            Any other case of an initialization in a TYPE_DECL is an error.  */
7235         if (pedantic || list_length (declspecs) > 1)
7236           {
7237             error ("typedef `%D' is initialized", decl);
7238             initialized = 0;
7239           }
7240         break;
7241
7242       case FUNCTION_DECL:
7243         error ("function `%#D' is initialized like a variable", decl);
7244         initialized = 0;
7245         break;
7246
7247       default:
7248         break;
7249       }
7250
7251   if (initialized)
7252     {
7253       if (! toplevel_bindings_p ()
7254           && DECL_EXTERNAL (decl))
7255         warning ("declaration of `%#D' has `extern' and is initialized",
7256                     decl);
7257       DECL_EXTERNAL (decl) = 0;
7258       if (toplevel_bindings_p ())
7259         TREE_STATIC (decl) = 1;
7260
7261       /* Tell `pushdecl' this is an initialized decl
7262          even though we don't yet have the initializer expression.
7263          Also tell `cp_finish_decl' it may store the real initializer.  */
7264       DECL_INITIAL (decl) = error_mark_node;
7265     }
7266
7267   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7268   cplus_decl_attributes (&decl, attributes, 0);
7269
7270   if (TREE_CODE (decl) == FUNCTION_DECL
7271       && DECL_DECLARED_INLINE_P (decl)
7272       && DECL_UNINLINABLE (decl)
7273       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7274     warning_with_decl (decl,
7275                        "inline function `%s' given attribute noinline");
7276
7277   if (context && COMPLETE_TYPE_P (complete_type (context)))
7278     {
7279       push_nested_class (context, 2);
7280
7281       if (TREE_CODE (decl) == VAR_DECL)
7282         {
7283           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7284           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7285             error ("`%#D' is not a static member of `%#T'", decl, context);
7286           else
7287             {
7288               if (DECL_CONTEXT (field) != context)
7289                 {
7290                   pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7291                               DECL_CONTEXT (field), DECL_NAME (decl),
7292                               context, DECL_NAME (decl));
7293                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7294                 }
7295               /* Static data member are tricky; an in-class initialization
7296                  still doesn't provide a definition, so the in-class
7297                  declaration will have DECL_EXTERNAL set, but will have an
7298                  initialization.  Thus, duplicate_decls won't warn
7299                  about this situation, and so we check here.  */
7300               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7301                 error ("duplicate initialization of %D", decl);
7302               if (duplicate_decls (decl, field))
7303                 decl = field;
7304             }
7305         }
7306       else
7307         {
7308           tree field = check_classfn (context, decl);
7309           if (field && duplicate_decls (decl, field))
7310             decl = field;
7311         }
7312
7313       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7314       DECL_IN_AGGR_P (decl) = 0;
7315       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7316           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7317         {
7318           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7319           /* [temp.expl.spec] An explicit specialization of a static data
7320              member of a template is a definition if the declaration
7321              includes an initializer; otherwise, it is a declaration.
7322
7323              We check for processing_specialization so this only applies
7324              to the new specialization syntax.  */
7325           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7326             DECL_EXTERNAL (decl) = 1;
7327         }
7328
7329       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7330         pedwarn ("declaration of `%#D' outside of class is not definition",
7331                     decl);
7332     }
7333
7334   /* Enter this declaration into the symbol table.  */
7335   tem = maybe_push_decl (decl);
7336
7337   if (processing_template_decl)
7338     tem = push_template_decl (tem);
7339
7340 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7341   /* Tell the back-end to use or not use .common as appropriate.  If we say
7342      -fconserve-space, we want this to save .data space, at the expense of
7343      wrong semantics.  If we say -fno-conserve-space, we want this to
7344      produce errors about redefs; to do this we force variables into the
7345      data segment.  */
7346   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7347 #endif
7348
7349   if (! processing_template_decl)
7350     start_decl_1 (tem);
7351
7352   return tem;
7353 }
7354
7355 void
7356 start_decl_1 (decl)
7357      tree decl;
7358 {
7359   tree type = TREE_TYPE (decl);
7360   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7361
7362   if (type == error_mark_node)
7363     return;
7364
7365   maybe_push_cleanup_level (type);
7366
7367   if (initialized)
7368     /* Is it valid for this decl to have an initializer at all?
7369        If not, set INITIALIZED to zero, which will indirectly
7370        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7371     {
7372       /* Don't allow initializations for incomplete types except for
7373          arrays which might be completed by the initialization.  */
7374       if (COMPLETE_TYPE_P (complete_type (type)))
7375         ;                       /* A complete type is ok.  */
7376       else if (TREE_CODE (type) != ARRAY_TYPE)
7377         {
7378           error ("variable `%#D' has initializer but incomplete type",
7379                     decl);
7380           initialized = 0;
7381           type = TREE_TYPE (decl) = error_mark_node;
7382         }
7383       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7384         {
7385           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7386             error ("elements of array `%#D' have incomplete type", decl);
7387           /* else we already gave an error in start_decl.  */
7388           initialized = 0;
7389         }
7390     }
7391
7392   if (!initialized
7393       && TREE_CODE (decl) != TYPE_DECL
7394       && TREE_CODE (decl) != TEMPLATE_DECL
7395       && type != error_mark_node
7396       && IS_AGGR_TYPE (type)
7397       && ! DECL_EXTERNAL (decl))
7398     {
7399       if ((! processing_template_decl || ! uses_template_parms (type))
7400           && !COMPLETE_TYPE_P (complete_type (type)))
7401         {
7402           error ("aggregate `%#D' has incomplete type and cannot be initialized",
7403                  decl);
7404           /* Change the type so that assemble_variable will give
7405              DECL an rtl we can live with: (mem (const_int 0)).  */
7406           type = TREE_TYPE (decl) = error_mark_node;
7407         }
7408       else
7409         {
7410           /* If any base type in the hierarchy of TYPE needs a constructor,
7411              then we set initialized to 1.  This way any nodes which are
7412              created for the purposes of initializing this aggregate
7413              will live as long as it does.  This is necessary for global
7414              aggregates which do not have their initializers processed until
7415              the end of the file.  */
7416           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7417         }
7418     }
7419
7420   if (! initialized)
7421     DECL_INITIAL (decl) = NULL_TREE;
7422 }
7423
7424 /* Handle initialization of references.
7425    These three arguments are from `cp_finish_decl', and have the
7426    same meaning here that they do there.
7427
7428    Quotes on semantics can be found in ARM 8.4.3.  */
7429
7430 static tree
7431 grok_reference_init (decl, type, init)
7432      tree decl, type, init;
7433 {
7434   tree tmp;
7435
7436   if (init == NULL_TREE)
7437     {
7438       if ((DECL_LANG_SPECIFIC (decl) == 0
7439            || DECL_IN_AGGR_P (decl) == 0)
7440           && ! DECL_THIS_EXTERN (decl))
7441         error ("`%D' declared as reference but not initialized", decl);
7442       return NULL_TREE;
7443     }
7444
7445   if (init == error_mark_node)
7446     return NULL_TREE;
7447
7448   if (TREE_CODE (init) == CONSTRUCTOR)
7449     {
7450       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7451       return NULL_TREE;
7452     }
7453
7454   if (TREE_CODE (init) == TREE_LIST)
7455     init = build_compound_expr (init);
7456
7457   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7458     init = convert_from_reference (init);
7459
7460   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7461       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7462     {
7463       /* Note: default conversion is only called in very special cases.  */
7464       init = default_conversion (init);
7465     }
7466
7467   /* Convert INIT to the reference type TYPE.  This may involve the
7468      creation of a temporary, whose lifetime must be the same as that
7469      of the reference.  If so, a DECL_STMT for the temporary will be
7470      added just after the DECL_STMT for DECL.  That's why we don't set
7471      DECL_INITIAL for local references (instead assigning to them
7472      explicitly); we need to allow the temporary to be initialized
7473      first.  */
7474   tmp = convert_to_reference
7475     (type, init, CONV_IMPLICIT,
7476      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7477      decl);
7478
7479   if (tmp == error_mark_node)
7480     return NULL_TREE;
7481   else if (tmp == NULL_TREE)
7482     {
7483       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7484       return NULL_TREE;
7485     }
7486
7487   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7488     return tmp;
7489
7490   DECL_INITIAL (decl) = tmp;
7491
7492   return NULL_TREE;
7493 }
7494
7495 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7496    mucking with forces it does not comprehend (i.e. initialization with a
7497    constructor).  If we are at global scope and won't go into COMMON, fill
7498    it in with a dummy CONSTRUCTOR to force the variable into .data;
7499    otherwise we can use error_mark_node.  */
7500
7501 static tree
7502 obscure_complex_init (decl, init)
7503      tree decl, init;
7504 {
7505   if (! flag_no_inline && TREE_STATIC (decl))
7506     {
7507       if (extract_init (decl, init))
7508         return NULL_TREE;
7509     }
7510
7511 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7512   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7513     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7514                                  NULL_TREE);
7515   else
7516 #endif
7517     DECL_INITIAL (decl) = error_mark_node;
7518
7519   return init;
7520 }
7521
7522 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7523    array until we finish parsing the initializer.  If that's the
7524    situation we're in, update DECL accordingly.  */
7525
7526 static void
7527 maybe_deduce_size_from_array_init (decl, init)
7528      tree decl;
7529      tree init;
7530 {
7531   tree type = TREE_TYPE (decl);
7532
7533   if (TREE_CODE (type) == ARRAY_TYPE
7534       && TYPE_DOMAIN (type) == NULL_TREE
7535       && TREE_CODE (decl) != TYPE_DECL)
7536     {
7537       /* do_default is really a C-ism to deal with tentative definitions.
7538          But let's leave it here to ease the eventual merge.  */
7539       int do_default = !DECL_EXTERNAL (decl);
7540       tree initializer = init ? init : DECL_INITIAL (decl);
7541       int failure = complete_array_type (type, initializer, do_default);
7542
7543       if (failure == 1)
7544         error ("initializer fails to determine size of `%D'", decl);
7545
7546       if (failure == 2)
7547         {
7548           if (do_default)
7549             error ("array size missing in `%D'", decl);
7550           /* If a `static' var's size isn't known, make it extern as
7551              well as static, so it does not get allocated.  If it's not
7552              `static', then don't mark it extern; finish_incomplete_decl
7553              will give it a default size and it will get allocated.  */
7554           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7555             DECL_EXTERNAL (decl) = 1;
7556         }
7557
7558       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7559           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7560                               integer_zero_node))
7561         error ("zero-size array `%D'", decl);
7562
7563       layout_decl (decl, 0);
7564     }
7565 }
7566
7567 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7568    any appropriate error messages regarding the layout.  */
7569
7570 static void
7571 layout_var_decl (decl)
7572      tree decl;
7573 {
7574   tree type = TREE_TYPE (decl);
7575 #if 0
7576   tree ttype = target_type (type);
7577 #endif
7578
7579   /* If we haven't already layed out this declaration, do so now.
7580      Note that we must not call complete type for an external object
7581      because it's type might involve templates that we are not
7582      supposed to isntantiate yet.  (And it's perfectly legal to say
7583      `extern X x' for some incomplete type `X'.)  */
7584   if (!DECL_EXTERNAL (decl))
7585     complete_type (type);
7586   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7587     layout_decl (decl, 0);
7588
7589   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7590     {
7591       /* An automatic variable with an incomplete type: that is an error.
7592          Don't talk about array types here, since we took care of that
7593          message in grokdeclarator.  */
7594       error ("storage size of `%D' isn't known", decl);
7595       TREE_TYPE (decl) = error_mark_node;
7596     }
7597 #if 0
7598   /* Keep this code around in case we later want to control debug info
7599      based on whether a type is "used".  (jason 1999-11-11) */
7600
7601   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7602     /* Let debugger know it should output info for this type.  */
7603     note_debug_info_needed (ttype);
7604
7605   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7606     note_debug_info_needed (DECL_CONTEXT (decl));
7607 #endif
7608
7609   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7610       && DECL_SIZE (decl) != NULL_TREE
7611       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7612     {
7613       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7614         constant_expression_warning (DECL_SIZE (decl));
7615       else
7616         error ("storage size of `%D' isn't constant", decl);
7617     }
7618
7619   if (TREE_STATIC (decl)
7620       && !DECL_ARTIFICIAL (decl)
7621       && current_function_decl
7622       && DECL_CONTEXT (decl) == current_function_decl)
7623     push_local_name (decl);
7624 }
7625
7626 /* If a local static variable is declared in an inline function, or if
7627    we have a weak definition, we must endeavor to create only one
7628    instance of the variable at link-time.  */
7629
7630 static void
7631 maybe_commonize_var (decl)
7632      tree decl;
7633 {
7634   /* Static data in a function with comdat linkage also has comdat
7635      linkage.  */
7636   if (TREE_STATIC (decl)
7637       /* Don't mess with __FUNCTION__.  */
7638       && ! DECL_ARTIFICIAL (decl)
7639       && current_function_decl
7640       && DECL_CONTEXT (decl) == current_function_decl
7641       && (DECL_DECLARED_INLINE_P (current_function_decl)
7642           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7643       && TREE_PUBLIC (current_function_decl))
7644     {
7645       /* If flag_weak, we don't need to mess with this, as we can just
7646          make the function weak, and let it refer to its unique local
7647          copy.  This works because we don't allow the function to be
7648          inlined.  */
7649       if (! flag_weak)
7650         {
7651           if (DECL_INTERFACE_KNOWN (current_function_decl))
7652             {
7653               TREE_PUBLIC (decl) = 1;
7654               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7655             }
7656           else if (DECL_INITIAL (decl) == NULL_TREE
7657                    || DECL_INITIAL (decl) == error_mark_node)
7658             {
7659               TREE_PUBLIC (decl) = 1;
7660               DECL_COMMON (decl) = 1;
7661             }
7662           /* else we lose. We can only do this if we can use common,
7663              which we can't if it has been initialized.  */
7664
7665           if (!TREE_PUBLIC (decl))
7666             {
7667               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7668               cp_warning_at ("  you can work around this by removing the initializer", decl);
7669             }
7670         }
7671       else
7672         comdat_linkage (decl);
7673     }
7674   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7675     /* Set it up again; we might have set DECL_INITIAL since the last
7676        time.  */
7677     comdat_linkage (decl);
7678 }
7679
7680 /* Issue an error message if DECL is an uninitialized const variable.  */
7681
7682 static void
7683 check_for_uninitialized_const_var (decl)
7684      tree decl;
7685 {
7686   tree type = TREE_TYPE (decl);
7687
7688   /* ``Unless explicitly declared extern, a const object does not have
7689      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7690      7.1.6 */
7691   if (TREE_CODE (decl) == VAR_DECL
7692       && TREE_CODE (type) != REFERENCE_TYPE
7693       && CP_TYPE_CONST_P (type)
7694       && !TYPE_NEEDS_CONSTRUCTING (type)
7695       && !DECL_INITIAL (decl))
7696     error ("uninitialized const `%D'", decl);
7697 }
7698
7699 /* Verify INIT (the initializer for DECL), and record the
7700    initialization in DECL_INITIAL, if appropriate.  Returns a new
7701    value for INIT.  */
7702
7703 static tree
7704 check_initializer (decl, init)
7705      tree decl;
7706      tree init;
7707 {
7708   tree type;
7709
7710   if (TREE_CODE (decl) == FIELD_DECL)
7711     return init;
7712
7713   type = TREE_TYPE (decl);
7714
7715   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7716   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7717     init = NULL_TREE;
7718
7719   /* Check the initializer.  */
7720   if (init)
7721     {
7722       /* Things that are going to be initialized need to have complete
7723          type.  */
7724       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7725
7726       if (type == error_mark_node)
7727         /* We will have already complained.  */
7728         init = NULL_TREE;
7729       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7730         {
7731           error ("variable-sized object `%D' may not be initialized", decl);
7732           init = NULL_TREE;
7733         }
7734       else if (TREE_CODE (type) == ARRAY_TYPE
7735                && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7736         {
7737           error ("elements of array `%#D' have incomplete type", decl);
7738           init = NULL_TREE;
7739         }
7740       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7741         {
7742           error ("`%D' has incomplete type", decl);
7743           TREE_TYPE (decl) = error_mark_node;
7744           init = NULL_TREE;
7745         }
7746     }
7747
7748   if (TREE_CODE (decl) == CONST_DECL)
7749     {
7750       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7751
7752       DECL_INITIAL (decl) = init;
7753
7754       my_friendly_assert (init != NULL_TREE, 149);
7755       init = NULL_TREE;
7756     }
7757   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7758     {
7759       init = grok_reference_init (decl, type, init);
7760       if (init)
7761         init = obscure_complex_init (decl, init);
7762     }
7763   else if (init)
7764     {
7765       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7766         {
7767           if (TREE_CODE (type) == ARRAY_TYPE)
7768             init = digest_init (type, init, (tree *) 0);
7769           else if (TREE_CODE (init) == CONSTRUCTOR
7770                    && TREE_HAS_CONSTRUCTOR (init))
7771             {
7772               if (TYPE_NON_AGGREGATE_CLASS (type))
7773                 {
7774                   error ("`%D' must be initialized by constructor, not by `{...}'",
7775                             decl);
7776                   init = error_mark_node;
7777                 }
7778               else
7779                 goto dont_use_constructor;
7780             }
7781         }
7782       else
7783         {
7784         dont_use_constructor:
7785           if (TREE_CODE (init) != TREE_VEC)
7786             init = store_init_value (decl, init);
7787         }
7788
7789       if (init)
7790         /* We must hide the initializer so that expand_decl
7791            won't try to do something it does not understand.  */
7792         init = obscure_complex_init (decl, init);
7793     }
7794   else if (DECL_EXTERNAL (decl))
7795     ;
7796   else if (TYPE_P (type)
7797            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7798     {
7799       tree core_type = strip_array_types (type);
7800
7801       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7802         {
7803           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7804             error ("structure `%D' with uninitialized const members", decl);
7805           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7806             error ("structure `%D' with uninitialized reference members",
7807                       decl);
7808         }
7809
7810       check_for_uninitialized_const_var (decl);
7811
7812       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7813         init = obscure_complex_init (decl, NULL_TREE);
7814
7815     }
7816   else
7817     check_for_uninitialized_const_var (decl);
7818
7819   return init;
7820 }
7821
7822 /* If DECL is not a local variable, give it RTL.  */
7823
7824 static void
7825 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7826      tree decl;
7827      tree init;
7828      const char *asmspec;
7829 {
7830   int toplev = toplevel_bindings_p ();
7831   int defer_p;
7832
7833   /* Handle non-variables up front.  */
7834   if (TREE_CODE (decl) != VAR_DECL)
7835     {
7836       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7837       return;
7838     }
7839
7840   /* If we see a class member here, it should be a static data
7841      member.  */
7842   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7843     {
7844       my_friendly_assert (TREE_STATIC (decl), 19990828);
7845       /* An in-class declaration of a static data member should be
7846          external; it is only a declaration, and not a definition.  */
7847       if (init == NULL_TREE)
7848         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7849     }
7850
7851   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7852   if (asmspec)
7853     {
7854       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7855       /* The `register' keyword, when used together with an
7856          asm-specification, indicates that the variable should be
7857          placed in a particular register.  */
7858       if (DECL_REGISTER (decl))
7859         DECL_C_HARD_REGISTER (decl) = 1;
7860     }
7861
7862   /* We don't create any RTL for local variables.  */
7863   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7864     return;
7865
7866   /* We defer emission of local statics until the corresponding
7867      DECL_STMT is expanded.  */
7868   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7869
7870   /* We try to defer namespace-scope static constants so that they are
7871      not emitted into the object file unnecessarily.  */
7872   if (!DECL_VIRTUAL_P (decl)
7873       && TREE_READONLY (decl)
7874       && DECL_INITIAL (decl) != NULL_TREE
7875       && DECL_INITIAL (decl) != error_mark_node
7876       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7877       && toplev
7878       && !TREE_PUBLIC (decl))
7879     {
7880       /* Fool with the linkage according to #pragma interface.  */
7881       if (!interface_unknown)
7882         {
7883           TREE_PUBLIC (decl) = 1;
7884           DECL_EXTERNAL (decl) = interface_only;
7885         }
7886
7887       defer_p = 1;
7888     }
7889
7890   /* If we're deferring the variable, we only need to make RTL if
7891      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7892      we need it.  (There's no way to lazily create RTL for things that
7893      have assembly specs because the information about the specifier
7894      isn't stored in the tree, yet)  */
7895   if (defer_p && asmspec)
7896     make_decl_rtl (decl, asmspec);
7897   /* If we're not deferring, go ahead and assemble the variable.  */
7898   else if (!defer_p)
7899     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7900 }
7901
7902 /* The old ARM scoping rules injected variables declared in the
7903    initialization statement of a for-statement into the surrounding
7904    scope.  We support this usage, in order to be backward-compatible.
7905    DECL is a just-declared VAR_DECL; if necessary inject its
7906    declaration into the surrounding scope.  */
7907
7908 void
7909 maybe_inject_for_scope_var (decl)
7910      tree decl;
7911 {
7912   if (!DECL_NAME (decl))
7913     return;
7914
7915   if (current_binding_level->is_for_scope)
7916     {
7917       struct binding_level *outer
7918         = current_binding_level->level_chain;
7919
7920       /* Check to see if the same name is already bound at the outer
7921          level, either because it was directly declared, or because a
7922          dead for-decl got preserved.  In either case, the code would
7923          not have been valid under the ARM scope rules, so clear
7924          is_for_scope for the current_binding_level.
7925
7926          Otherwise, we need to preserve the temp slot for decl to last
7927          into the outer binding level.  */
7928
7929       tree outer_binding
7930         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7931
7932       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7933           && (TREE_CODE (BINDING_VALUE (outer_binding))
7934               == VAR_DECL)
7935           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7936         {
7937           BINDING_VALUE (outer_binding)
7938             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7939           current_binding_level->is_for_scope = 0;
7940         }
7941       else if (DECL_IN_MEMORY_P (decl))
7942         preserve_temp_slots (DECL_RTL (decl));
7943     }
7944 }
7945
7946 /* Generate code to initialize DECL (a local variable).  */
7947
7948 void
7949 initialize_local_var (decl, init, flags)
7950      tree decl;
7951      tree init;
7952      int flags;
7953 {
7954   tree type = TREE_TYPE (decl);
7955
7956   /* If the type is bogus, don't bother initializing the variable.  */
7957   if (type == error_mark_node)
7958     return;
7959
7960   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7961     {
7962       /* If we used it already as memory, it must stay in memory.  */
7963       DECL_INITIAL (decl) = NULL_TREE;
7964       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7965     }
7966
7967   /* Local statics are handled differently from ordinary automatic
7968      variables.  */
7969   if (TREE_STATIC (decl))
7970     {
7971       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7972           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7973         expand_static_init (decl, init);
7974       return;
7975     }
7976
7977   if (DECL_SIZE (decl) && type != error_mark_node)
7978     {
7979       int already_used;
7980
7981       /* Compute and store the initial value.  */
7982       already_used = TREE_USED (decl) || TREE_USED (type);
7983
7984       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7985         {
7986           int saved_stmts_are_full_exprs_p;
7987
7988           my_friendly_assert (building_stmt_tree (), 20000906);
7989           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7990           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7991           finish_expr_stmt (build_aggr_init (decl, init, flags));
7992           current_stmt_tree ()->stmts_are_full_exprs_p =
7993             saved_stmts_are_full_exprs_p;
7994         }
7995
7996       /* Set this to 0 so we can tell whether an aggregate which was
7997          initialized was ever used.  Don't do this if it has a
7998          destructor, so we don't complain about the 'resource
7999          allocation is initialization' idiom.  Now set
8000          attribute((unused)) on types so decls of that type will be
8001          marked used. (see TREE_USED, above.)  */
8002       if (TYPE_NEEDS_CONSTRUCTING (type)
8003           && ! already_used
8004           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8005           && DECL_NAME (decl))
8006         TREE_USED (decl) = 0;
8007       else if (already_used)
8008         TREE_USED (decl) = 1;
8009     }
8010 }
8011
8012 /* Generate code to destroy DECL (a local variable).  */
8013
8014 static void
8015 destroy_local_var (decl)
8016      tree decl;
8017 {
8018   tree type = TREE_TYPE (decl);
8019   tree cleanup;
8020
8021   /* Only variables get cleaned up.  */
8022   if (TREE_CODE (decl) != VAR_DECL)
8023     return;
8024
8025   /* And only things with destructors need cleaning up.  */
8026   if (type == error_mark_node
8027       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8028     return;
8029
8030   if (TREE_CODE (decl) == VAR_DECL &&
8031       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8032     /* We don't clean up things that aren't defined in this
8033        translation unit, or that need a static cleanup.  The latter
8034        are handled by finish_file.  */
8035     return;
8036
8037   /* Compute the cleanup.  */
8038   cleanup = maybe_build_cleanup (decl);
8039
8040   /* Record the cleanup required for this declaration.  */
8041   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8042       && cleanup)
8043     finish_decl_cleanup (decl, cleanup);
8044 }
8045
8046 /* Finish processing of a declaration;
8047    install its line number and initial value.
8048    If the length of an array type is not known before,
8049    it must be determined now, from the initial value, or it is an error.
8050
8051    INIT holds the value of an initializer that should be allowed to escape
8052    the normal rules.
8053
8054    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8055    if the (init) syntax was used.  */
8056
8057 void
8058 cp_finish_decl (decl, init, asmspec_tree, flags)
8059      tree decl, init;
8060      tree asmspec_tree;
8061      int flags;
8062 {
8063   register tree type;
8064   tree ttype = NULL_TREE;
8065   const char *asmspec = NULL;
8066   int was_readonly = 0;
8067
8068   if (! decl)
8069     {
8070       if (init)
8071         error ("assignment (not initialization) in declaration");
8072       return;
8073     }
8074
8075   /* If a name was specified, get the string.  */
8076   if (asmspec_tree)
8077       asmspec = TREE_STRING_POINTER (asmspec_tree);
8078
8079   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8080     {
8081       error ("cannot initialize `%D' to namespace `%D'",
8082                 decl, init);
8083       init = NULL_TREE;
8084     }
8085
8086   if (current_class_type
8087       && CP_DECL_CONTEXT (decl) == current_class_type
8088       && TYPE_BEING_DEFINED (current_class_type)
8089       && (DECL_INITIAL (decl) || init))
8090     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8091
8092   if (TREE_CODE (decl) == VAR_DECL
8093       && DECL_CONTEXT (decl)
8094       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8095       && DECL_CONTEXT (decl) != current_namespace
8096       && init)
8097     {
8098       /* Leave the namespace of the object. */
8099       pop_decl_namespace ();
8100     }
8101
8102   type = TREE_TYPE (decl);
8103
8104   if (type == error_mark_node)
8105     return;
8106
8107   if (TYPE_HAS_MUTABLE_P (type))
8108     TREE_READONLY (decl) = 0;
8109
8110   if (processing_template_decl)
8111     {
8112       /* Add this declaration to the statement-tree.  */
8113       if (at_function_scope_p ()
8114           && TREE_CODE (decl) != RESULT_DECL)
8115         add_decl_stmt (decl);
8116
8117       if (init && DECL_INITIAL (decl))
8118         DECL_INITIAL (decl) = init;
8119       goto finish_end0;
8120     }
8121
8122   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8123   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8124
8125   /* Take care of TYPE_DECLs up front.  */
8126   if (TREE_CODE (decl) == TYPE_DECL)
8127     {
8128       if (init && DECL_INITIAL (decl))
8129         {
8130           /* typedef foo = bar; store the type of bar as the type of foo.  */
8131           TREE_TYPE (decl) = type = TREE_TYPE (init);
8132           DECL_INITIAL (decl) = init = NULL_TREE;
8133         }
8134       if (type != error_mark_node
8135           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8136         {
8137           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8138             warning ("shadowing previous type declaration of `%#D'", decl);
8139           set_identifier_type_value (DECL_NAME (decl), type);
8140           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8141         }
8142       GNU_xref_decl (current_function_decl, decl);
8143
8144       /* If we have installed this as the canonical typedef for this
8145          type, and that type has not been defined yet, delay emitting
8146          the debug information for it, as we will emit it later.  */
8147       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8148           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8149         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8150
8151       rest_of_decl_compilation (decl, NULL,
8152                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8153       goto finish_end;
8154     }
8155
8156   if (TREE_CODE (decl) != FUNCTION_DECL)
8157     ttype = target_type (type);
8158
8159   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8160       && TYPE_NEEDS_CONSTRUCTING (type))
8161     {
8162       /* Currently, GNU C++ puts constants in text space, making them
8163          impossible to initialize.  In the future, one would hope for
8164          an operating system which understood the difference between
8165          initialization and the running of a program.  */
8166       was_readonly = 1;
8167       TREE_READONLY (decl) = 0;
8168     }
8169
8170   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8171     {
8172       /* This must override the asm specifier which was placed by
8173          grokclassfn.  Lay this out fresh.  */
8174       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8175       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8176       make_decl_rtl (decl, asmspec);
8177     }
8178
8179   /* Deduce size of array from initialization, if not already known.  */
8180   init = check_initializer (decl, init);
8181   maybe_deduce_size_from_array_init (decl, init);
8182
8183   GNU_xref_decl (current_function_decl, decl);
8184
8185   /* Add this declaration to the statement-tree.  This needs to happen
8186      after the call to check_initializer so that the DECL_STMT for a
8187      reference temp is added before the DECL_STMT for the reference itself.  */
8188   if (building_stmt_tree ()
8189       && at_function_scope_p ()
8190       && TREE_CODE (decl) != RESULT_DECL)
8191     add_decl_stmt (decl);
8192
8193   if (TREE_CODE (decl) == VAR_DECL)
8194     layout_var_decl (decl);
8195
8196   /* Output the assembler code and/or RTL code for variables and functions,
8197      unless the type is an undefined structure or union.
8198      If not, it will get done when the type is completed.  */
8199   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8200       || TREE_CODE (decl) == RESULT_DECL)
8201     {
8202       if (TREE_CODE (decl) == VAR_DECL)
8203         maybe_commonize_var (decl);
8204
8205       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8206
8207       if (TREE_CODE (type) == FUNCTION_TYPE
8208           || TREE_CODE (type) == METHOD_TYPE)
8209         abstract_virtuals_error (decl,
8210                                  strip_array_types (TREE_TYPE (type)));
8211       else
8212         abstract_virtuals_error (decl, strip_array_types (type));
8213
8214       if (TREE_CODE (decl) == FUNCTION_DECL)
8215         ;
8216       else if (DECL_EXTERNAL (decl)
8217                && ! (DECL_LANG_SPECIFIC (decl)
8218                      && DECL_NOT_REALLY_EXTERN (decl)))
8219         {
8220           if (init)
8221             DECL_INITIAL (decl) = init;
8222         }
8223       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8224         {
8225           /* This is a local declaration.  */
8226           if (doing_semantic_analysis_p ())
8227             maybe_inject_for_scope_var (decl);
8228           /* Initialize the local variable.  But, if we're building a
8229              statement-tree, we'll do the initialization when we
8230              expand the tree.  */
8231           if (processing_template_decl)
8232             {
8233               if (init || DECL_INITIAL (decl) == error_mark_node)
8234                 DECL_INITIAL (decl) = init;
8235             }
8236           else
8237             {
8238               /* If we're not building RTL, then we need to do so
8239                  now.  */
8240               my_friendly_assert (building_stmt_tree (), 20000906);
8241               /* Initialize the variable.  */
8242               initialize_local_var (decl, init, flags);
8243               /* Clean up the variable.  */
8244               destroy_local_var (decl);
8245             }
8246         }
8247       else if (TREE_STATIC (decl) && type != error_mark_node)
8248         {
8249           /* Cleanups for static variables are handled by `finish_file'.  */
8250           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8251               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8252             expand_static_init (decl, init);
8253         }
8254     finish_end0:
8255
8256       /* Undo call to `pushclass' that was done in `start_decl'
8257          due to initialization of qualified member variable.
8258          I.e., Foo::x = 10;  */
8259       {
8260         tree context = CP_DECL_CONTEXT (decl);
8261         if (context
8262             && TYPE_P (context)
8263             && (TREE_CODE (decl) == VAR_DECL
8264                 /* We also have a pushclass done that we need to undo here
8265                    if we're at top level and declare a method.  */
8266                 || TREE_CODE (decl) == FUNCTION_DECL)
8267             /* If size hasn't been set, we're still defining it,
8268                and therefore inside the class body; don't pop
8269                the binding level..  */
8270             && COMPLETE_TYPE_P (context)
8271             && context == current_class_type)
8272           pop_nested_class ();
8273       }
8274     }
8275
8276  finish_end:
8277
8278   if (was_readonly)
8279     TREE_READONLY (decl) = 1;
8280 }
8281
8282 /* This is here for a midend callback from c-common.c */
8283
8284 void
8285 finish_decl (decl, init, asmspec_tree)
8286      tree decl, init;
8287      tree asmspec_tree;
8288 {
8289   cp_finish_decl (decl, init, asmspec_tree, 0);
8290 }
8291
8292 /* Returns a declaration for a VAR_DECL as if:
8293
8294      extern "C" TYPE NAME;
8295
8296    had been seen.  Used to create compiler-generated global
8297    variables.  */
8298
8299 tree
8300 declare_global_var (name, type)
8301      tree name;
8302      tree type;
8303 {
8304   tree decl;
8305
8306   push_to_top_level ();
8307   decl = build_decl (VAR_DECL, name, type);
8308   TREE_PUBLIC (decl) = 1;
8309   DECL_EXTERNAL (decl) = 1;
8310   DECL_ARTIFICIAL (decl) = 1;
8311   pushdecl (decl);
8312   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8313   pop_from_top_level ();
8314
8315   return decl;
8316 }
8317
8318 /* Returns a pointer to the `atexit' function.  Note that if
8319    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8320    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8321
8322 static tree
8323 get_atexit_node ()
8324 {
8325   tree atexit_fndecl;
8326   tree arg_types;
8327   tree fn_type;
8328   tree fn_ptr_type;
8329   const char *name;
8330
8331   if (atexit_node)
8332     return atexit_node;
8333
8334   if (flag_use_cxa_atexit)
8335     {
8336       /* The declaration for `__cxa_atexit' is:
8337
8338            int __cxa_atexit (void (*)(void *), void *, void *)
8339
8340          We build up the argument types and then then function type
8341          itself.  */
8342
8343       /* First, build the pointer-to-function type for the first
8344          argument.  */
8345       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8346       fn_type = build_function_type (void_type_node, arg_types);
8347       fn_ptr_type = build_pointer_type (fn_type);
8348       /* Then, build the rest of the argument types.  */
8349       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8350       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8351       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8352       /* And the final __cxa_atexit type.  */
8353       fn_type = build_function_type (integer_type_node, arg_types);
8354       fn_ptr_type = build_pointer_type (fn_type);
8355       name = "__cxa_atexit";
8356     }
8357   else
8358     {
8359       /* The declaration for `atexit' is:
8360
8361            int atexit (void (*)());
8362
8363          We build up the argument types and then then function type
8364          itself.  */
8365       fn_type = build_function_type (void_type_node, void_list_node);
8366       fn_ptr_type = build_pointer_type (fn_type);
8367       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8368       /* Build the final atexit type.  */
8369       fn_type = build_function_type (integer_type_node, arg_types);
8370       name = "atexit";
8371     }
8372
8373   /* Now, build the function declaration.  */
8374   push_lang_context (lang_name_c);
8375   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8376   mark_used (atexit_fndecl);
8377   pop_lang_context ();
8378   atexit_node = default_conversion (atexit_fndecl);
8379
8380   return atexit_node;
8381 }
8382
8383 /* Returns the __dso_handle VAR_DECL.  */
8384
8385 static tree
8386 get_dso_handle_node ()
8387 {
8388   if (dso_handle_node)
8389     return dso_handle_node;
8390
8391   /* Declare the variable.  */
8392   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8393                                         ptr_type_node);
8394
8395   return dso_handle_node;
8396 }
8397
8398 /* Begin a new function with internal linkage whose job will be simply
8399    to destroy some particular variable.  */
8400
8401 static tree
8402 start_cleanup_fn ()
8403 {
8404   static int counter = 0;
8405   int old_interface_unknown = interface_unknown;
8406   char name[32];
8407   tree parmtypes;
8408   tree fntype;
8409   tree fndecl;
8410
8411   push_to_top_level ();
8412
8413   /* No need to mangle this.  */
8414   push_lang_context (lang_name_c);
8415
8416   interface_unknown = 1;
8417
8418   /* Build the parameter-types.  */
8419   parmtypes = void_list_node;
8420   /* Functions passed to __cxa_atexit take an additional parameter.
8421      We'll just ignore it.  After we implement the new calling
8422      convention for destructors, we can eliminate the use of
8423      additional cleanup functions entirely in the -fnew-abi case.  */
8424   if (flag_use_cxa_atexit)
8425     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8426   /* Build the function type itself.  */
8427   fntype = build_function_type (void_type_node, parmtypes);
8428   /* Build the name of the function.  */
8429   sprintf (name, "__tcf_%d", counter++);
8430   /* Build the function declaration.  */
8431   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8432   /* It's a function with internal linkage, generated by the
8433      compiler.  */
8434   TREE_PUBLIC (fndecl) = 0;
8435   DECL_ARTIFICIAL (fndecl) = 1;
8436   /* Make the function `inline' so that it is only emitted if it is
8437      actually needed.  It is unlikely that it will be inlined, since
8438      it is only called via a function pointer, but we avoid unnecessary
8439      emissions this way.  */
8440   DECL_INLINE (fndecl) = 1;
8441   /* Build the parameter.  */
8442   if (flag_use_cxa_atexit)
8443     {
8444       tree parmdecl;
8445
8446       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8447       DECL_CONTEXT (parmdecl) = fndecl;
8448       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8449       TREE_USED (parmdecl) = 1;
8450       DECL_ARGUMENTS (fndecl) = parmdecl;
8451     }
8452
8453   pushdecl (fndecl);
8454   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8455
8456   interface_unknown = old_interface_unknown;
8457
8458   pop_lang_context ();
8459
8460   return current_function_decl;
8461 }
8462
8463 /* Finish the cleanup function begun by start_cleanup_fn.  */
8464
8465 static void
8466 end_cleanup_fn ()
8467 {
8468   expand_body (finish_function (0));
8469
8470   pop_from_top_level ();
8471 }
8472
8473 /* Generate code to handle the destruction of DECL, an object with
8474    static storage duration.  */
8475
8476 void
8477 register_dtor_fn (decl)
8478      tree decl;
8479 {
8480   tree cleanup;
8481   tree compound_stmt;
8482   tree args;
8483   tree fcall;
8484
8485   int saved_flag_access_control;
8486
8487   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8488     return;
8489
8490   /* Call build_cleanup before we enter the anonymous function so that
8491      any access checks will be done relative to the current scope,
8492      rather than the scope of the anonymous function.  */
8493   build_cleanup (decl);
8494
8495   /* Now start the function.  */
8496   cleanup = start_cleanup_fn ();
8497
8498   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8499      to the original function, rather than the anonymous one.  That
8500      will make the back-end think that nested functions are in use,
8501      which causes confusion.  */
8502   saved_flag_access_control = flag_access_control;
8503   flag_access_control = 0;
8504   fcall = build_cleanup (decl);
8505   flag_access_control = saved_flag_access_control;
8506
8507   /* Create the body of the anonymous function.  */
8508   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8509   finish_expr_stmt (fcall);
8510   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8511   end_cleanup_fn ();
8512
8513   /* Call atexit with the cleanup function.  */
8514   mark_addressable (cleanup);
8515   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8516   if (flag_use_cxa_atexit)
8517     {
8518       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8519       args = tree_cons (NULL_TREE, null_pointer_node, args);
8520       args = tree_cons (NULL_TREE, cleanup, args);
8521     }
8522   else
8523     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8524   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8525 }
8526
8527 void
8528 expand_static_init (decl, init)
8529      tree decl;
8530      tree init;
8531 {
8532   tree oldstatic = value_member (decl, static_aggregates);
8533
8534   if (oldstatic)
8535     {
8536       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8537         error ("multiple initializations given for `%D'", decl);
8538     }
8539   else if (! toplevel_bindings_p ())
8540     {
8541       /* Emit code to perform this initialization but once.  */
8542       tree if_stmt;
8543       tree then_clause;
8544       tree assignment;
8545       tree guard;
8546       tree guard_init;
8547
8548       /* Emit code to perform this initialization but once.  This code
8549          looks like:
8550
8551            static int guard = 0;
8552            if (!guard) {
8553              // Do initialization.
8554              guard = 1;
8555              // Register variable for destruction at end of program.
8556            }
8557
8558          Note that the `temp' variable is only set to 1 *after* the
8559          initialization is complete.  This ensures that an exception,
8560          thrown during the construction, will cause the variable to
8561          reinitialized when we pass through this code again, as per:
8562
8563            [stmt.dcl]
8564
8565            If the initialization exits by throwing an exception, the
8566            initialization is not complete, so it will be tried again
8567            the next time control enters the declaration.
8568
8569          In theory, this process should be thread-safe, too; multiple
8570          threads should not be able to initialize the variable more
8571          than once.  We don't yet attempt to ensure thread-safety.  */
8572
8573       /* Create the guard variable.  */
8574       guard = get_guard (decl);
8575
8576       /* Begin the conditional initialization.  */
8577       if_stmt = begin_if_stmt ();
8578       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8579       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8580
8581       /* Do the initialization itself.  */
8582       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8583           || (init && TREE_CODE (init) == TREE_LIST))
8584         assignment = build_aggr_init (decl, init, 0);
8585       else if (init)
8586         /* The initialization we're doing here is just a bitwise
8587            copy.  */
8588         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8589       else
8590         assignment = NULL_TREE;
8591
8592       /* Once the assignment is complete, set TEMP to 1.  Since the
8593          construction of the static object is complete at this point,
8594          we want to make sure TEMP is set to 1 even if a temporary
8595          constructed during the initialization throws an exception
8596          when it is destroyed.  So, we combine the initialization and
8597          the assignment to TEMP into a single expression, ensuring
8598          that when we call finish_expr_stmt the cleanups will not be
8599          run until after TEMP is set to 1.  */
8600       guard_init = set_guard (guard);
8601       if (assignment)
8602         {
8603           assignment = tree_cons (NULL_TREE, assignment,
8604                                   build_tree_list (NULL_TREE,
8605                                                    guard_init));
8606           assignment = build_compound_expr (assignment);
8607         }
8608       else
8609         assignment = guard_init;
8610       finish_expr_stmt (assignment);
8611
8612       /* Use atexit to register a function for destroying this static
8613          variable.  */
8614       register_dtor_fn (decl);
8615
8616       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8617       finish_then_clause (if_stmt);
8618       finish_if_stmt ();
8619     }
8620   else
8621     static_aggregates = tree_cons (init, decl, static_aggregates);
8622 }
8623
8624 /* Finish the declaration of a catch-parameter.  */
8625
8626 tree
8627 start_handler_parms (declspecs, declarator)
8628      tree declspecs;
8629      tree declarator;
8630 {
8631   tree decl;
8632   if (declspecs)
8633     {
8634       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8635                              1, NULL);
8636       if (decl == NULL_TREE)
8637         error ("invalid catch parameter");
8638     }
8639   else
8640     decl = NULL_TREE;
8641
8642   return decl;
8643 }
8644
8645 \f
8646 /* Make TYPE a complete type based on INITIAL_VALUE.
8647    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8648    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8649
8650 int
8651 complete_array_type (type, initial_value, do_default)
8652      tree type, initial_value;
8653      int do_default;
8654 {
8655   register tree maxindex = NULL_TREE;
8656   int value = 0;
8657
8658   if (initial_value)
8659     {
8660       /* An array of character type can be initialized from a
8661          brace-enclosed string constant.  */
8662       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8663           && TREE_CODE (initial_value) == CONSTRUCTOR
8664           && CONSTRUCTOR_ELTS (initial_value)
8665           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8666               == STRING_CST)
8667           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8668         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8669
8670       /* Note MAXINDEX is really the maximum index, one less than the
8671          size.  */
8672       if (TREE_CODE (initial_value) == STRING_CST)
8673         {
8674           int eltsize
8675             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8676           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8677                                    / eltsize) - 1, 0);
8678         }
8679       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8680         {
8681           tree elts = CONSTRUCTOR_ELTS (initial_value);
8682
8683           maxindex = ssize_int (-1);
8684           for (; elts; elts = TREE_CHAIN (elts))
8685             {
8686               if (TREE_PURPOSE (elts))
8687                 maxindex = TREE_PURPOSE (elts);
8688               else
8689                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8690             }
8691           maxindex = copy_node (maxindex);
8692         }
8693       else
8694         {
8695           /* Make an error message unless that happened already.  */
8696           if (initial_value != error_mark_node)
8697             value = 1;
8698           else
8699             initial_value = NULL_TREE;
8700
8701           /* Prevent further error messages.  */
8702           maxindex = build_int_2 (0, 0);
8703         }
8704     }
8705
8706   if (!maxindex)
8707     {
8708       if (do_default)
8709         maxindex = build_int_2 (0, 0);
8710       value = 2;
8711     }
8712
8713   if (maxindex)
8714     {
8715       tree itype;
8716       tree domain;
8717
8718       domain = build_index_type (maxindex);
8719       TYPE_DOMAIN (type) = domain;
8720
8721       if (! TREE_TYPE (maxindex))
8722         TREE_TYPE (maxindex) = domain;
8723       if (initial_value)
8724         itype = TREE_TYPE (initial_value);
8725       else
8726         itype = NULL;
8727       if (itype && !TYPE_DOMAIN (itype))
8728         TYPE_DOMAIN (itype) = domain;
8729       /* The type of the main variant should never be used for arrays
8730          of different sizes.  It should only ever be completed with the
8731          size of the array.  */
8732       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8733         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8734     }
8735
8736   /* Lay out the type now that we can get the real answer.  */
8737
8738   layout_type (type);
8739
8740   return value;
8741 }
8742 \f
8743 /* Return zero if something is declared to be a member of type
8744    CTYPE when in the context of CUR_TYPE.  STRING is the error
8745    message to print in that case.  Otherwise, quietly return 1.  */
8746
8747 static int
8748 member_function_or_else (ctype, cur_type, flags)
8749      tree ctype, cur_type;
8750      enum overload_flags flags;
8751 {
8752   if (ctype && ctype != cur_type)
8753     {
8754       if (flags == DTOR_FLAG)
8755         error ("destructor for alien class `%T' cannot be a member",
8756                   ctype);
8757       else
8758         error ("constructor for alien class `%T' cannot be a member",
8759                   ctype);
8760       return 0;
8761     }
8762   return 1;
8763 }
8764 \f
8765 /* Subroutine of `grokdeclarator'.  */
8766
8767 /* Generate errors possibly applicable for a given set of specifiers.
8768    This is for ARM $7.1.2.  */
8769
8770 static void
8771 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8772      tree object;
8773      const char *type;
8774      int virtualp, quals, friendp, raises, inlinep;
8775 {
8776   if (virtualp)
8777     error ("`%D' declared as a `virtual' %s", object, type);
8778   if (inlinep)
8779     error ("`%D' declared as an `inline' %s", object, type);
8780   if (quals)
8781     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8782               object, type);
8783   if (friendp)
8784     cp_error_at ("`%D' declared as a friend", object);
8785   if (raises
8786       && (TREE_CODE (object) == TYPE_DECL
8787           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8788               && !TYPE_REFFN_P (TREE_TYPE (object))
8789               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8790     cp_error_at ("`%D' declared with an exception specification", object);
8791 }
8792
8793 /* CTYPE is class type, or null if non-class.
8794    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8795    or METHOD_TYPE.
8796    DECLARATOR is the function's name.
8797    VIRTUALP is truthvalue of whether the function is virtual or not.
8798    FLAGS are to be passed through to `grokclassfn'.
8799    QUALS are qualifiers indicating whether the function is `const'
8800    or `volatile'.
8801    RAISES is a list of exceptions that this function can raise.
8802    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8803    not look, and -1 if we should not call `grokclassfn' at all.
8804
8805    Returns `NULL_TREE' if something goes wrong, after issuing
8806    applicable error messages.  */
8807
8808 static tree
8809 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8810             raises, check, friendp, publicp, inlinep, funcdef_flag,
8811             template_count, in_namespace)
8812      tree ctype, type;
8813      tree declarator;
8814      tree orig_declarator;
8815      int virtualp;
8816      enum overload_flags flags;
8817      tree quals, raises;
8818      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8819      tree in_namespace;
8820 {
8821   tree decl;
8822   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8823   int has_default_arg = 0;
8824   tree t;
8825
8826   if (raises)
8827     type = build_exception_variant (type, raises);
8828
8829   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8830   /* Propagate volatile out from type to decl. */
8831   if (TYPE_VOLATILE (type))
8832     TREE_THIS_VOLATILE (decl) = 1;
8833
8834   /* If this decl has namespace scope, set that up.  */
8835   if (in_namespace)
8836     set_decl_namespace (decl, in_namespace, friendp);
8837   else if (!ctype)
8838     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8839
8840   /* `main' and builtins have implicit 'C' linkage.  */
8841   if ((MAIN_NAME_P (declarator)
8842        || (IDENTIFIER_LENGTH (declarator) > 10
8843            && IDENTIFIER_POINTER (declarator)[0] == '_'
8844            && IDENTIFIER_POINTER (declarator)[1] == '_'
8845            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8846       && current_lang_name == lang_name_cplusplus
8847       && ctype == NULL_TREE
8848       /* NULL_TREE means global namespace.  */
8849       && DECL_CONTEXT (decl) == NULL_TREE)
8850     SET_DECL_LANGUAGE (decl, lang_c);
8851
8852   /* Should probably propagate const out from type to decl I bet (mrs).  */
8853   if (staticp)
8854     {
8855       DECL_STATIC_FUNCTION_P (decl) = 1;
8856       DECL_CONTEXT (decl) = ctype;
8857     }
8858
8859   if (ctype)
8860     DECL_CONTEXT (decl) = ctype;
8861
8862   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8863     {
8864       if (processing_template_decl)
8865         error ("cannot declare `::main' to be a template");
8866       if (inlinep)
8867         error ("cannot declare `::main' to be inline");
8868       if (!publicp)
8869         error ("cannot declare `::main' to be static");
8870       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8871                         integer_type_node))
8872         error ("`main' must return `int'");
8873       inlinep = 0;
8874       publicp = 1;
8875     }
8876
8877   /* Members of anonymous types and local classes have no linkage; make
8878      them internal.  */
8879   /* FIXME what if it gets a name from typedef?  */
8880   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8881                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8882     publicp = 0;
8883
8884   if (publicp)
8885     {
8886       /* [basic.link]: A name with no linkage (notably, the name of a class
8887          or enumeration declared in a local scope) shall not be used to
8888          declare an entity with linkage.
8889
8890          Only check this for public decls for now.  */
8891       t = no_linkage_check (TREE_TYPE (decl));
8892       if (t)
8893         {
8894           if (TYPE_ANONYMOUS_P (t))
8895             {
8896               if (DECL_EXTERN_C_P (decl))
8897                 /* Allow this; it's pretty common in C.  */;
8898               else
8899                 {
8900                   pedwarn ("non-local function `%#D' uses anonymous type",
8901                               decl);
8902                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8903                     cp_pedwarn_at ("\
8904 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8905                                 TYPE_NAME (t));
8906                 }
8907             }
8908           else
8909             pedwarn ("non-local function `%#D' uses local type `%T'",
8910                         decl, t);
8911         }
8912     }
8913
8914   TREE_PUBLIC (decl) = publicp;
8915   if (! publicp)
8916     {
8917       DECL_INTERFACE_KNOWN (decl) = 1;
8918       DECL_NOT_REALLY_EXTERN (decl) = 1;
8919     }
8920
8921   /* If the declaration was declared inline, mark it as such.  */
8922   if (inlinep)
8923     DECL_DECLARED_INLINE_P (decl) = 1;
8924   /* We inline functions that are explicitly declared inline, or, when
8925      the user explicitly asks us to, all functions.  */
8926   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8927     DECL_INLINE (decl) = 1;
8928
8929   DECL_EXTERNAL (decl) = 1;
8930   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8931     {
8932       error ("%smember function `%D' cannot have `%T' method qualifier",
8933                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8934       quals = NULL_TREE;
8935     }
8936
8937   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8938     grok_op_properties (decl, friendp);
8939
8940   if (ctype && decl_function_context (decl))
8941     DECL_NO_STATIC_CHAIN (decl) = 1;
8942
8943   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8944     if (TREE_PURPOSE (t)
8945         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8946       {
8947         has_default_arg = 1;
8948         break;
8949       }
8950
8951   if (friendp
8952       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8953     {
8954       if (funcdef_flag)
8955         error
8956           ("defining explicit specialization `%D' in friend declaration",
8957            orig_declarator);
8958       else
8959         {
8960           tree fns = TREE_OPERAND (orig_declarator, 0);
8961           tree args = TREE_OPERAND (orig_declarator, 1);
8962
8963           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8964             {
8965               /* Something like `template <class T> friend void f<T>()'.  */
8966               error ("invalid use of template-id `%D' in declaration of primary template",
8967                         orig_declarator);
8968               return NULL_TREE;
8969             }
8970
8971
8972           /* A friend declaration of the form friend void f<>().  Record
8973              the information in the TEMPLATE_ID_EXPR.  */
8974           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8975
8976           if (TREE_CODE (fns) == COMPONENT_REF)
8977             {
8978               /* Due to bison parser ickiness, we will have already looked
8979                  up an operator_name or PFUNCNAME within the current class
8980                  (see template_id in parse.y). If the current class contains
8981                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8982
8983               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8984                                   == current_class_type, 20001120);
8985               fns = TREE_OPERAND (fns, 1);
8986             }
8987           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8988                               || TREE_CODE (fns) == LOOKUP_EXPR
8989                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8990           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8991
8992           if (has_default_arg)
8993             {
8994               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8995                         decl);
8996               return NULL_TREE;
8997             }
8998
8999           if (inlinep)
9000             {
9001               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9002                         decl);
9003               return NULL_TREE;
9004             }
9005         }
9006     }
9007
9008   if (has_default_arg)
9009     add_defarg_fn (decl);
9010
9011   if (funcdef_flag)
9012     /* Make the init_value nonzero so pushdecl knows this is not
9013        tentative.  error_mark_node is replaced later with the BLOCK.  */
9014     DECL_INITIAL (decl) = error_mark_node;
9015
9016   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9017     TREE_NOTHROW (decl) = 1;
9018
9019   /* Caller will do the rest of this.  */
9020   if (check < 0)
9021     return decl;
9022
9023   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9024     DECL_CONSTRUCTOR_P (decl) = 1;
9025
9026   /* Function gets the ugly name, field gets the nice one.  This call
9027      may change the type of the function (because of default
9028      parameters)!  */
9029   if (ctype != NULL_TREE)
9030     grokclassfn (ctype, decl, flags, quals);
9031
9032   decl = check_explicit_specialization (orig_declarator, decl,
9033                                         template_count,
9034                                         2 * (funcdef_flag != 0) +
9035                                         4 * (friendp != 0));
9036   if (decl == error_mark_node)
9037     return NULL_TREE;
9038
9039   if (ctype != NULL_TREE
9040       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9041       && check)
9042     {
9043       tree old_decl;
9044
9045       old_decl = check_classfn (ctype, decl);
9046
9047       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9048         /* Because grokfndecl is always supposed to return a
9049            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9050            here.  We depend on our callers to figure out that its
9051            really a template that's being returned.  */
9052         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9053
9054       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9055           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9056         {
9057           /* Remove the `this' parm added by grokclassfn.
9058              XXX Isn't this done in start_function, too?  */
9059           revert_static_member_fn (decl);
9060           last_function_parms = TREE_CHAIN (last_function_parms);
9061         }
9062       if (old_decl && DECL_ARTIFICIAL (old_decl))
9063         error ("definition of implicitly-declared `%D'", old_decl);
9064
9065       if (old_decl)
9066         {
9067           /* Since we've smashed OLD_DECL to its
9068              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9069           if (TREE_CODE (decl) == TEMPLATE_DECL)
9070             decl = DECL_TEMPLATE_RESULT (decl);
9071
9072           /* Attempt to merge the declarations.  This can fail, in
9073              the case of some illegal specialization declarations.  */
9074           if (!duplicate_decls (decl, old_decl))
9075             error ("no `%#D' member function declared in class `%T'",
9076                       decl, ctype);
9077           return old_decl;
9078         }
9079     }
9080
9081   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9082     return NULL_TREE;
9083
9084   if (ctype == NULL_TREE || check)
9085     return decl;
9086
9087   if (virtualp)
9088     DECL_VIRTUAL_P (decl) = 1;
9089
9090   return decl;
9091 }
9092
9093 static tree
9094 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9095      tree type;
9096      tree declarator;
9097      RID_BIT_TYPE *specbits_in;
9098      int initialized;
9099      int constp;
9100      tree in_namespace;
9101 {
9102   tree decl;
9103   RID_BIT_TYPE specbits;
9104
9105   specbits = *specbits_in;
9106
9107   if (TREE_CODE (type) == OFFSET_TYPE)
9108     {
9109       /* If you declare a static member so that it
9110          can be initialized, the code will reach here.  */
9111       tree basetype = TYPE_OFFSET_BASETYPE (type);
9112       type = TREE_TYPE (type);
9113       decl = build_lang_decl (VAR_DECL, declarator, type);
9114       DECL_CONTEXT (decl) = basetype;
9115     }
9116   else
9117     {
9118       tree context;
9119
9120       if (in_namespace)
9121         context = in_namespace;
9122       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9123         context = current_namespace;
9124       else
9125         context = NULL_TREE;
9126
9127       /* For namespace-scope variables, declared in a template, we
9128          need the full lang_decl.  The same is true for
9129          namespace-scope variables that do not have C++ language
9130          linkage.  */
9131       if (context
9132           && (processing_template_decl
9133               || current_lang_name != lang_name_cplusplus))
9134         decl = build_lang_decl (VAR_DECL, declarator, type);
9135       else
9136         decl = build_decl (VAR_DECL, declarator, type);
9137
9138       if (context)
9139         set_decl_namespace (decl, context, 0);
9140
9141       context = DECL_CONTEXT (decl);
9142       if (declarator && context && current_lang_name != lang_name_c)
9143         /* We can't mangle lazily here because we don't have any
9144            way to recover whether or not a variable was `extern
9145            "C"' later.  */
9146         mangle_decl (decl);
9147     }
9148
9149   if (in_namespace)
9150     set_decl_namespace (decl, in_namespace, 0);
9151
9152   if (RIDBIT_SETP (RID_EXTERN, specbits))
9153     {
9154       DECL_THIS_EXTERN (decl) = 1;
9155       DECL_EXTERNAL (decl) = !initialized;
9156     }
9157
9158   /* In class context, static means one per class,
9159      public access, and static storage.  */
9160   if (DECL_CLASS_SCOPE_P (decl))
9161     {
9162       TREE_PUBLIC (decl) = 1;
9163       TREE_STATIC (decl) = 1;
9164       DECL_EXTERNAL (decl) = 0;
9165     }
9166   /* At top level, either `static' or no s.c. makes a definition
9167      (perhaps tentative), and absence of `static' makes it public.  */
9168   else if (toplevel_bindings_p ())
9169     {
9170       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9171                             && (DECL_THIS_EXTERN (decl) || ! constp));
9172       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9173     }
9174   /* Not at top level, only `static' makes a static definition.  */
9175   else
9176     {
9177       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9178       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9179     }
9180
9181   if (TREE_PUBLIC (decl))
9182     {
9183       /* [basic.link]: A name with no linkage (notably, the name of a class
9184          or enumeration declared in a local scope) shall not be used to
9185          declare an entity with linkage.
9186
9187          Only check this for public decls for now.  */
9188       tree t = no_linkage_check (TREE_TYPE (decl));
9189       if (t)
9190         {
9191           if (TYPE_ANONYMOUS_P (t))
9192             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9193           else
9194             pedwarn ("non-local variable `%#D' uses local type `%T'",
9195                         decl, t);
9196         }
9197     }
9198
9199   return decl;
9200 }
9201
9202 /* Create and return a canonical pointer to member function type, for
9203    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9204
9205 tree
9206 build_ptrmemfunc_type (type)
9207      tree type;
9208 {
9209   tree fields[4];
9210   tree t;
9211   tree unqualified_variant = NULL_TREE;
9212
9213   if (type == error_mark_node)
9214     return type;
9215
9216   /* If a canonical type already exists for this type, use it.  We use
9217      this method instead of type_hash_canon, because it only does a
9218      simple equality check on the list of field members.  */
9219
9220   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9221     return t;
9222
9223   /* Make sure that we always have the unqualified pointer-to-member
9224      type first.  */
9225   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9226     unqualified_variant
9227       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9228
9229   t = make_aggr_type (RECORD_TYPE);
9230   /* Let the front-end know this is a pointer to member function...  */
9231   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9232   /* ... and not really an aggregate.  */
9233   SET_IS_AGGR_TYPE (t, 0);
9234
9235   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9236   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9237                           delta_type_node);
9238   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9239
9240   /* Zap out the name so that the back-end will give us the debugging
9241      information for this anonymous RECORD_TYPE.  */
9242   TYPE_NAME (t) = NULL_TREE;
9243
9244   /* If this is not the unqualified form of this pointer-to-member
9245      type, set the TYPE_MAIN_VARIANT for this type to be the
9246      unqualified type.  Since they are actually RECORD_TYPEs that are
9247      not variants of each other, we must do this manually.  */
9248   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9249     {
9250       t = build_qualified_type (t, cp_type_quals (type));
9251       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9252       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9253       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9254     }
9255
9256   /* Cache this pointer-to-member type so that we can find it again
9257      later.  */
9258   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9259
9260   /* Seems to be wanted.  */
9261   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9262
9263   return t;
9264 }
9265
9266 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9267    Check to see that the definition is valid.  Issue appropriate error
9268    messages.  Return 1 if the definition is particularly bad, or 0
9269    otherwise.  */
9270
9271 int
9272 check_static_variable_definition (decl, type)
9273      tree decl;
9274      tree type;
9275 {
9276   /* Motion 10 at San Diego: If a static const integral data member is
9277      initialized with an integral constant expression, the initializer
9278      may appear either in the declaration (within the class), or in
9279      the definition, but not both.  If it appears in the class, the
9280      member is a member constant.  The file-scope definition is always
9281      required.  */
9282   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9283     {
9284       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9285                 type);
9286       /* If we just return the declaration, crashes will sometimes
9287          occur.  We therefore return void_type_node, as if this was a
9288          friend declaration, to cause callers to completely ignore
9289          this declaration.  */
9290       return 1;
9291     }
9292   else if (!CP_TYPE_CONST_P (type))
9293     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9294               decl);
9295   else if (pedantic && !INTEGRAL_TYPE_P (type))
9296     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9297
9298   return 0;
9299 }
9300
9301 /* Given the SIZE (i.e., number of elements) in an array, compute an
9302    appropriate index type for the array.  If non-NULL, NAME is the
9303    name of the thing being declared.  */
9304
9305 tree
9306 compute_array_index_type (name, size)
9307      tree name;
9308      tree size;
9309 {
9310   tree itype;
9311
9312   /* If this involves a template parameter, it will be a constant at
9313      instantiation time, but we don't know what the value is yet.
9314      Even if no template parameters are involved, we may an expression
9315      that is not a constant; we don't even simplify `1 + 2' when
9316      processing a template.  */
9317   if (processing_template_decl)
9318     {
9319       /* Resolve a qualified reference to an enumerator or static
9320          const data member of ours.  */
9321       if (TREE_CODE (size) == SCOPE_REF
9322           && TREE_OPERAND (size, 0) == current_class_type)
9323         {
9324           tree t = lookup_field (current_class_type,
9325                                  TREE_OPERAND (size, 1), 0, 0);
9326           if (t)
9327             size = t;
9328         }
9329
9330       return build_index_type (build_min (MINUS_EXPR, sizetype,
9331                                           size, integer_one_node));
9332     }
9333
9334   /* The size might be the result of a cast. */
9335   STRIP_TYPE_NOPS (size);
9336
9337   /* It might be a const variable or enumeration constant.  */
9338   size = decl_constant_value (size);
9339
9340   /* The array bound must be an integer type.  */
9341   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9342       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9343       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9344     {
9345       if (name)
9346         error ("size of array `%D' has non-integer type", name);
9347       else
9348         error ("size of array has non-integer type");
9349       size = integer_one_node;
9350     }
9351
9352   /* Normally, the array-bound will be a constant.  */
9353   if (TREE_CODE (size) == INTEGER_CST)
9354     {
9355       /* Check to see if the array bound overflowed.  Make that an
9356          error, no matter how generous we're being.  */
9357       int old_flag_pedantic_errors = flag_pedantic_errors;
9358       int old_pedantic = pedantic;
9359       pedantic = flag_pedantic_errors = 1;
9360       constant_expression_warning (size);
9361       pedantic = old_pedantic;
9362       flag_pedantic_errors = old_flag_pedantic_errors;
9363
9364       /* An array must have a positive number of elements.  */
9365       if (INT_CST_LT (size, integer_zero_node))
9366         {
9367           if (name)
9368             error ("size of array `%D' is negative", name);
9369           else
9370             error ("size of array is negative");
9371           size = integer_one_node;
9372         }
9373       /* Except that an extension we allow zero-sized arrays.  We
9374          always allow them in system headers because glibc uses
9375          them.  */
9376       else if (integer_zerop (size) && pedantic && !in_system_header)
9377         {
9378           if (name)
9379             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9380           else
9381             pedwarn ("ISO C++ forbids zero-size array");
9382         }
9383     }
9384   else if (TREE_CONSTANT (size))
9385     {
9386       /* `(int) &fn' is not a valid array bound.  */
9387       if (name)
9388         error ("size of array `%D' is not an integral constant-expression",
9389                   name);
9390       else
9391         error ("size of array is not an integral constant-expression");
9392     }
9393
9394   /* Compute the index of the largest element in the array.  It is
9395      one less than the number of elements in the array.  */
9396   itype
9397     = fold (cp_build_binary_op (MINUS_EXPR,
9398                                 cp_convert (ssizetype, size),
9399                                 cp_convert (ssizetype,
9400                                             integer_one_node)));
9401
9402   /* Check for variable-sized arrays.  We allow such things as an
9403      extension, even though they are not allowed in ANSI/ISO C++.  */
9404   if (!TREE_CONSTANT (itype))
9405     {
9406       if (pedantic)
9407         {
9408           if (name)
9409             pedwarn ("ISO C++ forbids variable-size array `%D'",
9410                         name);
9411           else
9412             pedwarn ("ISO C++ forbids variable-size array");
9413         }
9414
9415       /* Create a variable-sized array index type.  */
9416       itype = variable_size (itype);
9417     }
9418   /* Make sure that there was no overflow when creating to a signed
9419      index type.  (For example, on a 32-bit machine, an array with
9420      size 2^32 - 1 is too big.)  */
9421   else if (TREE_OVERFLOW (itype))
9422     {
9423       error ("overflow in array dimension");
9424       TREE_OVERFLOW (itype) = 0;
9425     }
9426
9427   /* Create and return the appropriate index type.  */
9428   return build_index_type (itype);
9429 }
9430
9431 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9432    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9433    with this type.  */
9434
9435 static tree
9436 create_array_type_for_decl (name, type, size)
9437      tree name;
9438      tree type;
9439      tree size;
9440 {
9441   tree itype = NULL_TREE;
9442   const char* error_msg;
9443
9444   /* If things have already gone awry, bail now.  */
9445   if (type == error_mark_node || size == error_mark_node)
9446     return error_mark_node;
9447
9448   /* Assume that everything will go OK.  */
9449   error_msg = NULL;
9450
9451   /* There are some types which cannot be array elements.  */
9452   switch (TREE_CODE (type))
9453     {
9454     case VOID_TYPE:
9455       error_msg = "array of void";
9456       break;
9457
9458     case FUNCTION_TYPE:
9459       error_msg = "array of functions";
9460       break;
9461
9462     case REFERENCE_TYPE:
9463       error_msg = "array of references";
9464       break;
9465
9466     case OFFSET_TYPE:
9467       error_msg = "array of data members";
9468       break;
9469
9470     case METHOD_TYPE:
9471       error_msg = "array of function members";
9472       break;
9473
9474     default:
9475       break;
9476     }
9477
9478   /* If something went wrong, issue an error-message and return.  */
9479   if (error_msg)
9480     {
9481       if (name)
9482         error ("declaration of `%D' as %s", name, error_msg);
9483       else
9484         error ("creating %s", error_msg);
9485
9486       return error_mark_node;
9487     }
9488
9489   /* [dcl.array]
9490
9491      The constant expressions that specify the bounds of the arrays
9492      can be omitted only for the first member of the sequence.  */
9493   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9494     {
9495       if (name)
9496         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9497                   name);
9498       else
9499         error ("multidimensional array must have bounds for all dimensions except the first");
9500
9501       return error_mark_node;
9502     }
9503
9504   /* Figure out the index type for the array.  */
9505   if (size)
9506     itype = compute_array_index_type (name, size);
9507
9508   return build_cplus_array_type (type, itype);
9509 }
9510
9511 /* Check that it's OK to declare a function with the indicated TYPE.
9512    SFK indicates the kind of special function (if any) that this
9513    function is.  OPTYPE is the type given in a conversion operator
9514    declaration.  Returns the actual return type of the function; that
9515    may be different than TYPE if an error occurs, or for certain
9516    special functions.  */
9517
9518 static tree
9519 check_special_function_return_type (sfk, type, optype)
9520      special_function_kind sfk;
9521      tree type;
9522      tree optype;
9523 {
9524   switch (sfk)
9525     {
9526     case sfk_constructor:
9527       if (type)
9528         error ("return type specification for constructor invalid");
9529
9530       type = void_type_node;
9531       break;
9532
9533     case sfk_destructor:
9534       if (type)
9535         error ("return type specification for destructor invalid");
9536       type = void_type_node;
9537       break;
9538
9539     case sfk_conversion:
9540       if (type && !same_type_p (type, optype))
9541         error ("operator `%T' declared to return `%T'", optype, type);
9542       else if (type)
9543         pedwarn ("return type specified for `operator %T'",  optype);
9544       type = optype;
9545       break;
9546
9547     default:
9548       abort ();
9549       break;
9550     }
9551
9552   return type;
9553 }
9554
9555 /* Given declspecs and a declarator,
9556    determine the name and type of the object declared
9557    and construct a ..._DECL node for it.
9558    (In one case we can return a ..._TYPE node instead.
9559     For invalid input we sometimes return 0.)
9560
9561    DECLSPECS is a chain of tree_list nodes whose value fields
9562     are the storage classes and type specifiers.
9563
9564    DECL_CONTEXT says which syntactic context this declaration is in:
9565      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9566      FUNCDEF for a function definition.  Like NORMAL but a few different
9567       error messages in each case.  Return value may be zero meaning
9568       this definition is too screwy to try to parse.
9569      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9570       handle member functions (which have FIELD context).
9571       Return value may be zero meaning this definition is too screwy to
9572       try to parse.
9573      PARM for a parameter declaration (either within a function prototype
9574       or before a function body).  Make a PARM_DECL, or return void_type_node.
9575      CATCHPARM for a parameter declaration before a catch clause.
9576      TYPENAME if for a typename (in a cast or sizeof).
9577       Don't make a DECL node; just return the ..._TYPE node.
9578      FIELD for a struct or union field; make a FIELD_DECL.
9579      BITFIELD for a field with specified width.
9580    INITIALIZED is 1 if the decl has an initializer.
9581
9582    ATTRLIST is a pointer to the list of attributes, which may be NULL
9583    if there are none; *ATTRLIST may be modified if attributes from inside
9584    the declarator should be applied to the declaration.
9585
9586    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9587    It may also be so in the PARM case, for a prototype where the
9588    argument type is specified but not the name.
9589
9590    This function is where the complicated C meanings of `static'
9591    and `extern' are interpreted.
9592
9593    For C++, if there is any monkey business to do, the function which
9594    calls this one must do it, i.e., prepending instance variables,
9595    renaming overloaded function names, etc.
9596
9597    Note that for this C++, it is an error to define a method within a class
9598    which does not belong to that class.
9599
9600    Except in the case where SCOPE_REFs are implicitly known (such as
9601    methods within a class being redundantly qualified),
9602    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9603    (class_name::decl_name).  The caller must also deal with this.
9604
9605    If a constructor or destructor is seen, and the context is FIELD,
9606    then the type gains the attribute TREE_HAS_x.  If such a declaration
9607    is erroneous, NULL_TREE is returned.
9608
9609    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9610    function, these are the qualifiers to give to the `this' pointer. We
9611    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9612
9613    May return void_type_node if the declarator turned out to be a friend.
9614    See grokfield for details.  */
9615
9616 tree
9617 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9618      tree declspecs;
9619      tree declarator;
9620      enum decl_context decl_context;
9621      int initialized;
9622      tree *attrlist;
9623 {
9624   RID_BIT_TYPE specbits;
9625   int nclasses = 0;
9626   tree spec;
9627   tree type = NULL_TREE;
9628   int longlong = 0;
9629   int constp;
9630   int restrictp;
9631   int volatilep;
9632   int type_quals;
9633   int virtualp, explicitp, friendp, inlinep, staticp;
9634   int explicit_int = 0;
9635   int explicit_char = 0;
9636   int defaulted_int = 0;
9637   int extern_langp = 0;
9638
9639   tree typedef_decl = NULL_TREE;
9640   const char *name;
9641   tree typedef_type = NULL_TREE;
9642   int funcdef_flag = 0;
9643   enum tree_code innermost_code = ERROR_MARK;
9644   int bitfield = 0;
9645 #if 0
9646   /* See the code below that used this.  */
9647   tree decl_attr = NULL_TREE;
9648 #endif
9649   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9650      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9651   tree init = NULL_TREE;
9652
9653   /* Keep track of what sort of function is being processed
9654      so that we can warn about default return values, or explicit
9655      return values which do not match prescribed defaults.  */
9656   special_function_kind sfk = sfk_none;
9657
9658   tree dname = NULL_TREE;
9659   tree ctype = current_class_type;
9660   tree ctor_return_type = NULL_TREE;
9661   enum overload_flags flags = NO_SPECIAL;
9662   tree quals = NULL_TREE;
9663   tree raises = NULL_TREE;
9664   int template_count = 0;
9665   tree in_namespace = NULL_TREE;
9666   tree returned_attrs = NULL_TREE;
9667
9668   RIDBIT_RESET_ALL (specbits);
9669   if (decl_context == FUNCDEF)
9670     funcdef_flag = 1, decl_context = NORMAL;
9671   else if (decl_context == MEMFUNCDEF)
9672     funcdef_flag = -1, decl_context = FIELD;
9673   else if (decl_context == BITFIELD)
9674     bitfield = 1, decl_context = FIELD;
9675
9676   /* Look inside a declarator for the name being declared
9677      and get it as a string, for an error message.  */
9678   {
9679     tree *next = &declarator;
9680     register tree decl;
9681     name = NULL;
9682
9683     while (next && *next)
9684       {
9685         decl = *next;
9686         switch (TREE_CODE (decl))
9687           {
9688           case TREE_LIST:
9689             /* For attributes.  */
9690             next = &TREE_VALUE (decl);
9691             break;
9692
9693           case COND_EXPR:
9694             ctype = NULL_TREE;
9695             next = &TREE_OPERAND (decl, 0);
9696             break;
9697
9698           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9699             {
9700               tree name = TREE_OPERAND (decl, 0);
9701               tree rename = NULL_TREE;
9702
9703               my_friendly_assert (flags == NO_SPECIAL, 152);
9704               flags = DTOR_FLAG;
9705               sfk = sfk_destructor;
9706               if (TREE_CODE (name) == TYPE_DECL)
9707                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9708               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9709               if (ctype == NULL_TREE)
9710                 {
9711                   if (current_class_type == NULL_TREE)
9712                     {
9713                       error ("destructors must be member functions");
9714                       flags = NO_SPECIAL;
9715                     }
9716                   else
9717                     {
9718                       tree t = constructor_name (current_class_name);
9719                       if (t != name)
9720                         rename = t;
9721                     }
9722                 }
9723               else
9724                 {
9725                   tree t = constructor_name (ctype);
9726                   if (t != name)
9727                     rename = t;
9728                 }
9729
9730               if (rename)
9731                 {
9732                   error ("destructor `%T' must match class name `%T'",
9733                             name, rename);
9734                   TREE_OPERAND (decl, 0) = rename;
9735                 }
9736               next = &name;
9737             }
9738             break;
9739
9740           case ADDR_EXPR:       /* C++ reference declaration */
9741             /* Fall through. */
9742           case ARRAY_REF:
9743           case INDIRECT_REF:
9744             ctype = NULL_TREE;
9745             innermost_code = TREE_CODE (decl);
9746             next = &TREE_OPERAND (decl, 0);
9747             break;
9748
9749           case CALL_EXPR:
9750             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9751               {
9752                 /* This is actually a variable declaration using
9753                    constructor syntax.  We need to call start_decl and
9754                    cp_finish_decl so we can get the variable
9755                    initialized...  */
9756
9757                 tree attributes;
9758
9759                 *next = TREE_OPERAND (decl, 0);
9760                 init = CALL_DECLARATOR_PARMS (decl);
9761
9762                 if (attrlist)
9763                   {
9764                     attributes = *attrlist;
9765                   }
9766                 else
9767                   {
9768                     attributes = NULL_TREE;
9769                   }
9770
9771                 decl = start_decl (declarator, declspecs, 1,
9772                                    attributes, NULL_TREE);
9773                 decl_type_access_control (decl);
9774                 if (decl)
9775                   {
9776                     /* Look for __unused__ attribute */
9777                     if (TREE_USED (TREE_TYPE (decl)))
9778                       TREE_USED (decl) = 1;
9779                     finish_decl (decl, init, NULL_TREE);
9780                   }
9781                 else
9782                   error ("invalid declarator");
9783                 return 0;
9784               }
9785             innermost_code = TREE_CODE (decl);
9786             if (decl_context == FIELD && ctype == NULL_TREE)
9787               ctype = current_class_type;
9788             if (ctype
9789                 && TREE_OPERAND (decl, 0)
9790                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9791                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9792                          == constructor_name_full (ctype))
9793                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9794                             == constructor_name (ctype)))))
9795               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9796             next = &TREE_OPERAND (decl, 0);
9797             decl = *next;
9798             if (ctype != NULL_TREE
9799                 && decl != NULL_TREE && flags != DTOR_FLAG
9800                 && decl == constructor_name (ctype))
9801               {
9802                 sfk = sfk_constructor;
9803                 ctor_return_type = ctype;
9804               }
9805             ctype = NULL_TREE;
9806             break;
9807
9808           case TEMPLATE_ID_EXPR:
9809               {
9810                 tree fns = TREE_OPERAND (decl, 0);
9811
9812                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9813                   fns = TREE_OPERAND (fns, 0);
9814
9815                 dname = fns;
9816                 if (TREE_CODE (dname) == COMPONENT_REF)
9817                   dname = TREE_OPERAND (dname, 1);
9818                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9819                   {
9820                     my_friendly_assert (is_overloaded_fn (dname),
9821                                         19990331);
9822                     dname = DECL_NAME (get_first_fn (dname));
9823                   }
9824               }
9825           /* Fall through. */
9826
9827           case IDENTIFIER_NODE:
9828             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9829               dname = decl;
9830
9831             next = 0;
9832
9833             if (C_IS_RESERVED_WORD (dname))
9834               {
9835                 error ("declarator-id missing; using reserved word `%D'",
9836                           dname);
9837                 name = IDENTIFIER_POINTER (dname);
9838               }
9839             else if (!IDENTIFIER_TYPENAME_P (dname))
9840               name = IDENTIFIER_POINTER (dname);
9841             else
9842               {
9843                 my_friendly_assert (flags == NO_SPECIAL, 154);
9844                 flags = TYPENAME_FLAG;
9845                 ctor_return_type = TREE_TYPE (dname);
9846                 sfk = sfk_conversion;
9847                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9848                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9849                         == TYPE_DECL))
9850                   name = IDENTIFIER_POINTER (dname);
9851                 else
9852                   name = "<invalid operator>";
9853               }
9854             break;
9855
9856             /* C++ extension */
9857           case SCOPE_REF:
9858             {
9859               /* Perform error checking, and decide on a ctype.  */
9860               tree cname = TREE_OPERAND (decl, 0);
9861               if (cname == NULL_TREE)
9862                 ctype = NULL_TREE;
9863               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9864                 {
9865                   ctype = NULL_TREE;
9866                   in_namespace = TREE_OPERAND (decl, 0);
9867                   TREE_OPERAND (decl, 0) = NULL_TREE;
9868                 }
9869               else if (! is_aggr_type (cname, 1))
9870                 TREE_OPERAND (decl, 0) = NULL_TREE;
9871               /* Must test TREE_OPERAND (decl, 1), in case user gives
9872                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9873               else if (TREE_OPERAND (decl, 1)
9874                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9875                 ctype = cname;
9876               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9877                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9878                 {
9879                   error ("`%T::%D' is not a valid declarator", cname,
9880                             TREE_OPERAND (decl, 1));
9881                   error ("  perhaps you want `typename %T::%D' to make it a type",
9882                             cname, TREE_OPERAND (decl, 1));
9883                   return void_type_node;
9884                 }
9885               else if (ctype == NULL_TREE)
9886                 ctype = cname;
9887               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9888                 TREE_OPERAND (decl, 0) = ctype;
9889               else
9890                 {
9891                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9892                     {
9893                       error ("type `%T' is not derived from type `%T'",
9894                                 cname, ctype);
9895                       TREE_OPERAND (decl, 0) = NULL_TREE;
9896                     }
9897                   else
9898                     ctype = cname;
9899                 }
9900
9901               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9902                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9903                        == constructor_name_full (ctype))
9904                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9905                           == constructor_name (ctype))))
9906                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9907               next = &TREE_OPERAND (decl, 1);
9908               decl = *next;
9909               if (ctype)
9910                 {
9911                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9912                       && constructor_name (ctype) == decl)
9913                     {
9914                       sfk = sfk_constructor;
9915                       ctor_return_type = ctype;
9916                     }
9917                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9918                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9919                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9920                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9921                     {
9922                       sfk = sfk_destructor;
9923                       ctor_return_type = ctype;
9924                       flags = DTOR_FLAG;
9925                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9926                       next = &TREE_OPERAND (decl, 0);
9927                     }
9928                 }
9929             }
9930             break;
9931
9932           case ERROR_MARK:
9933             next = 0;
9934             break;
9935
9936           case TYPE_DECL:
9937             /* Parse error puts this typespec where
9938                a declarator should go.  */
9939             error ("`%T' specified as declarator-id", DECL_NAME (decl));
9940             if (TREE_TYPE (decl) == current_class_type)
9941               error ("  perhaps you want `%T' for a constructor",
9942                         current_class_name);
9943             dname = DECL_NAME (decl);
9944             name = IDENTIFIER_POINTER (dname);
9945
9946             /* Avoid giving two errors for this.  */
9947             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9948
9949             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9950             *next = dname;
9951             next = 0;
9952             break;
9953
9954           default:
9955             internal_error ("`%D' as declarator", decl);
9956           }
9957       }
9958   }
9959
9960   /* A function definition's declarator must have the form of
9961      a function declarator.  */
9962
9963   if (funcdef_flag && innermost_code != CALL_EXPR)
9964     return 0;
9965
9966   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9967       && innermost_code != CALL_EXPR
9968       && ! (ctype && declspecs == NULL_TREE))
9969     {
9970       error ("declaration of `%D' as non-function", dname);
9971       return void_type_node;
9972     }
9973
9974   /* Anything declared one level down from the top level
9975      must be one of the parameters of a function
9976      (because the body is at least two levels down).  */
9977
9978   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9979      by not allowing C++ class definitions to specify their parameters
9980      with xdecls (must be spec.d in the parmlist).
9981
9982      Since we now wait to push a class scope until we are sure that
9983      we are in a legitimate method context, we must set oldcname
9984      explicitly (since current_class_name is not yet alive).
9985
9986      We also want to avoid calling this a PARM if it is in a namespace.  */
9987
9988   if (decl_context == NORMAL && !toplevel_bindings_p ())
9989     {
9990       struct binding_level *b = current_binding_level;
9991       current_binding_level = b->level_chain;
9992       if (current_binding_level != 0 && toplevel_bindings_p ())
9993         decl_context = PARM;
9994       current_binding_level = b;
9995     }
9996
9997   if (name == NULL)
9998     name = decl_context == PARM ? "parameter" : "type name";
9999
10000   /* Look through the decl specs and record which ones appear.
10001      Some typespecs are defined as built-in typenames.
10002      Others, the ones that are modifiers of other types,
10003      are represented by bits in SPECBITS: set the bits for
10004      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10005
10006      If there is a typedef name or a type, store the type in TYPE.
10007      This includes builtin typedefs such as `int'.
10008
10009      Set EXPLICIT_INT if the type is `int' or `char' and did not
10010      come from a user typedef.
10011
10012      Set LONGLONG if `long' is mentioned twice.
10013
10014      For C++, constructors and destructors have their own fast treatment.  */
10015
10016   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10017     {
10018       register int i;
10019       register tree id;
10020
10021       /* Certain parse errors slip through.  For example,
10022          `int class;' is not caught by the parser. Try
10023          weakly to recover here.  */
10024       if (TREE_CODE (spec) != TREE_LIST)
10025         return 0;
10026
10027       id = TREE_VALUE (spec);
10028
10029       /* If the entire declaration is itself tagged as deprecated then
10030          suppress reports of deprecated items.  */
10031       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10032         {
10033           if (deprecated_state != DEPRECATED_SUPPRESS)
10034             warn_deprecated_use (id);
10035         }
10036
10037       if (TREE_CODE (id) == IDENTIFIER_NODE)
10038         {
10039           if (id == ridpointers[(int) RID_INT]
10040               || id == ridpointers[(int) RID_CHAR]
10041               || id == ridpointers[(int) RID_BOOL]
10042               || id == ridpointers[(int) RID_WCHAR])
10043             {
10044               if (type)
10045                 {
10046                   if (id == ridpointers[(int) RID_BOOL])
10047                     error ("`bool' is now a keyword");
10048                   else
10049                     error ("extraneous `%T' ignored", id);
10050                 }
10051               else
10052                 {
10053                   if (id == ridpointers[(int) RID_INT])
10054                     explicit_int = 1;
10055                   else if (id == ridpointers[(int) RID_CHAR])
10056                     explicit_char = 1;
10057                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10058                 }
10059               goto found;
10060             }
10061           /* C++ aggregate types.  */
10062           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10063             {
10064               if (type)
10065                 error ("multiple declarations `%T' and `%T'", type, id);
10066               else
10067                 type = IDENTIFIER_TYPE_VALUE (id);
10068               goto found;
10069             }
10070
10071           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10072             {
10073               if (ridpointers[i] == id)
10074                 {
10075                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10076                     {
10077                       if (pedantic && ! in_system_header && warn_long_long)
10078                         pedwarn ("ISO C++ does not support `long long'");
10079                       if (longlong)
10080                         error ("`long long long' is too long for GCC");
10081                       else
10082                         longlong = 1;
10083                     }
10084                   else if (RIDBIT_SETP (i, specbits))
10085                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10086                   if (i == (int)RID_EXTERN
10087                       && TREE_PURPOSE (spec) == error_mark_node)
10088                     /* This extern was part of a language linkage.  */
10089                     extern_langp = 1;
10090                   RIDBIT_SET (i, specbits);
10091                   goto found;
10092                 }
10093             }
10094         }
10095       /* C++ aggregate types.  */
10096       else if (TREE_CODE (id) == TYPE_DECL)
10097         {
10098           if (type)
10099             error ("multiple declarations `%T' and `%T'", type,
10100                       TREE_TYPE (id));
10101           else
10102             {
10103               type = TREE_TYPE (id);
10104               TREE_VALUE (spec) = type;
10105             }
10106           goto found;
10107         }
10108       if (type)
10109         error ("two or more data types in declaration of `%s'", name);
10110       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10111         {
10112           register tree t = lookup_name (id, 1);
10113           if (!t || TREE_CODE (t) != TYPE_DECL)
10114             error ("`%s' fails to be a typedef or built in type",
10115                    IDENTIFIER_POINTER (id));
10116           else
10117             {
10118               type = TREE_TYPE (t);
10119 #if 0
10120               /* See the code below that used this.  */
10121               decl_attr = DECL_ATTRIBUTES (id);
10122 #endif
10123               typedef_decl = t;
10124             }
10125         }
10126       else if (id != error_mark_node)
10127         /* Can't change CLASS nodes into RECORD nodes here!  */
10128         type = id;
10129
10130     found: ;
10131     }
10132
10133   typedef_type = type;
10134
10135   /* No type at all: default to `int', and set DEFAULTED_INT
10136      because it was not a user-defined typedef.  */
10137
10138   if (type == NULL_TREE
10139       && (RIDBIT_SETP (RID_SIGNED, specbits)
10140           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10141           || RIDBIT_SETP (RID_LONG, specbits)
10142           || RIDBIT_SETP (RID_SHORT, specbits)))
10143     {
10144       /* These imply 'int'.  */
10145       type = integer_type_node;
10146       defaulted_int = 1;
10147     }
10148
10149   if (sfk != sfk_none)
10150     type = check_special_function_return_type (sfk, type,
10151                                                ctor_return_type);
10152   else if (type == NULL_TREE)
10153     {
10154       int is_main;
10155
10156       explicit_int = -1;
10157
10158       /* We handle `main' specially here, because 'main () { }' is so
10159          common.  With no options, it is allowed.  With -Wreturn-type,
10160          it is a warning.  It is only an error with -pedantic-errors.  */
10161       is_main = (funcdef_flag
10162                  && dname && MAIN_NAME_P (dname)
10163                  && ctype == NULL_TREE
10164                  && in_namespace == NULL_TREE
10165                  && current_namespace == global_namespace);
10166
10167       if (in_system_header || flag_ms_extensions)
10168         /* Allow it, sigh.  */;
10169       else if (pedantic || ! is_main)
10170         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10171                     name);
10172       else if (warn_return_type)
10173         warning ("ISO C++ forbids declaration of `%s' with no type",
10174                     name);
10175
10176       type = integer_type_node;
10177     }
10178
10179   if (type && TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
10180     {
10181       /* The implicit typename extension is deprecated and will be
10182          removed.  Warn about its use now.  */
10183       warning ("`%T' is implicitly a typename", type);
10184       cp_deprecated ("implicit typename");
10185
10186       /* Now remove its implicitness, so that we don't warn again.
10187          For instance this might be a typedef, and we do not want to
10188          warn on uses of the typedef itself.  Simply clearing the
10189          TREE_TYPE is insufficient.  */
10190       type = copy_node (type);
10191       TREE_TYPE (type) = NULL_TREE;
10192     }
10193
10194   ctype = NULL_TREE;
10195
10196   /* Now process the modifiers that were specified
10197      and check for invalid combinations.  */
10198
10199   /* Long double is a special combination.  */
10200
10201   if (RIDBIT_SETP (RID_LONG, specbits)
10202       && TYPE_MAIN_VARIANT (type) == double_type_node)
10203     {
10204       RIDBIT_RESET (RID_LONG, specbits);
10205       type = build_qualified_type (long_double_type_node,
10206                                    cp_type_quals (type));
10207     }
10208
10209   /* Check all other uses of type modifiers.  */
10210
10211   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10212       || RIDBIT_SETP (RID_SIGNED, specbits)
10213       || RIDBIT_SETP (RID_LONG, specbits)
10214       || RIDBIT_SETP (RID_SHORT, specbits))
10215     {
10216       int ok = 0;
10217
10218       if (TREE_CODE (type) == REAL_TYPE)
10219         error ("short, signed or unsigned invalid for `%s'", name);
10220       else if (TREE_CODE (type) != INTEGER_TYPE)
10221         error ("long, short, signed or unsigned invalid for `%s'", name);
10222       else if (RIDBIT_SETP (RID_LONG, specbits)
10223                && RIDBIT_SETP (RID_SHORT, specbits))
10224         error ("long and short specified together for `%s'", name);
10225       else if ((RIDBIT_SETP (RID_LONG, specbits)
10226                 || RIDBIT_SETP (RID_SHORT, specbits))
10227                && explicit_char)
10228         error ("long or short specified with char for `%s'", name);
10229       else if ((RIDBIT_SETP (RID_LONG, specbits)
10230                 || RIDBIT_SETP (RID_SHORT, specbits))
10231                && TREE_CODE (type) == REAL_TYPE)
10232         error ("long or short specified with floating type for `%s'", name);
10233       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10234                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10235         error ("signed and unsigned given together for `%s'", name);
10236       else
10237         {
10238           ok = 1;
10239           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10240             {
10241               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10242                        name);
10243               if (flag_pedantic_errors)
10244                 ok = 0;
10245             }
10246         }
10247
10248       /* Discard the type modifiers if they are invalid.  */
10249       if (! ok)
10250         {
10251           RIDBIT_RESET (RID_UNSIGNED, specbits);
10252           RIDBIT_RESET (RID_SIGNED, specbits);
10253           RIDBIT_RESET (RID_LONG, specbits);
10254           RIDBIT_RESET (RID_SHORT, specbits);
10255           longlong = 0;
10256         }
10257     }
10258
10259   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10260       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10261     {
10262       error ("complex invalid for `%s'", name);
10263       RIDBIT_RESET (RID_COMPLEX, specbits);
10264     }
10265
10266   /* Decide whether an integer type is signed or not.
10267      Optionally treat bitfields as signed by default.  */
10268   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10269       /* [class.bit]
10270
10271          It is implementation-defined whether a plain (neither
10272          explicitly signed or unsigned) char, short, int, or long
10273          bit-field is signed or unsigned.
10274
10275          Naturally, we extend this to long long as well.  Note that
10276          this does not include wchar_t.  */
10277       || (bitfield && !flag_signed_bitfields
10278           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10279           /* A typedef for plain `int' without `signed' can be
10280              controlled just like plain `int', but a typedef for
10281              `signed int' cannot be so controlled.  */
10282           && !(typedef_decl
10283                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10284           && (TREE_CODE (type) == INTEGER_TYPE
10285               || TREE_CODE (type) == CHAR_TYPE)
10286           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10287     {
10288       if (longlong)
10289         type = long_long_unsigned_type_node;
10290       else if (RIDBIT_SETP (RID_LONG, specbits))
10291         type = long_unsigned_type_node;
10292       else if (RIDBIT_SETP (RID_SHORT, specbits))
10293         type = short_unsigned_type_node;
10294       else if (type == char_type_node)
10295         type = unsigned_char_type_node;
10296       else if (typedef_decl)
10297         type = unsigned_type (type);
10298       else
10299         type = unsigned_type_node;
10300     }
10301   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10302            && type == char_type_node)
10303     type = signed_char_type_node;
10304   else if (longlong)
10305     type = long_long_integer_type_node;
10306   else if (RIDBIT_SETP (RID_LONG, specbits))
10307     type = long_integer_type_node;
10308   else if (RIDBIT_SETP (RID_SHORT, specbits))
10309     type = short_integer_type_node;
10310
10311   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10312     {
10313       /* If we just have "complex", it is equivalent to
10314          "complex double", but if any modifiers at all are specified it is
10315          the complex form of TYPE.  E.g, "complex short" is
10316          "complex short int".  */
10317
10318       if (defaulted_int && ! longlong
10319           && ! (RIDBIT_SETP (RID_LONG, specbits)
10320                 || RIDBIT_SETP (RID_SHORT, specbits)
10321                 || RIDBIT_SETP (RID_SIGNED, specbits)
10322                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10323         type = complex_double_type_node;
10324       else if (type == integer_type_node)
10325         type = complex_integer_type_node;
10326       else if (type == float_type_node)
10327         type = complex_float_type_node;
10328       else if (type == double_type_node)
10329         type = complex_double_type_node;
10330       else if (type == long_double_type_node)
10331         type = complex_long_double_type_node;
10332       else
10333         type = build_complex_type (type);
10334     }
10335
10336   if (sfk == sfk_conversion
10337       && (RIDBIT_SETP (RID_CONST, specbits)
10338           || RIDBIT_SETP (RID_VOLATILE, specbits)
10339           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10340     error ("qualifiers are not allowed on declaration of `operator %T'",
10341               ctor_return_type);
10342
10343   /* Set CONSTP if this declaration is `const', whether by
10344      explicit specification or via a typedef.
10345      Likewise for VOLATILEP.  */
10346
10347   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10348   restrictp =
10349     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10350   volatilep =
10351     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10352   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10353                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10354                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10355   type = cp_build_qualified_type (type, type_quals);
10356   staticp = 0;
10357   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10358   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10359   RIDBIT_RESET (RID_VIRTUAL, specbits);
10360   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10361   RIDBIT_RESET (RID_EXPLICIT, specbits);
10362
10363   if (RIDBIT_SETP (RID_STATIC, specbits))
10364     staticp = 1 + (decl_context == FIELD);
10365
10366   if (virtualp && staticp == 2)
10367     {
10368       error ("member `%D' cannot be declared both virtual and static",
10369                 dname);
10370       staticp = 0;
10371     }
10372   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10373   RIDBIT_RESET (RID_FRIEND, specbits);
10374
10375   /* Warn if two storage classes are given. Default to `auto'.  */
10376
10377   if (RIDBIT_ANY_SET (specbits))
10378     {
10379       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10380       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10381       if (decl_context == PARM && nclasses > 0)
10382         error ("storage class specifiers invalid in parameter declarations");
10383       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10384         {
10385           if (decl_context == PARM)
10386             error ("typedef declaration invalid in parameter declaration");
10387           nclasses++;
10388         }
10389       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10390       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10391       if (!nclasses && !friendp && extern_langp)
10392         nclasses++;
10393     }
10394
10395   /* Give error if `virtual' is used outside of class declaration.  */
10396   if (virtualp
10397       && (current_class_name == NULL_TREE || decl_context != FIELD))
10398     {
10399       error ("virtual outside class declaration");
10400       virtualp = 0;
10401     }
10402
10403   /* Static anonymous unions are dealt with here.  */
10404   if (staticp && decl_context == TYPENAME
10405       && TREE_CODE (declspecs) == TREE_LIST
10406       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10407     decl_context = FIELD;
10408
10409   /* Warn about storage classes that are invalid for certain
10410      kinds of declarations (parameters, typenames, etc.).  */
10411
10412   if (nclasses > 1)
10413     error ("multiple storage classes in declaration of `%s'", name);
10414   else if (decl_context != NORMAL && nclasses > 0)
10415     {
10416       if ((decl_context == PARM || decl_context == CATCHPARM)
10417           && (RIDBIT_SETP (RID_REGISTER, specbits)
10418               || RIDBIT_SETP (RID_AUTO, specbits)))
10419         ;
10420       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10421         ;
10422       else if (decl_context == FIELD
10423                /* C++ allows static class elements  */
10424                && RIDBIT_SETP (RID_STATIC, specbits))
10425         /* C++ also allows inlines and signed and unsigned elements,
10426            but in those cases we don't come in here.  */
10427         ;
10428       else
10429         {
10430           if (decl_context == FIELD)
10431             {
10432               tree tmp = NULL_TREE;
10433               register int op = 0;
10434
10435               if (declarator)
10436                 {
10437                   /* Avoid trying to get an operand off an identifier node.  */
10438                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10439                     tmp = declarator;
10440                   else
10441                     tmp = TREE_OPERAND (declarator, 0);
10442                   op = IDENTIFIER_OPNAME_P (tmp);
10443                   if (IDENTIFIER_TYPENAME_P (tmp))
10444                     {
10445                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10446                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10447                               == TYPE_DECL))
10448                         name = IDENTIFIER_POINTER (tmp);
10449                       else
10450                         name = "<invalid operator>";
10451                     }
10452                 }
10453               error ("storage class specified for %s `%s'",
10454                      op ? "member operator" : "field",
10455                      name);
10456             }
10457           else
10458             {
10459               if (decl_context == PARM || decl_context == CATCHPARM)
10460                 error ("storage class specified for parameter `%s'", name);
10461               else
10462                 error ("storage class specified for typename");
10463             }
10464           RIDBIT_RESET (RID_REGISTER, specbits);
10465           RIDBIT_RESET (RID_AUTO, specbits);
10466           RIDBIT_RESET (RID_EXTERN, specbits);
10467         }
10468     }
10469   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10470     {
10471       if (toplevel_bindings_p ())
10472         {
10473           /* It's common practice (and completely valid) to have a const
10474              be initialized and declared extern.  */
10475           if (!(type_quals & TYPE_QUAL_CONST))
10476             warning ("`%s' initialized and declared `extern'", name);
10477         }
10478       else
10479         error ("`%s' has both `extern' and initializer", name);
10480     }
10481   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10482            && ! toplevel_bindings_p ())
10483     error ("nested function `%s' declared `extern'", name);
10484   else if (toplevel_bindings_p ())
10485     {
10486       if (RIDBIT_SETP (RID_AUTO, specbits))
10487         error ("top-level declaration of `%s' specifies `auto'", name);
10488     }
10489
10490   if (nclasses > 0 && friendp)
10491     error ("storage class specifiers invalid in friend function declarations");
10492
10493   /* Now figure out the structure of the declarator proper.
10494      Descend through it, creating more complex types, until we reach
10495      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10496
10497   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10498          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10499     {
10500       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10501          an INDIRECT_REF (for *...),
10502          a CALL_EXPR (for ...(...)),
10503          an identifier (for the name being declared)
10504          or a null pointer (for the place in an absolute declarator
10505          where the name was omitted).
10506          For the last two cases, we have just exited the loop.
10507
10508          For C++ it could also be
10509          a SCOPE_REF (for class :: ...).  In this case, we have converted
10510          sensible names to types, and those are the values we use to
10511          qualify the member name.
10512          an ADDR_EXPR (for &...),
10513          a BIT_NOT_EXPR (for destructors)
10514
10515          At this point, TYPE is the type of elements of an array,
10516          or for a function to return, or for a pointer to point to.
10517          After this sequence of ifs, TYPE is the type of the
10518          array or function or pointer, and DECLARATOR has had its
10519          outermost layer removed.  */
10520
10521       if (type == error_mark_node)
10522         {
10523           if (TREE_CODE (declarator) == SCOPE_REF)
10524             declarator = TREE_OPERAND (declarator, 1);
10525           else
10526             declarator = TREE_OPERAND (declarator, 0);
10527           continue;
10528         }
10529       if (quals != NULL_TREE
10530           && (declarator == NULL_TREE
10531               || TREE_CODE (declarator) != SCOPE_REF))
10532         {
10533           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10534             ctype = TYPE_METHOD_BASETYPE (type);
10535           if (ctype != NULL_TREE)
10536             {
10537               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10538               grok_method_quals (ctype, dummy, quals);
10539               type = TREE_TYPE (dummy);
10540               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10541               quals = NULL_TREE;
10542             }
10543         }
10544
10545       switch (TREE_CODE (declarator))
10546         {
10547         case TREE_LIST:
10548           {
10549             /* We encode a declarator with embedded attributes using
10550                a TREE_LIST.  */
10551             tree attrs = TREE_PURPOSE (declarator);
10552             tree inner_decl;
10553             int attr_flags;
10554
10555             declarator = TREE_VALUE (declarator);
10556             inner_decl = declarator;
10557             while (inner_decl != NULL_TREE
10558                    && TREE_CODE (inner_decl) == TREE_LIST)
10559               inner_decl = TREE_VALUE (inner_decl);
10560             attr_flags = 0;
10561             if (inner_decl == NULL_TREE
10562                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10563               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10564             if (TREE_CODE (inner_decl) == CALL_EXPR)
10565               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10566             if (TREE_CODE (inner_decl) == ARRAY_REF)
10567               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10568             returned_attrs = decl_attributes (&type,
10569                                               chainon (returned_attrs, attrs),
10570                                               attr_flags);
10571           }
10572           break;
10573
10574         case ARRAY_REF:
10575           {
10576             register tree size;
10577
10578             size = TREE_OPERAND (declarator, 1);
10579
10580             /* VC++ spells a zero-sized array with [].  */
10581             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10582                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10583               size = integer_zero_node;
10584
10585             declarator = TREE_OPERAND (declarator, 0);
10586
10587             type = create_array_type_for_decl (dname, type, size);
10588
10589             /* VLAs never work as fields. */
10590             if (decl_context == FIELD && !processing_template_decl
10591                 && TREE_CODE (type) == ARRAY_TYPE
10592                 && TYPE_DOMAIN (type) != NULL_TREE
10593                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10594               {
10595                 error ("size of member `%D' is not constant", dname);
10596                 /* Proceed with arbitrary constant size, so that offset
10597                    computations don't get confused. */
10598                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10599                                                    integer_one_node);
10600               }
10601
10602             ctype = NULL_TREE;
10603           }
10604           break;
10605
10606         case CALL_EXPR:
10607           {
10608             tree arg_types;
10609             int funcdecl_p;
10610             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10611             tree inner_decl = TREE_OPERAND (declarator, 0);
10612
10613             /* Declaring a function type.
10614                Make sure we have a valid type for the function to return.  */
10615
10616             /* We now know that the TYPE_QUALS don't apply to the
10617                decl, but to its return type.  */
10618             type_quals = TYPE_UNQUALIFIED;
10619
10620             /* Warn about some types functions can't return.  */
10621
10622             if (TREE_CODE (type) == FUNCTION_TYPE)
10623               {
10624                 error ("`%s' declared as function returning a function", name);
10625                 type = integer_type_node;
10626               }
10627             if (TREE_CODE (type) == ARRAY_TYPE)
10628               {
10629                 error ("`%s' declared as function returning an array", name);
10630                 type = integer_type_node;
10631               }
10632
10633             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10634               inner_decl = TREE_OPERAND (inner_decl, 1);
10635
10636             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10637               inner_decl = dname;
10638
10639             /* Pick up type qualifiers which should be applied to `this'.  */
10640             quals = CALL_DECLARATOR_QUALS (declarator);
10641
10642             /* Pick up the exception specifications.  */
10643             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10644
10645             /* Say it's a definition only for the CALL_EXPR
10646                closest to the identifier.  */
10647             funcdecl_p
10648               = inner_decl
10649               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10650                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10651                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10652
10653             if (ctype == NULL_TREE
10654                 && decl_context == FIELD
10655                 && funcdecl_p
10656                 && (friendp == 0 || dname == current_class_name))
10657               ctype = current_class_type;
10658
10659             if (ctype && sfk == sfk_conversion)
10660               TYPE_HAS_CONVERSION (ctype) = 1;
10661             if (ctype && constructor_name (ctype) == dname)
10662               {
10663                 /* We are within a class's scope. If our declarator name
10664                    is the same as the class name, and we are defining
10665                    a function, then it is a constructor/destructor, and
10666                    therefore returns a void type.  */
10667
10668                 if (flags == DTOR_FLAG)
10669                   {
10670                     /* ISO C++ 12.4/2.  A destructor may not be
10671                        declared const or volatile.  A destructor may
10672                        not be static.  */
10673                     if (staticp == 2)
10674                       error ("destructor cannot be static member function");
10675                     if (quals)
10676                       {
10677                         error ("destructors may not be `%s'",
10678                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10679                         quals = NULL_TREE;
10680                       }
10681                     if (decl_context == FIELD)
10682                       {
10683                         if (! member_function_or_else (ctype,
10684                                                        current_class_type,
10685                                                        flags))
10686                           return void_type_node;
10687                       }
10688                   }
10689                 else            /* It's a constructor.  */
10690                   {
10691                     if (explicitp == 1)
10692                       explicitp = 2;
10693                     /* ISO C++ 12.1.  A constructor may not be
10694                        declared const or volatile.  A constructor may
10695                        not be virtual.  A constructor may not be
10696                        static.  */
10697                     if (staticp == 2)
10698                       error ("constructor cannot be static member function");
10699                     if (virtualp)
10700                       {
10701                         pedwarn ("constructors cannot be declared virtual");
10702                         virtualp = 0;
10703                       }
10704                     if (quals)
10705                       {
10706                         error ("constructors may not be `%s'",
10707                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10708                         quals = NULL_TREE;
10709                       }
10710                     {
10711                       RID_BIT_TYPE tmp_bits;
10712                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10713                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10714                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10715                       if (RIDBIT_ANY_SET (tmp_bits))
10716                         error ("return value type specifier for constructor ignored");
10717                     }
10718                     if (decl_context == FIELD)
10719                       {
10720                         if (! member_function_or_else (ctype,
10721                                                        current_class_type,
10722                                                        flags))
10723                           return void_type_node;
10724                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10725                         if (sfk != sfk_constructor)
10726                           return NULL_TREE;
10727                       }
10728                   }
10729                 if (decl_context == FIELD)
10730                   staticp = 0;
10731               }
10732             else if (friendp)
10733               {
10734                 if (initialized)
10735                   error ("can't initialize friend function `%s'", name);
10736                 if (virtualp)
10737                   {
10738                     /* Cannot be both friend and virtual.  */
10739                     error ("virtual functions cannot be friends");
10740                     RIDBIT_RESET (RID_FRIEND, specbits);
10741                     friendp = 0;
10742                   }
10743                 if (decl_context == NORMAL)
10744                   error ("friend declaration not in class definition");
10745                 if (current_function_decl && funcdef_flag)
10746                   error ("can't define friend function `%s' in a local class definition",
10747                             name);
10748               }
10749
10750             /* Construct the function type and go to the next
10751                inner layer of declarator.  */
10752
10753             declarator = TREE_OPERAND (declarator, 0);
10754
10755             /* FIXME: This is where default args should be fully
10756                processed.  */
10757
10758             arg_types = grokparms (inner_parms);
10759
10760             if (declarator && flags == DTOR_FLAG)
10761               {
10762                 /* A destructor declared in the body of a class will
10763                    be represented as a BIT_NOT_EXPR.  But, we just
10764                    want the underlying IDENTIFIER.  */
10765                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10766                   declarator = TREE_OPERAND (declarator, 0);
10767
10768                 if (arg_types != void_list_node)
10769                   {
10770                     error ("destructors may not have parameters");
10771                     arg_types = void_list_node;
10772                     last_function_parms = NULL_TREE;
10773                   }
10774               }
10775
10776             /* ANSI says that `const int foo ();'
10777                does not make the function foo const.  */
10778             type = build_function_type (type, arg_types);
10779
10780             {
10781               tree t;
10782               for (t = arg_types; t; t = TREE_CHAIN (t))
10783                 if (TREE_PURPOSE (t)
10784                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10785                   {
10786                     add_defarg_fn (type);
10787                     break;
10788                   }
10789             }
10790           }
10791           break;
10792
10793         case ADDR_EXPR:
10794         case INDIRECT_REF:
10795           /* Filter out pointers-to-references and references-to-references.
10796              We can get these if a TYPE_DECL is used.  */
10797
10798           if (TREE_CODE (type) == REFERENCE_TYPE)
10799             {
10800               error ("cannot declare %s to references",
10801                      TREE_CODE (declarator) == ADDR_EXPR
10802                      ? "references" : "pointers");
10803               declarator = TREE_OPERAND (declarator, 0);
10804               continue;
10805             }
10806
10807           if (TREE_CODE (type) == OFFSET_TYPE
10808               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10809                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10810             {
10811               error ("cannot declare pointer to `%#T' member",
10812                         TREE_TYPE (type));
10813               type = TREE_TYPE (type);
10814             }
10815
10816           /* Merge any constancy or volatility into the target type
10817              for the pointer.  */
10818
10819           /* We now know that the TYPE_QUALS don't apply to the decl,
10820              but to the target of the pointer.  */
10821           type_quals = TYPE_UNQUALIFIED;
10822
10823           if (TREE_CODE (declarator) == ADDR_EXPR)
10824             {
10825               if (TREE_CODE (type) == VOID_TYPE)
10826                 error ("invalid type: `void &'");
10827               else
10828                 type = build_reference_type (type);
10829             }
10830           else if (TREE_CODE (type) == METHOD_TYPE)
10831             type = build_ptrmemfunc_type (build_pointer_type (type));
10832           else
10833             type = build_pointer_type (type);
10834
10835           /* Process a list of type modifier keywords (such as
10836              const or volatile) that were given inside the `*' or `&'.  */
10837
10838           if (TREE_TYPE (declarator))
10839             {
10840               register tree typemodlist;
10841               int erred = 0;
10842
10843               constp = 0;
10844               volatilep = 0;
10845               restrictp = 0;
10846               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10847                    typemodlist = TREE_CHAIN (typemodlist))
10848                 {
10849                   tree qualifier = TREE_VALUE (typemodlist);
10850
10851                   if (qualifier == ridpointers[(int) RID_CONST])
10852                     constp++;
10853                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10854                     volatilep++;
10855                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10856                     restrictp++;
10857                   else if (!erred)
10858                     {
10859                       erred = 1;
10860                       error ("invalid type modifier within pointer declarator");
10861                     }
10862                 }
10863               if (constp > 1)
10864                 pedwarn ("duplicate `const'");
10865               if (volatilep > 1)
10866                 pedwarn ("duplicate `volatile'");
10867               if (restrictp > 1)
10868                 pedwarn ("duplicate `restrict'");
10869
10870               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10871                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10872                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10873               if (TREE_CODE (declarator) == ADDR_EXPR
10874                   && (constp || volatilep))
10875                 {
10876                   if (constp)
10877                     pedwarn ("discarding `const' applied to a reference");
10878                   if (volatilep)
10879                     pedwarn ("discarding `volatile' applied to a reference");
10880                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10881                 }
10882               type = cp_build_qualified_type (type, type_quals);
10883             }
10884           declarator = TREE_OPERAND (declarator, 0);
10885           ctype = NULL_TREE;
10886           break;
10887
10888         case SCOPE_REF:
10889           {
10890             /* We have converted type names to NULL_TREE if the
10891                name was bogus, or to a _TYPE node, if not.
10892
10893                The variable CTYPE holds the type we will ultimately
10894                resolve to.  The code here just needs to build
10895                up appropriate member types.  */
10896             tree sname = TREE_OPERAND (declarator, 1);
10897             tree t;
10898
10899             /* Destructors can have their visibilities changed as well.  */
10900             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10901               sname = TREE_OPERAND (sname, 0);
10902
10903             if (TREE_COMPLEXITY (declarator) == 0)
10904               /* This needs to be here, in case we are called
10905                  multiple times.  */ ;
10906             else if (TREE_COMPLEXITY (declarator) == -1)
10907               /* Namespace member. */
10908               pop_decl_namespace ();
10909             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10910               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10911             else if (! IS_AGGR_TYPE_CODE
10912                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10913               ;
10914             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10915               {
10916                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10917                    that refer to ctype.  They couldn't be resolved earlier
10918                    because we hadn't pushed into the class yet.
10919                    Example: resolve 'B<T>::type' in
10920                    'B<typename B<T>::type> B<T>::f () { }'.  */
10921                 if (current_template_parms
10922                     && uses_template_parms (type)
10923                     && uses_template_parms (current_class_type))
10924                   {
10925                     tree args = current_template_args ();
10926                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10927                   }
10928
10929                 /* This pop_nested_class corresponds to the
10930                    push_nested_class used to push into class scope for
10931                    parsing the argument list of a function decl, in
10932                    qualified_id.  */
10933                 pop_nested_class ();
10934                 TREE_COMPLEXITY (declarator) = current_class_depth;
10935               }
10936             else
10937               abort ();
10938
10939             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10940               {
10941                 /* We had a reference to a global decl, or
10942                    perhaps we were given a non-aggregate typedef,
10943                    in which case we cleared this out, and should just
10944                    keep going as though it wasn't there.  */
10945                 declarator = sname;
10946                 continue;
10947               }
10948             ctype = TREE_OPERAND (declarator, 0);
10949
10950             t = ctype;
10951             while (t != NULL_TREE && CLASS_TYPE_P (t))
10952               {
10953                 /* You're supposed to have one `template <...>'
10954                    for every template class, but you don't need one
10955                    for a full specialization.  For example:
10956
10957                      template <class T> struct S{};
10958                      template <> struct S<int> { void f(); };
10959                      void S<int>::f () {}
10960
10961                    is correct; there shouldn't be a `template <>' for
10962                    the definition of `S<int>::f'.  */
10963                 if (CLASSTYPE_TEMPLATE_INFO (t)
10964                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10965                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10966                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10967                   template_count += 1;
10968
10969                 t = TYPE_MAIN_DECL (t);
10970                 t = DECL_CONTEXT (t);
10971               }
10972
10973             if (sname == NULL_TREE)
10974               goto done_scoping;
10975
10976             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10977               {
10978                 /* This is the `standard' use of the scoping operator:
10979                    basetype :: member .  */
10980
10981                 if (ctype == current_class_type)
10982                   {
10983                     /* class A {
10984                          void A::f ();
10985                        };
10986
10987                        Is this ill-formed?  */
10988
10989                     if (pedantic)
10990                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
10991                                   ctype, name);
10992                   }
10993                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10994                   {
10995                     if (current_class_type == NULL_TREE || friendp)
10996                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10997                                                       TYPE_ARG_TYPES (type));
10998                     else
10999                       {
11000                         error ("cannot declare member function `%T::%s' within `%T'",
11001                                   ctype, name, current_class_type);
11002                         return void_type_node;
11003                       }
11004                   }
11005                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11006                          || COMPLETE_TYPE_P (complete_type (ctype)))
11007                   {
11008                     /* Have to move this code elsewhere in this function.
11009                        this code is used for i.e., typedef int A::M; M *pm;
11010
11011                        It is?  How? jason 10/2/94 */
11012
11013                     if (current_class_type)
11014                       {
11015                         error ("cannot declare member `%T::%s' within `%T'",
11016                                   ctype, name, current_class_type);
11017                         return void_type_node;
11018                       }
11019                     type = build_offset_type (ctype, type);
11020                   }
11021                 else
11022                   {
11023                     incomplete_type_error (NULL_TREE, ctype);
11024                     return error_mark_node;
11025                   }
11026
11027                 declarator = sname;
11028               }
11029             else if (TREE_CODE (sname) == SCOPE_REF)
11030               abort ();
11031             else
11032               {
11033               done_scoping:
11034                 declarator = TREE_OPERAND (declarator, 1);
11035                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11036                   /* In this case, we will deal with it later.  */
11037                   ;
11038                 else
11039                   {
11040                     if (TREE_CODE (type) == FUNCTION_TYPE)
11041                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11042                                                       TYPE_ARG_TYPES (type));
11043                     else
11044                       type = build_offset_type (ctype, type);
11045                   }
11046               }
11047           }
11048           break;
11049
11050         case BIT_NOT_EXPR:
11051           declarator = TREE_OPERAND (declarator, 0);
11052           break;
11053
11054         case RECORD_TYPE:
11055         case UNION_TYPE:
11056         case ENUMERAL_TYPE:
11057           declarator = NULL_TREE;
11058           break;
11059
11060         case ERROR_MARK:
11061           declarator = NULL_TREE;
11062           break;
11063
11064         default:
11065           abort ();
11066         }
11067     }
11068
11069   if (returned_attrs)
11070     {
11071       if (attrlist)
11072         *attrlist = chainon (returned_attrs, *attrlist);
11073       else
11074         attrlist = &returned_attrs;
11075     }
11076
11077   /* Now TYPE has the actual type.  */
11078
11079   /* Did array size calculations overflow?  */
11080
11081   if (TREE_CODE (type) == ARRAY_TYPE
11082       && COMPLETE_TYPE_P (type)
11083       && TREE_OVERFLOW (TYPE_SIZE (type)))
11084     {
11085       error ("size of array `%s' is too large", name);
11086       /* If we proceed with the array type as it is, we'll eventually
11087          crash in tree_low_cst().  */
11088       type = error_mark_node;
11089     }
11090
11091   if (explicitp == 1 || (explicitp && friendp))
11092     {
11093       /* [dcl.fct.spec] The explicit specifier shall only be used in
11094          declarations of constructors within a class definition.  */
11095       error ("only declarations of constructors can be `explicit'");
11096       explicitp = 0;
11097     }
11098
11099   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11100     {
11101       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11102         {
11103           error ("non-member `%s' cannot be declared `mutable'", name);
11104           RIDBIT_RESET (RID_MUTABLE, specbits);
11105         }
11106       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11107         {
11108           error ("non-object member `%s' cannot be declared `mutable'", name);
11109           RIDBIT_RESET (RID_MUTABLE, specbits);
11110         }
11111       else if (TREE_CODE (type) == FUNCTION_TYPE
11112                || TREE_CODE (type) == METHOD_TYPE)
11113         {
11114           error ("function `%s' cannot be declared `mutable'", name);
11115           RIDBIT_RESET (RID_MUTABLE, specbits);
11116         }
11117       else if (staticp)
11118         {
11119           error ("static `%s' cannot be declared `mutable'", name);
11120           RIDBIT_RESET (RID_MUTABLE, specbits);
11121         }
11122       else if (type_quals & TYPE_QUAL_CONST)
11123         {
11124           error ("const `%s' cannot be declared `mutable'", name);
11125           RIDBIT_RESET (RID_MUTABLE, specbits);
11126         }
11127     }
11128
11129   if (declarator == NULL_TREE
11130       || TREE_CODE (declarator) == IDENTIFIER_NODE
11131       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11132           && (TREE_CODE (type) == FUNCTION_TYPE
11133               || TREE_CODE (type) == METHOD_TYPE)))
11134     /* OK */;
11135   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11136     {
11137       error ("template-id `%D' used as a declarator", declarator);
11138       declarator = dname;
11139     }
11140   else
11141     /* Unexpected declarator format.  */
11142     abort ();
11143
11144   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11145
11146   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11147     {
11148       tree decl;
11149
11150       /* Note that the grammar rejects storage classes
11151          in typenames, fields or parameters.  */
11152       if (current_lang_name == lang_name_java)
11153         TYPE_FOR_JAVA (type) = 1;
11154
11155       if (decl_context == FIELD)
11156         {
11157           if (declarator == constructor_name (current_class_type))
11158             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11159                         declarator);
11160           decl = build_lang_decl (TYPE_DECL, declarator, type);
11161         }
11162       else
11163         {
11164           decl = build_decl (TYPE_DECL, declarator, type);
11165           if (!current_function_decl)
11166             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11167         }
11168
11169       /* If the user declares "typedef struct {...} foo" then the
11170          struct will have an anonymous name.  Fill that name in now.
11171          Nothing can refer to it, so nothing needs know about the name
11172          change.  */
11173       if (type != error_mark_node
11174           && declarator
11175           && TYPE_NAME (type)
11176           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11177           && TYPE_ANONYMOUS_P (type)
11178           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11179         {
11180           tree oldname = TYPE_NAME (type);
11181           tree t;
11182
11183           /* Replace the anonymous name with the real name everywhere.  */
11184           lookup_tag_reverse (type, declarator);
11185           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11186             if (TYPE_NAME (t) == oldname)
11187               TYPE_NAME (t) = decl;
11188
11189           if (TYPE_LANG_SPECIFIC (type))
11190             TYPE_WAS_ANONYMOUS (type) = 1;
11191
11192           /* If this is a typedef within a template class, the nested
11193              type is a (non-primary) template.  The name for the
11194              template needs updating as well.  */
11195           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11196             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11197               = TYPE_IDENTIFIER (type);
11198
11199           /* FIXME remangle member functions; member functions of a
11200              type with external linkage have external linkage.  */
11201         }
11202
11203       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11204         {
11205           cp_error_at ("typedef name may not be class-qualified", decl);
11206           return NULL_TREE;
11207         }
11208       else if (quals)
11209         {
11210           if (ctype == NULL_TREE)
11211             {
11212               if (TREE_CODE (type) != METHOD_TYPE)
11213                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11214               else
11215                 ctype = TYPE_METHOD_BASETYPE (type);
11216             }
11217           if (ctype != NULL_TREE)
11218             grok_method_quals (ctype, decl, quals);
11219         }
11220
11221       if (RIDBIT_SETP (RID_SIGNED, specbits)
11222           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11223         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11224
11225       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11226                       inlinep, friendp, raises != NULL_TREE);
11227
11228       if (initialized)
11229         error ("typedef declaration includes an initializer");
11230
11231       return decl;
11232     }
11233
11234   /* Detect the case of an array type of unspecified size
11235      which came, as such, direct from a typedef name.
11236      We must copy the type, so that each identifier gets
11237      a distinct type, so that each identifier's size can be
11238      controlled separately by its own initializer.  */
11239
11240   if (type != 0 && typedef_type != 0
11241       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
11242       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11243     {
11244       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11245     }
11246
11247   /* Detect where we're using a typedef of function type to declare a
11248      function. last_function_parms will not be set, so we must create
11249      it now.  */
11250
11251   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11252     {
11253       tree decls = NULL_TREE;
11254       tree args;
11255
11256       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11257         {
11258           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11259
11260           TREE_CHAIN (decl) = decls;
11261           decls = decl;
11262         }
11263
11264       last_function_parms = nreverse (decls);
11265     }
11266
11267   /* If this is a type name (such as, in a cast or sizeof),
11268      compute the type and return it now.  */
11269
11270   if (decl_context == TYPENAME)
11271     {
11272       /* Note that the grammar rejects storage classes
11273          in typenames, fields or parameters.  */
11274       if (type_quals != TYPE_UNQUALIFIED)
11275         type_quals = TYPE_UNQUALIFIED;
11276
11277       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11278       if (friendp)
11279         {
11280           if (type_quals != TYPE_UNQUALIFIED)
11281             {
11282               error ("type qualifiers specified for friend class declaration");
11283               type_quals = TYPE_UNQUALIFIED;
11284             }
11285           if (inlinep)
11286             {
11287               error ("`inline' specified for friend class declaration");
11288               inlinep = 0;
11289             }
11290
11291           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11292              But don't allow implicit typenames except with a class-key.  */
11293           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11294                                 || IMPLICIT_TYPENAME_P (type)))
11295             {
11296               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11297                 pedwarn ("template parameters cannot be friends");
11298               else if (TREE_CODE (type) == TYPENAME_TYPE)
11299                 pedwarn ("\
11300 friend declaration requires class-key, i.e. `friend class %T::%T'",
11301                             constructor_name (current_class_type),
11302                             TYPE_IDENTIFIER (type));
11303               else
11304                 pedwarn ("\
11305 friend declaration requires class-key, i.e. `friend %#T'",
11306                             type);
11307             }
11308
11309           /* Only try to do this stuff if we didn't already give up.  */
11310           if (type != integer_type_node)
11311             {
11312               /* DR 209. The friendly class does not need to be accessible
11313                  in the scope of the class granting friendship. */
11314               skip_type_access_control ();
11315
11316               /* A friendly class?  */
11317               if (current_class_type)
11318                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11319               else
11320                 error ("trying to make class `%T' a friend of global scope",
11321                           type);
11322
11323               type = void_type_node;
11324             }
11325         }
11326       else if (quals)
11327         {
11328           if (ctype == NULL_TREE)
11329             {
11330               if (TREE_CODE (type) != METHOD_TYPE)
11331                 error ("invalid qualifiers on non-member function type");
11332               else
11333                 ctype = TYPE_METHOD_BASETYPE (type);
11334             }
11335           if (ctype)
11336             {
11337               tree dummy = build_decl (TYPE_DECL, declarator, type);
11338               grok_method_quals (ctype, dummy, quals);
11339               type = TREE_TYPE (dummy);
11340             }
11341         }
11342
11343       return type;
11344     }
11345   else if (declarator == NULL_TREE && decl_context != PARM
11346            && decl_context != CATCHPARM
11347            && TREE_CODE (type) != UNION_TYPE
11348            && ! bitfield)
11349     {
11350       error ("abstract declarator `%T' used as declaration", type);
11351       declarator = make_anon_name ();
11352     }
11353
11354   /* `void' at top level (not within pointer)
11355      is allowed only in typedefs or type names.
11356      We don't complain about parms either, but that is because
11357      a better error message can be made later.  */
11358
11359   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11360     {
11361       if (! declarator)
11362         error ("unnamed variable or field declared void");
11363       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11364         {
11365           if (IDENTIFIER_OPNAME_P (declarator))
11366             abort ();
11367           else
11368             error ("variable or field `%s' declared void", name);
11369         }
11370       else
11371         error ("variable or field declared void");
11372       type = integer_type_node;
11373     }
11374
11375   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11376      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11377
11378   if (decl_context == PARM || decl_context == CATCHPARM)
11379     {
11380       if (ctype || in_namespace)
11381         error ("cannot use `::' in parameter declaration");
11382
11383       /* A parameter declared as an array of T is really a pointer to T.
11384          One declared as a function is really a pointer to a function.
11385          One declared as a member is really a pointer to member.  */
11386
11387       if (TREE_CODE (type) == ARRAY_TYPE)
11388         {
11389           /* Transfer const-ness of array into that of type pointed to.  */
11390           type = build_pointer_type (TREE_TYPE (type));
11391           type_quals = TYPE_UNQUALIFIED;
11392         }
11393       else if (TREE_CODE (type) == FUNCTION_TYPE)
11394         type = build_pointer_type (type);
11395       else if (TREE_CODE (type) == OFFSET_TYPE)
11396         type = build_pointer_type (type);
11397     }
11398
11399   {
11400     register tree decl;
11401
11402     if (decl_context == PARM)
11403       {
11404         decl = build_decl (PARM_DECL, declarator, type);
11405
11406         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11407                         inlinep, friendp, raises != NULL_TREE);
11408
11409         /* Compute the type actually passed in the parmlist,
11410            for the case where there is no prototype.
11411            (For example, shorts and chars are passed as ints.)
11412            When there is a prototype, this is overridden later.  */
11413
11414         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11415       }
11416     else if (decl_context == FIELD)
11417       {
11418         if (type == error_mark_node)
11419           {
11420             /* Happens when declaring arrays of sizes which
11421                are error_mark_node, for example.  */
11422             decl = NULL_TREE;
11423           }
11424         else if (in_namespace && !friendp)
11425           {
11426             /* Something like struct S { int N::j; };  */
11427             error ("invalid use of `::'");
11428             decl = NULL_TREE;
11429           }
11430         else if (TREE_CODE (type) == FUNCTION_TYPE)
11431           {
11432             int publicp = 0;
11433             tree function_context;
11434
11435             /* We catch the others as conflicts with the builtin
11436                typedefs.  */
11437             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11438               {
11439                 error ("function `%D' cannot be declared friend",
11440                           declarator);
11441                 friendp = 0;
11442               }
11443
11444             if (friendp == 0)
11445               {
11446                 if (ctype == NULL_TREE)
11447                   ctype = current_class_type;
11448
11449                 if (ctype == NULL_TREE)
11450                   {
11451                     error ("can't make `%D' into a method -- not in a class",
11452                               declarator);
11453                     return void_type_node;
11454                   }
11455
11456                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11457                    ARM 9.5 */
11458                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11459                   {
11460                     error ("function `%D' declared virtual inside a union",
11461                               declarator);
11462                     return void_type_node;
11463                   }
11464
11465                 if (declarator == ansi_opname (NEW_EXPR)
11466                     || declarator == ansi_opname (VEC_NEW_EXPR)
11467                     || declarator == ansi_opname (DELETE_EXPR)
11468                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11469                   {
11470                     if (virtualp)
11471                       {
11472                         error ("`%D' cannot be declared virtual, since it is always static",
11473                                   declarator);
11474                         virtualp = 0;
11475                       }
11476                   }
11477                 else if (staticp < 2)
11478                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11479                                                   TYPE_ARG_TYPES (type));
11480               }
11481
11482             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11483             function_context = (ctype != NULL_TREE) ?
11484               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11485             publicp = (! friendp || ! staticp)
11486               && function_context == NULL_TREE;
11487             decl = grokfndecl (ctype, type,
11488                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11489                                ? declarator : dname,
11490                                declarator,
11491                                virtualp, flags, quals, raises,
11492                                friendp ? -1 : 0, friendp, publicp, inlinep,
11493                                funcdef_flag, template_count, in_namespace);
11494             if (decl == NULL_TREE)
11495               return decl;
11496 #if 0
11497             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11498             /* The decl and setting of decl_attr is also turned off.  */
11499             decl = build_decl_attribute_variant (decl, decl_attr);
11500 #endif
11501
11502             /* [class.conv.ctor]
11503
11504                A constructor declared without the function-specifier
11505                explicit that can be called with a single parameter
11506                specifies a conversion from the type of its first
11507                parameter to the type of its class.  Such a constructor
11508                is called a converting constructor.  */
11509             if (explicitp == 2)
11510               DECL_NONCONVERTING_P (decl) = 1;
11511             else if (DECL_CONSTRUCTOR_P (decl))
11512               {
11513                 /* The constructor can be called with exactly one
11514                    parameter if there is at least one parameter, and
11515                    any subsequent parameters have default arguments.
11516                    Ignore any compiler-added parms.  */
11517                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11518
11519                 if (arg_types == void_list_node
11520                     || (arg_types
11521                         && TREE_CHAIN (arg_types)
11522                         && TREE_CHAIN (arg_types) != void_list_node
11523                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11524                   DECL_NONCONVERTING_P (decl) = 1;
11525               }
11526           }
11527         else if (TREE_CODE (type) == METHOD_TYPE)
11528           {
11529             /* We only get here for friend declarations of
11530                members of other classes.  */
11531             /* All method decls are public, so tell grokfndecl to set
11532                TREE_PUBLIC, also.  */
11533             decl = grokfndecl (ctype, type, declarator, declarator,
11534                                virtualp, flags, quals, raises,
11535                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11536                                template_count, in_namespace);
11537             if (decl == NULL_TREE)
11538               return NULL_TREE;
11539           }
11540         else if (!staticp && ! processing_template_decl
11541                  && !COMPLETE_TYPE_P (complete_type (type))
11542                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11543           {
11544             if (declarator)
11545               error ("field `%D' has incomplete type", declarator);
11546             else
11547               error ("name `%T' has incomplete type", type);
11548
11549             /* If we're instantiating a template, tell them which
11550                instantiation made the field's type be incomplete.  */
11551             if (current_class_type
11552                 && TYPE_NAME (current_class_type)
11553                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11554                 && declspecs && TREE_VALUE (declspecs)
11555                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11556               error ("  in instantiation of template `%T'",
11557                         current_class_type);
11558
11559             type = error_mark_node;
11560             decl = NULL_TREE;
11561           }
11562         else
11563           {
11564             if (friendp)
11565               {
11566                 error ("`%s' is neither function nor member function; cannot be declared friend",
11567                        IDENTIFIER_POINTER (declarator));
11568                 friendp = 0;
11569               }
11570             decl = NULL_TREE;
11571           }
11572
11573         if (friendp)
11574           {
11575             /* Friends are treated specially.  */
11576             tree t = NULL_TREE;
11577
11578             /* DR 209. The friend does not need to be accessible at this
11579                point. */
11580             skip_type_access_control ();
11581
11582             if (ctype == current_class_type)
11583               warning ("member functions are implicitly friends of their class");
11584
11585             if (decl && DECL_NAME (decl))
11586               {
11587                 if (template_class_depth (current_class_type) == 0)
11588                   {
11589                     decl = check_explicit_specialization
11590                             (declarator, decl,
11591                              template_count, 2 * (funcdef_flag != 0) + 4);
11592                     if (decl == error_mark_node)
11593                       return error_mark_node;
11594                   }
11595
11596                 t = do_friend (ctype, declarator, decl,
11597                                last_function_parms, *attrlist, flags, quals,
11598                                funcdef_flag);
11599               }
11600             if (t && funcdef_flag)
11601               return t;
11602             return void_type_node;
11603           }
11604
11605         /* Structure field.  It may not be a function, except for C++ */
11606
11607         if (decl == NULL_TREE)
11608           {
11609             if (initialized)
11610               {
11611                 if (!staticp)
11612                   {
11613                     /* An attempt is being made to initialize a non-static
11614                        member.  But, from [class.mem]:
11615
11616                        4 A member-declarator can contain a
11617                        constant-initializer only if it declares a static
11618                        member (_class.static_) of integral or enumeration
11619                        type, see _class.static.data_.
11620
11621                        This used to be relatively common practice, but
11622                        the rest of the compiler does not correctly
11623                        handle the initialization unless the member is
11624                        static so we make it static below.  */
11625                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11626                                 declarator);
11627                     pedwarn ("making `%D' static", declarator);
11628                     staticp = 1;
11629                   }
11630
11631                 if (uses_template_parms (type))
11632                   /* We'll check at instantiation time.  */
11633                   ;
11634                 else if (check_static_variable_definition (declarator,
11635                                                            type))
11636                   /* If we just return the declaration, crashes
11637                      will sometimes occur.  We therefore return
11638                      void_type_node, as if this was a friend
11639                      declaration, to cause callers to completely
11640                      ignore this declaration.  */
11641                   return void_type_node;
11642               }
11643
11644             /* 9.2p13 [class.mem] */
11645             if (declarator == constructor_name (current_class_type)
11646                 /* The standard does not allow non-static data members
11647                    here either, but we agreed at the 10/99 meeting
11648                    to change that in TC 1 so that they are allowed in
11649                    classes with no user-defined constructors.  */
11650                 && staticp)
11651               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11652                           declarator);
11653
11654             if (staticp)
11655               {
11656                 /* C++ allows static class members.  All other work
11657                    for this is done by grokfield.  */
11658                 decl = build_lang_decl (VAR_DECL, declarator, type);
11659                 TREE_STATIC (decl) = 1;
11660                 /* In class context, 'static' means public access.  */
11661                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11662               }
11663             else
11664               {
11665                 decl = build_decl (FIELD_DECL, declarator, type);
11666                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11667                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11668                   {
11669                     DECL_MUTABLE_P (decl) = 1;
11670                     RIDBIT_RESET (RID_MUTABLE, specbits);
11671                   }
11672               }
11673
11674             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11675                             inlinep, friendp, raises != NULL_TREE);
11676           }
11677       }
11678     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11679       {
11680         tree original_name;
11681         int publicp = 0;
11682
11683         if (! declarator)
11684           return NULL_TREE;
11685
11686         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11687           original_name = dname;
11688         else
11689           original_name = declarator;
11690
11691         if (RIDBIT_SETP (RID_AUTO, specbits))
11692           error ("storage class `auto' invalid for function `%s'", name);
11693         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11694           error ("storage class `register' invalid for function `%s'", name);
11695
11696         /* Function declaration not at top level.
11697            Storage classes other than `extern' are not allowed
11698            and `extern' makes no difference.  */
11699         if (! toplevel_bindings_p ()
11700             && (RIDBIT_SETP (RID_STATIC, specbits)
11701                 || RIDBIT_SETP (RID_INLINE, specbits))
11702             && pedantic)
11703           {
11704             if (RIDBIT_SETP (RID_STATIC, specbits))
11705               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11706             else
11707               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11708           }
11709
11710         if (ctype == NULL_TREE)
11711           {
11712             if (virtualp)
11713               {
11714                 error ("virtual non-class function `%s'", name);
11715                 virtualp = 0;
11716               }
11717           }
11718         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11719           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11720                                           TYPE_ARG_TYPES (type));
11721
11722         /* Record presence of `static'.  */
11723         publicp = (ctype != NULL_TREE
11724                    || RIDBIT_SETP (RID_EXTERN, specbits)
11725                    || !RIDBIT_SETP (RID_STATIC, specbits));
11726
11727         decl = grokfndecl (ctype, type, original_name, declarator,
11728                            virtualp, flags, quals, raises,
11729                            1, friendp,
11730                            publicp, inlinep, funcdef_flag,
11731                            template_count, in_namespace);
11732         if (decl == NULL_TREE)
11733           return NULL_TREE;
11734
11735         if (staticp == 1)
11736           {
11737             int illegal_static = 0;
11738
11739             /* Don't allow a static member function in a class, and forbid
11740                declaring main to be static.  */
11741             if (TREE_CODE (type) == METHOD_TYPE)
11742               {
11743                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11744                 illegal_static = 1;
11745               }
11746             else if (current_function_decl)
11747               {
11748                 /* FIXME need arm citation */
11749                 error ("cannot declare static function inside another function");
11750                 illegal_static = 1;
11751               }
11752
11753             if (illegal_static)
11754               {
11755                 staticp = 0;
11756                 RIDBIT_RESET (RID_STATIC, specbits);
11757               }
11758           }
11759       }
11760     else
11761       {
11762         /* It's a variable.  */
11763
11764         /* An uninitialized decl with `extern' is a reference.  */
11765         decl = grokvardecl (type, declarator, &specbits,
11766                             initialized,
11767                             (type_quals & TYPE_QUAL_CONST) != 0,
11768                             in_namespace);
11769         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11770                         inlinep, friendp, raises != NULL_TREE);
11771
11772         if (ctype)
11773           {
11774             DECL_CONTEXT (decl) = ctype;
11775             if (staticp == 1)
11776               {
11777                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11778                 staticp = 0;
11779                 RIDBIT_RESET (RID_STATIC, specbits);
11780               }
11781             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11782               {
11783                 error ("static member `%D' declared `register'", decl);
11784                 RIDBIT_RESET (RID_REGISTER, specbits);
11785               }
11786             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11787               {
11788                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11789                             decl);
11790                 RIDBIT_RESET (RID_EXTERN, specbits);
11791               }
11792           }
11793       }
11794
11795     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11796
11797     /* Record `register' declaration for warnings on &
11798        and in case doing stupid register allocation.  */
11799
11800     if (RIDBIT_SETP (RID_REGISTER, specbits))
11801       DECL_REGISTER (decl) = 1;
11802
11803     if (RIDBIT_SETP (RID_EXTERN, specbits))
11804       DECL_THIS_EXTERN (decl) = 1;
11805
11806     if (RIDBIT_SETP (RID_STATIC, specbits))
11807       DECL_THIS_STATIC (decl) = 1;
11808
11809     /* Record constancy and volatility.  There's no need to do this
11810        when processing a template; we'll do this for the instantiated
11811        declaration based on the type of DECL.  */
11812     if (!processing_template_decl)
11813       c_apply_type_quals_to_decl (type_quals, decl);
11814
11815     return decl;
11816   }
11817 }
11818 \f
11819 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11820    An empty exprlist is a parmlist.  An exprlist which
11821    contains only identifiers at the global level
11822    is a parmlist.  Otherwise, it is an exprlist.  */
11823
11824 int
11825 parmlist_is_exprlist (exprs)
11826      tree exprs;
11827 {
11828   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11829     return 0;
11830
11831   if (toplevel_bindings_p ())
11832     {
11833       /* At the global level, if these are all identifiers,
11834          then it is a parmlist.  */
11835       while (exprs)
11836         {
11837           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11838             return 1;
11839           exprs = TREE_CHAIN (exprs);
11840         }
11841       return 0;
11842     }
11843   return 1;
11844 }
11845
11846 /* Subroutine of start_function.  Ensure that each of the parameter
11847    types (as listed in PARMS) is complete, as is required for a
11848    function definition.  */
11849
11850 static void
11851 require_complete_types_for_parms (parms)
11852      tree parms;
11853 {
11854   for (; parms; parms = TREE_CHAIN (parms))
11855     {
11856       if (VOID_TYPE_P (TREE_TYPE (parms)))
11857         /* grokparms will have already issued an error */
11858         TREE_TYPE (parms) = error_mark_node;
11859       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11860         layout_decl (parms, 0);
11861       else
11862         TREE_TYPE (parms) = error_mark_node;
11863     }
11864 }
11865
11866 /* Returns non-zero if T is a local variable.  */
11867
11868 int
11869 local_variable_p (t)
11870      tree t;
11871 {
11872   if ((TREE_CODE (t) == VAR_DECL
11873        /* A VAR_DECL with a context that is a _TYPE is a static data
11874           member.  */
11875        && !TYPE_P (CP_DECL_CONTEXT (t))
11876        /* Any other non-local variable must be at namespace scope.  */
11877        && !DECL_NAMESPACE_SCOPE_P (t))
11878       || (TREE_CODE (t) == PARM_DECL))
11879     return 1;
11880
11881   return 0;
11882 }
11883
11884 /* Returns non-zero if T is an automatic local variable or a label.
11885    (These are the declarations that need to be remapped when the code
11886    containing them is duplicated.)  */
11887
11888 int
11889 nonstatic_local_decl_p (t)
11890      tree t;
11891 {
11892   return ((local_variable_p (t) && !TREE_STATIC (t))
11893           || TREE_CODE (t) == LABEL_DECL
11894           || TREE_CODE (t) == RESULT_DECL);
11895 }
11896
11897 /* Like local_variable_p, but suitable for use as a tree-walking
11898    function.  */
11899
11900 static tree
11901 local_variable_p_walkfn (tp, walk_subtrees, data)
11902      tree *tp;
11903      int *walk_subtrees ATTRIBUTE_UNUSED;
11904      void *data ATTRIBUTE_UNUSED;
11905 {
11906   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11907           ? *tp : NULL_TREE);
11908 }
11909
11910 /* Check that ARG, which is a default-argument expression for a
11911    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11912    something goes wrong.  DECL may also be a _TYPE node, rather than a
11913    DECL, if there is no DECL available.  */
11914
11915 tree
11916 check_default_argument (decl, arg)
11917      tree decl;
11918      tree arg;
11919 {
11920   tree var;
11921   tree decl_type;
11922
11923   if (TREE_CODE (arg) == DEFAULT_ARG)
11924     /* We get a DEFAULT_ARG when looking at an in-class declaration
11925        with a default argument.  Ignore the argument for now; we'll
11926        deal with it after the class is complete.  */
11927     return arg;
11928
11929   if (processing_template_decl || uses_template_parms (arg))
11930     /* We don't do anything checking until instantiation-time.  Note
11931        that there may be uninstantiated arguments even for an
11932        instantiated function, since default arguments are not
11933        instantiated until they are needed.  */
11934     return arg;
11935
11936   if (TYPE_P (decl))
11937     {
11938       decl_type = decl;
11939       decl = NULL_TREE;
11940     }
11941   else
11942     decl_type = TREE_TYPE (decl);
11943
11944   if (arg == error_mark_node
11945       || decl == error_mark_node
11946       || TREE_TYPE (arg) == error_mark_node
11947       || decl_type == error_mark_node)
11948     /* Something already went wrong.  There's no need to check
11949        further.  */
11950     return error_mark_node;
11951
11952   /* [dcl.fct.default]
11953
11954      A default argument expression is implicitly converted to the
11955      parameter type.  */
11956   if (!TREE_TYPE (arg)
11957       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11958     {
11959       if (decl)
11960         error ("default argument for `%#D' has type `%T'",
11961                   decl, TREE_TYPE (arg));
11962       else
11963         error ("default argument for parameter of type `%T' has type `%T'",
11964                   decl_type, TREE_TYPE (arg));
11965
11966       return error_mark_node;
11967     }
11968
11969   /* [dcl.fct.default]
11970
11971      Local variables shall not be used in default argument
11972      expressions.
11973
11974      The keyword `this' shall not be used in a default argument of a
11975      member function.  */
11976   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11977                                       NULL);
11978   if (var)
11979     {
11980       error ("default argument `%E' uses local variable `%D'",
11981                 arg, var);
11982       return error_mark_node;
11983     }
11984
11985   /* All is well.  */
11986   return arg;
11987 }
11988
11989 /* Decode the list of parameter types for a function type.
11990    Given the list of things declared inside the parens,
11991    return a list of types.
11992
11993    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11994    flag. If unset, we append void_list_node. A parmlist declared
11995    as `(void)' is accepted as the empty parmlist.
11996
11997    Also set last_function_parms to the chain of PARM_DECLs.  */
11998
11999 static tree
12000 grokparms (first_parm)
12001      tree first_parm;
12002 {
12003   tree result = NULL_TREE;
12004   tree decls = NULL_TREE;
12005   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12006   tree parm, chain;
12007   int any_error = 0;
12008
12009   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12010
12011   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12012     {
12013       tree type = NULL_TREE;
12014       tree decl = TREE_VALUE (parm);
12015       tree init = TREE_PURPOSE (parm);
12016       tree specs, attrs;
12017
12018       chain = TREE_CHAIN (parm);
12019       /* @@ weak defense against parse errors.  */
12020       if (TREE_CODE (decl) != VOID_TYPE
12021           && TREE_CODE (decl) != TREE_LIST)
12022         {
12023           /* Give various messages as the need arises.  */
12024           if (TREE_CODE (decl) == STRING_CST)
12025             error ("invalid string constant `%E'", decl);
12026           else if (TREE_CODE (decl) == INTEGER_CST)
12027             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12028           continue;
12029         }
12030
12031       if (parm == void_list_node)
12032         break;
12033
12034       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12035       decl = grokdeclarator (TREE_VALUE (decl), specs,
12036                              PARM, init != NULL_TREE, &attrs);
12037       if (! decl || TREE_TYPE (decl) == error_mark_node)
12038         continue;
12039
12040       if (attrs)
12041         cplus_decl_attributes (&decl, attrs, 0);
12042
12043       type = TREE_TYPE (decl);
12044       if (VOID_TYPE_P (type))
12045         {
12046           if (same_type_p (type, void_type_node)
12047               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12048             /* this is a parmlist of `(void)', which is ok.  */
12049             break;
12050           incomplete_type_error (decl, type);
12051           /* It's not a good idea to actually create parameters of
12052              type `void'; other parts of the compiler assume that a
12053              void type terminates the parameter list.  */
12054           type = error_mark_node;
12055           TREE_TYPE (decl) = error_mark_node;
12056         }
12057
12058       if (type != error_mark_node)
12059         {
12060           /* Top-level qualifiers on the parameters are
12061              ignored for function types.  */
12062           type = TYPE_MAIN_VARIANT (type);
12063           if (TREE_CODE (type) == METHOD_TYPE)
12064             {
12065               error ("parameter `%D' invalidly declared method type", decl);
12066               type = build_pointer_type (type);
12067               TREE_TYPE (decl) = type;
12068             }
12069           else if (TREE_CODE (type) == OFFSET_TYPE)
12070             {
12071               error ("parameter `%D' invalidly declared offset type", decl);
12072               type = build_pointer_type (type);
12073               TREE_TYPE (decl) = type;
12074             }
12075           else if (abstract_virtuals_error (decl, type))
12076             any_error = 1;  /* Seems like a good idea. */
12077           else if (POINTER_TYPE_P (type))
12078             {
12079               /* [dcl.fct]/6, parameter types cannot contain pointers
12080                  (references) to arrays of unknown bound.  */
12081               tree t = TREE_TYPE (type);
12082               int ptr = TYPE_PTR_P (type);
12083
12084               while (1)
12085                 {
12086                   if (TYPE_PTR_P (t))
12087                     ptr = 1;
12088                   else if (TREE_CODE (t) != ARRAY_TYPE)
12089                     break;
12090                   else if (!TYPE_DOMAIN (t))
12091                     break;
12092                   t = TREE_TYPE (t);
12093                 }
12094               if (TREE_CODE (t) == ARRAY_TYPE)
12095                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12096                           decl, ptr ? "pointer" : "reference", t);
12097             }
12098
12099           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12100           if (PROMOTE_PROTOTYPES
12101               && INTEGRAL_TYPE_P (type)
12102               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12103             DECL_ARG_TYPE (decl) = integer_type_node;
12104           if (!any_error && init)
12105             init = check_default_argument (decl, init);
12106           else
12107             init = NULL_TREE;
12108         }
12109
12110       TREE_CHAIN (decl) = decls;
12111       decls = decl;
12112       result = tree_cons (init, type, result);
12113     }
12114   decls = nreverse (decls);
12115   result = nreverse (result);
12116   if (!ellipsis)
12117     result = chainon (result, void_list_node);
12118   last_function_parms = decls;
12119
12120   return result;
12121 }
12122
12123 \f
12124 /* D is a constructor or overloaded `operator='.
12125
12126    Let T be the class in which D is declared. Then, this function
12127    returns:
12128
12129    -1 if D's is an ill-formed constructor or copy assignment operator
12130       whose first parameter is of type `T'.
12131    0  if D is not a copy constructor or copy assignment
12132       operator.
12133    1  if D is a copy constructor or copy assignment operator whose
12134       first parameter is a reference to const qualified T.
12135    2  if D is a copy constructor or copy assignment operator whose
12136       first parameter is a reference to non-const qualified T.
12137
12138    This function can be used as a predicate. Positive values indicate
12139    a copy constructor and non-zero values indicate a copy assignment
12140    operator.  */
12141
12142 int
12143 copy_fn_p (d)
12144      tree d;
12145 {
12146   tree args;
12147   tree arg_type;
12148   int result = 1;
12149
12150   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12151
12152   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12153     /* Instantiations of template member functions are never copy
12154        functions.  Note that member functions of templated classes are
12155        represented as template functions internally, and we must
12156        accept those as copy functions.  */
12157     return 0;
12158
12159   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12160   if (!args)
12161     return 0;
12162
12163   arg_type = TREE_VALUE (args);
12164
12165   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12166     {
12167       /* Pass by value copy assignment operator.  */
12168       result = -1;
12169     }
12170   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12171            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12172     {
12173       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12174         result = 2;
12175     }
12176   else
12177     return 0;
12178
12179   args = TREE_CHAIN (args);
12180
12181   if (args && args != void_list_node && !TREE_PURPOSE (args))
12182     /* There are more non-optional args.  */
12183     return 0;
12184
12185   return result;
12186 }
12187
12188 /* Remember any special properties of member function DECL.  */
12189
12190 void grok_special_member_properties (decl)
12191      tree decl;
12192 {
12193   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12194     ; /* Not special.  */
12195   else if (DECL_CONSTRUCTOR_P (decl))
12196     {
12197       int ctor = copy_fn_p (decl);
12198
12199       if (ctor > 0)
12200         {
12201           /* [class.copy]
12202
12203              A non-template constructor for class X is a copy
12204              constructor if its first parameter is of type X&, const
12205              X&, volatile X& or const volatile X&, and either there
12206              are no other parameters or else all other parameters have
12207              default arguments.  */
12208           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12209           if (ctor > 1)
12210             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12211         }
12212       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12213         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12214     }
12215   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12216     {
12217       /* [class.copy]
12218
12219          A non-template assignment operator for class X is a copy
12220          assignment operator if its parameter is of type X, X&, const
12221          X&, volatile X& or const volatile X&.  */
12222
12223       int assop = copy_fn_p (decl);
12224
12225       if (assop)
12226         {
12227           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12228           if (assop != 1)
12229             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12230           if (DECL_PURE_VIRTUAL_P (decl))
12231             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12232         }
12233     }
12234 }
12235
12236 /* Check a constructor DECL has the correct form.  Complains
12237    if the class has a constructor of the form X(X).  */
12238
12239 int
12240 grok_ctor_properties (ctype, decl)
12241      tree ctype, decl;
12242 {
12243   int ctor_parm = copy_fn_p (decl);
12244
12245   if (ctor_parm < 0)
12246     {
12247       /* [class.copy]
12248
12249          A declaration of a constructor for a class X is ill-formed if
12250          its first parameter is of type (optionally cv-qualified) X
12251          and either there are no other parameters or else all other
12252          parameters have default arguments.
12253
12254          We *don't* complain about member template instantiations that
12255          have this form, though; they can occur as we try to decide
12256          what constructor to use during overload resolution.  Since
12257          overload resolution will never prefer such a constructor to
12258          the non-template copy constructor (which is either explicitly
12259          or implicitly defined), there's no need to worry about their
12260          existence.  Theoretically, they should never even be
12261          instantiated, but that's hard to forestall.  */
12262       error ("invalid constructor; you probably meant `%T (const %T&)'",
12263                 ctype, ctype);
12264       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12265       return 0;
12266     }
12267
12268   return 1;
12269 }
12270
12271 /* An operator with this code is unary, but can also be binary.  */
12272
12273 static int
12274 ambi_op_p (code)
12275      enum tree_code code;
12276 {
12277   return (code == INDIRECT_REF
12278           || code == ADDR_EXPR
12279           || code == CONVERT_EXPR
12280           || code == NEGATE_EXPR
12281           || code == PREINCREMENT_EXPR
12282           || code == PREDECREMENT_EXPR);
12283 }
12284
12285 /* An operator with this name can only be unary.  */
12286
12287 static int
12288 unary_op_p (code)
12289      enum tree_code code;
12290 {
12291   return (code == TRUTH_NOT_EXPR
12292           || code == BIT_NOT_EXPR
12293           || code == COMPONENT_REF
12294           || code == TYPE_EXPR);
12295 }
12296
12297 /* Do a little sanity-checking on how they declared their operator.  */
12298
12299 void
12300 grok_op_properties (decl, friendp)
12301      tree decl;
12302      int friendp;
12303 {
12304   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12305   tree argtype;
12306   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12307   tree name = DECL_NAME (decl);
12308   enum tree_code operator_code;
12309   int arity;
12310
12311   /* Count the number of arguments.  */
12312   for (argtype = argtypes, arity = 0;
12313        argtype && argtype != void_list_node;
12314        argtype = TREE_CHAIN (argtype))
12315     ++arity;
12316
12317   if (current_class_type == NULL_TREE)
12318     friendp = 1;
12319
12320   if (DECL_CONV_FN_P (decl))
12321     operator_code = TYPE_EXPR;
12322   else
12323     do
12324       {
12325 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12326         if (ansi_opname (CODE) == name)                         \
12327           {                                                     \
12328             operator_code = (CODE);                             \
12329             break;                                              \
12330           }                                                     \
12331         else if (ansi_assopname (CODE) == name)                 \
12332           {                                                     \
12333             operator_code = (CODE);                             \
12334             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12335             break;                                              \
12336           }
12337
12338 #include "operators.def"
12339 #undef DEF_OPERATOR
12340
12341         abort ();
12342       }
12343     while (0);
12344   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12345   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12346
12347   if (! friendp)
12348     {
12349       switch (operator_code)
12350         {
12351         case CALL_EXPR:
12352           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12353           break;
12354
12355         case ARRAY_REF:
12356           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12357           break;
12358
12359         case COMPONENT_REF:
12360         case MEMBER_REF:
12361           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12362           break;
12363
12364         case NEW_EXPR:
12365           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12366           break;
12367
12368         case DELETE_EXPR:
12369           TYPE_GETS_DELETE (current_class_type) |= 1;
12370           break;
12371
12372         case VEC_NEW_EXPR:
12373           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12374           break;
12375
12376         case VEC_DELETE_EXPR:
12377           TYPE_GETS_DELETE (current_class_type) |= 2;
12378           break;
12379
12380         default:
12381           break;
12382         }
12383     }
12384
12385   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12386     {
12387       /* When the compiler encounters the definition of A::operator new, it
12388          doesn't look at the class declaration to find out if it's static.  */
12389       if (methodp)
12390         revert_static_member_fn (decl);
12391
12392       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12393     }
12394   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12395     {
12396       if (methodp)
12397         revert_static_member_fn (decl);
12398
12399       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12400     }
12401   else
12402     {
12403       /* An operator function must either be a non-static member function
12404          or have at least one parameter of a class, a reference to a class,
12405          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12406       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12407         {
12408           if (operator_code == TYPE_EXPR
12409               || operator_code == CALL_EXPR
12410               || operator_code == COMPONENT_REF
12411               || operator_code == ARRAY_REF
12412               || operator_code == NOP_EXPR)
12413             error ("`%D' must be a nonstatic member function", decl);
12414           else
12415             {
12416               tree p = argtypes;
12417
12418               if (DECL_STATIC_FUNCTION_P (decl))
12419                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12420
12421               if (p)
12422                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12423                   {
12424                     tree arg = TREE_VALUE (p);
12425                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12426                       arg = TREE_TYPE (arg);
12427
12428                     /* This lets bad template code slip through.  */
12429                     if (IS_AGGR_TYPE (arg)
12430                         || TREE_CODE (arg) == ENUMERAL_TYPE
12431                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12432                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12433                       goto foundaggr;
12434                   }
12435               error
12436                 ("`%D' must have an argument of class or enumerated type",
12437                  decl);
12438             foundaggr:
12439               ;
12440             }
12441         }
12442
12443       if (operator_code == CALL_EXPR)
12444         return;                 /* No restrictions on args. */
12445
12446       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12447         {
12448           tree t = TREE_TYPE (name);
12449           if (! friendp)
12450             {
12451               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12452               const char *what = 0;
12453
12454               if (ref)
12455                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12456
12457               if (TREE_CODE (t) == VOID_TYPE)
12458                 what = "void";
12459               else if (t == current_class_type)
12460                 what = "the same type";
12461               /* Don't force t to be complete here.  */
12462               else if (IS_AGGR_TYPE (t)
12463                        && COMPLETE_TYPE_P (t)
12464                        && DERIVED_FROM_P (t, current_class_type))
12465                 what = "a base class";
12466
12467               if (what)
12468                 warning ("conversion to %s%s will never use a type conversion operator",
12469                          ref ? "a reference to " : "", what);
12470             }
12471         }
12472       if (operator_code == COND_EXPR)
12473         {
12474           /* 13.4.0.3 */
12475           error ("ISO C++ prohibits overloading operator ?:");
12476         }
12477       else if (ambi_op_p (operator_code))
12478         {
12479           if (arity == 1)
12480             /* We pick the one-argument operator codes by default, so
12481                we don't have to change anything.  */
12482             ;
12483           else if (arity == 2)
12484             {
12485               /* If we thought this was a unary operator, we now know
12486                  it to be a binary operator.  */
12487               switch (operator_code)
12488                 {
12489                 case INDIRECT_REF:
12490                   operator_code = MULT_EXPR;
12491                   break;
12492
12493                 case ADDR_EXPR:
12494                   operator_code = BIT_AND_EXPR;
12495                   break;
12496
12497                 case CONVERT_EXPR:
12498                   operator_code = PLUS_EXPR;
12499                   break;
12500
12501                 case NEGATE_EXPR:
12502                   operator_code = MINUS_EXPR;
12503                   break;
12504
12505                 case PREINCREMENT_EXPR:
12506                   operator_code = POSTINCREMENT_EXPR;
12507                   break;
12508
12509                 case PREDECREMENT_EXPR:
12510                   operator_code = POSTDECREMENT_EXPR;
12511                   break;
12512
12513                 default:
12514                   abort ();
12515                 }
12516
12517               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12518
12519               if ((operator_code == POSTINCREMENT_EXPR
12520                    || operator_code == POSTDECREMENT_EXPR)
12521                   && ! processing_template_decl
12522                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12523                 {
12524                   if (methodp)
12525                     error ("postfix `%D' must take `int' as its argument",
12526                               decl);
12527                   else
12528                     error
12529                       ("postfix `%D' must take `int' as its second argument",
12530                        decl);
12531                 }
12532             }
12533           else
12534             {
12535               if (methodp)
12536                 error ("`%D' must take either zero or one argument", decl);
12537               else
12538                 error ("`%D' must take either one or two arguments", decl);
12539             }
12540
12541           /* More Effective C++ rule 6.  */
12542           if (warn_ecpp
12543               && (operator_code == POSTINCREMENT_EXPR
12544                   || operator_code == POSTDECREMENT_EXPR
12545                   || operator_code == PREINCREMENT_EXPR
12546                   || operator_code == PREDECREMENT_EXPR))
12547             {
12548               tree arg = TREE_VALUE (argtypes);
12549               tree ret = TREE_TYPE (TREE_TYPE (decl));
12550               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12551                 arg = TREE_TYPE (arg);
12552               arg = TYPE_MAIN_VARIANT (arg);
12553               if (operator_code == PREINCREMENT_EXPR
12554                   || operator_code == PREDECREMENT_EXPR)
12555                 {
12556                   if (TREE_CODE (ret) != REFERENCE_TYPE
12557                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12558                                        arg))
12559                     warning ("prefix `%D' should return `%T'", decl,
12560                                 build_reference_type (arg));
12561                 }
12562               else
12563                 {
12564                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12565                     warning ("postfix `%D' should return `%T'", decl, arg);
12566                 }
12567             }
12568         }
12569       else if (unary_op_p (operator_code))
12570         {
12571           if (arity != 1)
12572             {
12573               if (methodp)
12574                 error ("`%D' must take `void'", decl);
12575               else
12576                 error ("`%D' must take exactly one argument", decl);
12577             }
12578         }
12579       else /* if (binary_op_p (operator_code)) */
12580         {
12581           if (arity != 2)
12582             {
12583               if (methodp)
12584                 error ("`%D' must take exactly one argument", decl);
12585               else
12586                 error ("`%D' must take exactly two arguments", decl);
12587             }
12588
12589           /* More Effective C++ rule 7.  */
12590           if (warn_ecpp
12591               && (operator_code == TRUTH_ANDIF_EXPR
12592                   || operator_code == TRUTH_ORIF_EXPR
12593                   || operator_code == COMPOUND_EXPR))
12594             warning ("user-defined `%D' always evaluates both arguments",
12595                         decl);
12596         }
12597
12598       /* Effective C++ rule 23.  */
12599       if (warn_ecpp
12600           && arity == 2
12601           && (operator_code == PLUS_EXPR
12602               || operator_code == MINUS_EXPR
12603               || operator_code == TRUNC_DIV_EXPR
12604               || operator_code == MULT_EXPR)
12605           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12606         warning ("`%D' should return by value", decl);
12607
12608       /* [over.oper]/8 */
12609       for (; argtypes && argtypes != void_list_node;
12610           argtypes = TREE_CHAIN (argtypes))
12611         if (TREE_PURPOSE (argtypes))
12612           {
12613             TREE_PURPOSE (argtypes) = NULL_TREE;
12614             if (operator_code == POSTINCREMENT_EXPR
12615                 || operator_code == POSTDECREMENT_EXPR)
12616               {
12617                 if (pedantic)
12618                   pedwarn ("`%D' cannot have default arguments", decl);
12619               }
12620             else
12621               error ("`%D' cannot have default arguments", decl);
12622           }
12623
12624     }
12625 }
12626 \f
12627 static const char *
12628 tag_name (code)
12629      enum tag_types code;
12630 {
12631   switch (code)
12632     {
12633     case record_type:
12634       return "struct";
12635     case class_type:
12636       return "class";
12637     case union_type:
12638       return "union ";
12639     case enum_type:
12640       return "enum";
12641     default:
12642       abort ();
12643     }
12644 }
12645
12646 /* Get the struct, enum or union (CODE says which) with tag NAME.
12647    Define the tag as a forward-reference if it is not defined.
12648
12649    C++: If a class derivation is given, process it here, and report
12650    an error if multiple derivation declarations are not identical.
12651
12652    If this is a definition, come in through xref_tag and only look in
12653    the current frame for the name (since C++ allows new names in any
12654    scope.)  */
12655
12656 tree
12657 xref_tag (code_type_node, name, globalize)
12658      tree code_type_node;
12659      tree name;
12660      int globalize;
12661 {
12662   enum tag_types tag_code;
12663   enum tree_code code;
12664   register tree ref, t;
12665   struct binding_level *b = current_binding_level;
12666   int got_type = 0;
12667   tree attributes = NULL_TREE;
12668   tree context = NULL_TREE;
12669
12670   /* If we are called from the parser, code_type_node will sometimes be a
12671      TREE_LIST.  This indicates that the user wrote
12672      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12673      use them later.  */
12674   if (TREE_CODE (code_type_node) == TREE_LIST)
12675     {
12676       attributes = TREE_PURPOSE (code_type_node);
12677       code_type_node = TREE_VALUE (code_type_node);
12678     }
12679
12680   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12681   switch (tag_code)
12682     {
12683     case record_type:
12684     case class_type:
12685       code = RECORD_TYPE;
12686       break;
12687     case union_type:
12688       code = UNION_TYPE;
12689       break;
12690     case enum_type:
12691       code = ENUMERAL_TYPE;
12692       break;
12693     default:
12694       abort ();
12695     }
12696
12697   /* If a cross reference is requested, look up the type
12698      already defined for this tag and return it.  */
12699   if (TYPE_P (name))
12700     {
12701       t = name;
12702       name = TYPE_IDENTIFIER (t);
12703       got_type = 1;
12704     }
12705   else
12706     t = IDENTIFIER_TYPE_VALUE (name);
12707
12708   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12709   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12710     {
12711       static int explained;
12712       tree shadowed;
12713
12714       warning ("`%s %T' declares a new type at namespace scope",
12715                   tag_name (tag_code), name);
12716       if (!explained++)
12717         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12718                     tag_name (tag_code),
12719                     constructor_name (current_class_type),
12720                     TYPE_IDENTIFIER (t));
12721
12722       /* We need to remove the class scope binding for the
12723          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12724       for (shadowed = b->class_shadowed;
12725            shadowed;
12726            shadowed = TREE_CHAIN (shadowed))
12727         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12728           {
12729             TREE_PURPOSE (shadowed) = NULL_TREE;
12730             break;
12731           }
12732     }
12733
12734   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12735       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12736     t = NULL_TREE;
12737
12738   if (! globalize)
12739     {
12740       /* If we know we are defining this tag, only look it up in
12741          this scope and don't try to find it as a type.  */
12742       ref = lookup_tag (code, name, b, 1);
12743     }
12744   else
12745     {
12746       if (t)
12747         {
12748           /* [dcl.type.elab] If the identifier resolves to a
12749              typedef-name or a template type-parameter, the
12750              elaborated-type-specifier is ill-formed.  */
12751           if (t != TYPE_MAIN_VARIANT (t)
12752               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12753             pedwarn ("using typedef-name `%D' after `%s'",
12754                         TYPE_NAME (t), tag_name (tag_code));
12755           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12756             error ("using template type parameter `%T' after `%s'",
12757                       t, tag_name (tag_code));
12758
12759           ref = t;
12760         }
12761       else
12762         ref = lookup_tag (code, name, b, 0);
12763
12764       if (! ref)
12765         {
12766           /* Try finding it as a type declaration.  If that wins,
12767              use it.  */
12768           ref = lookup_name (name, 1);
12769
12770           if (ref != NULL_TREE
12771               && processing_template_decl
12772               && DECL_CLASS_TEMPLATE_P (ref)
12773               && template_class_depth (current_class_type) == 0)
12774             /* Since GLOBALIZE is true, we're declaring a global
12775                template, so we want this type.  */
12776             ref = DECL_TEMPLATE_RESULT (ref);
12777
12778           if (ref && TREE_CODE (ref) == TYPE_DECL
12779               && TREE_CODE (TREE_TYPE (ref)) == code)
12780             ref = TREE_TYPE (ref);
12781           else
12782             ref = NULL_TREE;
12783         }
12784
12785       if (ref && current_class_type
12786           && template_class_depth (current_class_type)
12787           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12788         {
12789           /* Since GLOBALIZE is non-zero, we are not looking at a
12790              definition of this tag.  Since, in addition, we are currently
12791              processing a (member) template declaration of a template
12792              class, we must be very careful; consider:
12793
12794                template <class X>
12795                struct S1
12796
12797                template <class U>
12798                struct S2
12799                { template <class V>
12800                friend struct S1; };
12801
12802              Here, the S2::S1 declaration should not be confused with the
12803              outer declaration.  In particular, the inner version should
12804              have a template parameter of level 2, not level 1.  This
12805              would be particularly important if the member declaration
12806              were instead:
12807
12808                template <class V = U> friend struct S1;
12809
12810              say, when we should tsubst into `U' when instantiating
12811              S2.  On the other hand, when presented with:
12812
12813                  template <class T>
12814                  struct S1 {
12815                    template <class U>
12816                    struct S2 {};
12817                    template <class U>
12818                    friend struct S2;
12819                  };
12820
12821               we must find the inner binding eventually.  We
12822               accomplish this by making sure that the new type we
12823               create to represent this declaration has the right
12824               TYPE_CONTEXT.  */
12825           context = TYPE_CONTEXT (ref);
12826           ref = NULL_TREE;
12827         }
12828     }
12829
12830   if (! ref)
12831     {
12832       /* If no such tag is yet defined, create a forward-reference node
12833          and record it as the "definition".
12834          When a real declaration of this type is found,
12835          the forward-reference will be altered into a real type.  */
12836       if (code == ENUMERAL_TYPE)
12837         {
12838           error ("use of enum `%#D' without previous declaration", name);
12839
12840           ref = make_node (ENUMERAL_TYPE);
12841
12842           /* Give the type a default layout like unsigned int
12843              to avoid crashing if it does not get defined.  */
12844           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12845           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12846           TYPE_USER_ALIGN (ref) = 0;
12847           TREE_UNSIGNED (ref) = 1;
12848           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12849           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12850           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12851
12852           /* Enable us to recognize when a type is created in class context.
12853              To do nested classes correctly, this should probably be cleared
12854              out when we leave this classes scope.  Currently this in only
12855              done in `start_enum'.  */
12856
12857           pushtag (name, ref, globalize);
12858         }
12859       else
12860         {
12861           struct binding_level *old_b = class_binding_level;
12862
12863           ref = make_aggr_type (code);
12864           TYPE_CONTEXT (ref) = context;
12865
12866 #ifdef NONNESTED_CLASSES
12867           /* Class types don't nest the way enums do.  */
12868           class_binding_level = (struct binding_level *)0;
12869 #endif
12870           pushtag (name, ref, globalize);
12871           class_binding_level = old_b;
12872         }
12873     }
12874   else
12875     {
12876       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12877         redeclare_class_template (ref, current_template_parms);
12878     }
12879
12880   /* Until the type is defined, tentatively accept whatever
12881      structure tag the user hands us.  */
12882   if (!COMPLETE_TYPE_P (ref)
12883       && ref != current_class_type
12884       /* Have to check this, in case we have contradictory tag info.  */
12885       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12886     {
12887       if (tag_code == class_type)
12888         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12889       else if (tag_code == record_type)
12890         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12891     }
12892
12893   TYPE_ATTRIBUTES (ref) = attributes;
12894
12895   return ref;
12896 }
12897
12898 tree
12899 xref_tag_from_type (old, id, globalize)
12900      tree old, id;
12901      int globalize;
12902 {
12903   tree code_type_node;
12904
12905   if (TREE_CODE (old) == RECORD_TYPE)
12906     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12907                       ? class_type_node : record_type_node);
12908   else
12909     code_type_node = union_type_node;
12910
12911   if (id == NULL_TREE)
12912     id = TYPE_IDENTIFIER (old);
12913
12914   return xref_tag (code_type_node, id, globalize);
12915 }
12916
12917 /* REF is a type (named NAME), for which we have just seen some
12918    baseclasses.  BINFO is a list of those baseclasses; the
12919    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12920    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12921    struct, or union.  */
12922
12923 void
12924 xref_basetypes (code_type_node, name, ref, binfo)
12925      tree code_type_node;
12926      tree name, ref;
12927      tree binfo;
12928 {
12929   /* In the declaration `A : X, Y, ... Z' we mark all the types
12930      (A, X, Y, ..., Z) so we can check for duplicates.  */
12931   tree binfos;
12932   tree base;
12933
12934   int i, len;
12935   enum tag_types tag_code;
12936
12937   /* If we are called from the parser, code_type_node will sometimes be a
12938      TREE_LIST.  This indicates that the user wrote
12939      "class __attribute__ ((foo)) bar".  Extract the attributes so that
12940      tree_low_cst doesn't crash.  */
12941   if (TREE_CODE (code_type_node) == TREE_LIST)
12942     code_type_node = TREE_VALUE (code_type_node);
12943
12944   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12945
12946   if (tag_code == union_type)
12947     {
12948       error ("derived union `%T' invalid", ref);
12949       return;
12950     }
12951
12952   len = list_length (binfo);
12953
12954   /* First, make sure that any templates in base-classes are
12955      instantiated.  This ensures that if we call ourselves recursively
12956      we do not get confused about which classes are marked and which
12957      are not.  */
12958   for (base = binfo; base; base = TREE_CHAIN (base))
12959     complete_type (TREE_VALUE (base));
12960
12961   SET_CLASSTYPE_MARKED (ref);
12962   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12963
12964   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12965     {
12966       /* The base of a derived struct is public by default.  */
12967       int via_public
12968         = (TREE_PURPOSE (binfo) == access_public_node
12969            || TREE_PURPOSE (binfo) == access_public_virtual_node
12970            || (tag_code != class_type
12971                && (TREE_PURPOSE (binfo) == access_default_node
12972                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12973       int via_protected
12974         = (TREE_PURPOSE (binfo) == access_protected_node
12975            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12976       int via_virtual
12977         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12978            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12979            || TREE_PURPOSE (binfo) == access_public_virtual_node
12980            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12981       tree basetype = TREE_VALUE (binfo);
12982       tree base_binfo;
12983
12984       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12985         basetype = TREE_TYPE (basetype);
12986       if (!basetype
12987           || (TREE_CODE (basetype) != RECORD_TYPE
12988               && TREE_CODE (basetype) != TYPENAME_TYPE
12989               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12990               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12991         {
12992           error ("base type `%T' fails to be a struct or class type",
12993                     TREE_VALUE (binfo));
12994           continue;
12995         }
12996
12997       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12998
12999       /* This code replaces similar code in layout_basetypes.
13000          We put the complete_type first for implicit `typename'.  */
13001       if (!COMPLETE_TYPE_P (basetype)
13002           && ! (current_template_parms && uses_template_parms (basetype)))
13003         {
13004           error ("base class `%T' has incomplete type", basetype);
13005           continue;
13006         }
13007       else
13008         {
13009           if (CLASSTYPE_MARKED (basetype))
13010             {
13011               if (basetype == ref)
13012                 error ("recursive type `%T' undefined", basetype);
13013               else
13014                 error ("duplicate base type `%T' invalid", basetype);
13015               continue;
13016             }
13017
13018           if (TYPE_FOR_JAVA (basetype)
13019               && (current_lang_depth () == 0))
13020             TYPE_FOR_JAVA (ref) = 1;
13021
13022           /* Note that the BINFO records which describe individual
13023              inheritances are *not* shared in the lattice!  They
13024              cannot be shared because a given baseclass may be
13025              inherited with different `accessibility' by different
13026              derived classes.  (Each BINFO record describing an
13027              individual inheritance contains flags which say what
13028              the `accessibility' of that particular inheritance is.)  */
13029
13030           base_binfo
13031             = make_binfo (size_zero_node, basetype,
13032                           CLASS_TYPE_P (basetype)
13033                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13034                           CLASS_TYPE_P (basetype)
13035                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13036
13037           TREE_VEC_ELT (binfos, i) = base_binfo;
13038           TREE_VIA_PUBLIC (base_binfo) = via_public;
13039           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13040           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13041           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13042
13043           /* We need to unshare the binfos now so that lookups during class
13044              definition work.  */
13045           unshare_base_binfos (base_binfo);
13046
13047           SET_CLASSTYPE_MARKED (basetype);
13048
13049           /* We are free to modify these bits because they are meaningless
13050              at top level, and BASETYPE is a top-level type.  */
13051           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13052             {
13053               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13054               /* Converting to a virtual base class requires looking
13055                  up the offset of the virtual base.  */
13056               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13057             }
13058
13059           if (CLASS_TYPE_P (basetype))
13060             {
13061               TYPE_HAS_NEW_OPERATOR (ref)
13062                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13063               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13064                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13065               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13066               /* If the base-class uses multiple inheritance, so do we.  */
13067               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13068                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13069               /* Likewise, if converting to a base of the base may require
13070                  code, then we may need to generate code to convert to a
13071                  base as well.  */
13072               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13073                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13074             }
13075
13076           i += 1;
13077         }
13078     }
13079   if (i)
13080     TREE_VEC_LENGTH (binfos) = i;
13081   else
13082     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13083
13084   if (i > 1)
13085     {
13086       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13087       /* If there is more than one non-empty they cannot be at the same
13088          address.  */
13089       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13090     }
13091
13092   /* Unmark all the types.  */
13093   while (--i >= 0)
13094     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13095   CLEAR_CLASSTYPE_MARKED (ref);
13096
13097   /* Now that we know all the base-classes, set up the list of virtual
13098      bases.  */
13099   get_vbase_types (ref);
13100 }
13101
13102 \f
13103 /* Begin compiling the definition of an enumeration type.
13104    NAME is its name (or null if anonymous).
13105    Returns the type object, as yet incomplete.
13106    Also records info about it so that build_enumerator
13107    may be used to declare the individual values as they are read.  */
13108
13109 tree
13110 start_enum (name)
13111      tree name;
13112 {
13113   register tree enumtype = NULL_TREE;
13114   struct binding_level *b = current_binding_level;
13115
13116   /* If this is the real definition for a previous forward reference,
13117      fill in the contents in the same object that used to be the
13118      forward reference.  */
13119
13120   if (name != NULL_TREE)
13121     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13122
13123   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13124     {
13125       error ("multiple definition of `%#T'", enumtype);
13126       cp_error_at ("previous definition here", enumtype);
13127       /* Clear out TYPE_VALUES, and start again.  */
13128       TYPE_VALUES (enumtype) = NULL_TREE;
13129     }
13130   else
13131     {
13132       enumtype = make_node (ENUMERAL_TYPE);
13133       pushtag (name, enumtype, 0);
13134     }
13135
13136   if (current_class_type)
13137     TREE_ADDRESSABLE (b->tags) = 1;
13138
13139   GNU_xref_decl (current_function_decl, enumtype);
13140   return enumtype;
13141 }
13142
13143 /* After processing and defining all the values of an enumeration type,
13144    install their decls in the enumeration type and finish it off.
13145    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13146
13147 void
13148 finish_enum (enumtype)
13149      tree enumtype;
13150 {
13151   tree pair;
13152   tree minnode;
13153   tree maxnode;
13154   tree t;
13155   bool unsignedp;
13156   int lowprec;
13157   int highprec;
13158   int precision;
13159
13160   /* We built up the VALUES in reverse order.  */
13161   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13162
13163   /* [dcl.enum]
13164
13165      Following the closing brace of an enum-specifier, each
13166      enumerator has the type of its enumeration.  Prior to the
13167      closing brace, the type of each enumerator is the type of
13168      its initializing value.  */
13169   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13170     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13171
13172   /* For a enum defined in a template, all further processing is
13173      postponed until the template is instantiated.  */
13174   if (processing_template_decl)
13175     {
13176       tree scope = current_scope ();
13177       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13178         add_stmt (build_min (TAG_DEFN, enumtype));
13179
13180
13181       return;
13182     }
13183
13184   /* Figure out what the minimum and maximum values of the enumerators
13185      are.  */
13186   if (TYPE_VALUES (enumtype))
13187     {
13188       minnode = maxnode = NULL_TREE;
13189
13190       for (pair = TYPE_VALUES (enumtype);
13191            pair;
13192            pair = TREE_CHAIN (pair))
13193         {
13194           tree value;
13195
13196           value = DECL_INITIAL (TREE_VALUE (pair));
13197
13198           if (!minnode)
13199             minnode = maxnode = value;
13200           else if (tree_int_cst_lt (maxnode, value))
13201             maxnode = value;
13202           else if (tree_int_cst_lt (value, minnode))
13203             minnode = value;
13204         }
13205     }
13206   else
13207     minnode = maxnode = integer_zero_node;
13208
13209   /* Compute the number of bits require to represent all values of the
13210      enumeration.  We must do this before the type of MINNODE and
13211      MAXNODE are transformed, since min_precision relies on the
13212      TREE_TYPE of the value it is passed.  */
13213   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13214   lowprec = min_precision (minnode, unsignedp);
13215   highprec = min_precision (maxnode, unsignedp);
13216   precision = MAX (lowprec, highprec);
13217
13218   /* Set the TREE_TYPE for the values as well.  That's so that when we
13219      call decl_constant_value we get an entity of the right type (but
13220      with the constant value).  In addition, transform the TYPE_VALUES
13221      list to contain the values, rather than the CONST_DECLs for them.  */
13222   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13223     {
13224       tree value = DECL_INITIAL (TREE_VALUE (pair));
13225
13226       TREE_TYPE (value) = enumtype;
13227       TREE_VALUE (pair) = value;
13228     }
13229
13230   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13231   TYPE_SIZE (enumtype) = NULL_TREE;
13232   TYPE_PRECISION (enumtype) = precision;
13233   if (unsignedp)
13234     fixup_unsigned_type (enumtype);
13235   else
13236     fixup_signed_type (enumtype);
13237
13238   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13239     /* Use the width of the narrowest normal C type which is wide
13240        enough.  */
13241     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13242                                                 (precision, 1));
13243   else
13244     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13245
13246   TYPE_SIZE (enumtype) = NULL_TREE;
13247   layout_type (enumtype);
13248
13249   /* Fix up all variant types of this enum type.  */
13250   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13251     {
13252       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13253       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13254       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13255       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13256       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13257       TYPE_MODE (t) = TYPE_MODE (enumtype);
13258       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13259       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13260       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13261       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13262     }
13263
13264   /* Finish debugging output for this type.  */
13265   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13266 }
13267
13268 /* Build and install a CONST_DECL for an enumeration constant of the
13269    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13270    Assignment of sequential values by default is handled here.  */
13271
13272 void
13273 build_enumerator (name, value, enumtype)
13274      tree name;
13275      tree value;
13276      tree enumtype;
13277 {
13278   tree decl;
13279   tree context;
13280   tree type;
13281   tree values;
13282
13283   /* Remove no-op casts from the value.  */
13284   if (value)
13285     STRIP_TYPE_NOPS (value);
13286
13287   if (! processing_template_decl)
13288     {
13289       /* Validate and default VALUE.  */
13290       if (value != NULL_TREE)
13291         {
13292           value = decl_constant_value (value);
13293
13294           if (TREE_CODE (value) == INTEGER_CST)
13295             {
13296               value = default_conversion (value);
13297               constant_expression_warning (value);
13298             }
13299           else
13300             {
13301               error ("enumerator value for `%D' not integer constant", name);
13302               value = NULL_TREE;
13303             }
13304         }
13305
13306       /* Default based on previous value.  */
13307       if (value == NULL_TREE && ! processing_template_decl)
13308         {
13309           tree prev_value;
13310
13311           if (TYPE_VALUES (enumtype))
13312             {
13313               /* The next value is the previous value ... */
13314               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13315               /* ... plus one.  */
13316               value = cp_build_binary_op (PLUS_EXPR,
13317                                           prev_value,
13318                                           integer_one_node);
13319
13320               if (tree_int_cst_lt (value, prev_value))
13321                 error ("overflow in enumeration values at `%D'", name);
13322             }
13323           else
13324             value = integer_zero_node;
13325         }
13326
13327       /* Remove no-op casts from the value.  */
13328       if (value)
13329         STRIP_TYPE_NOPS (value);
13330 #if 0
13331       /* To fix MAX_VAL enum consts. (bkoz)  */
13332       TREE_TYPE (value) = integer_type_node;
13333 #endif
13334     }
13335
13336   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13337      Even in other cases, we will later (in finish_enum) be setting
13338      the type of VALUE.  But, we don't need to make a copy if this
13339      VALUE is one of the enumeration constants for this same
13340      enumeration type.  */
13341   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13342     if (TREE_VALUE (values) == value)
13343       break;
13344   /* If we didn't break out of the loop, then we do need a copy.  */
13345   if (!values && value)
13346     value = copy_node (value);
13347
13348   /* C++ associates enums with global, function, or class declarations.  */
13349   context = current_scope ();
13350
13351   /* Build the actual enumeration constant.  Note that the enumeration
13352     constants have the type of their initializers until the
13353     enumeration is complete:
13354
13355       [ dcl.enum ]
13356
13357       Following the closing brace of an enum-specifier, each enumer-
13358       ator has the type of its enumeration.  Prior to the closing
13359       brace, the type of each enumerator is the type of its
13360       initializing value.
13361
13362     In finish_enum we will reset the type.  Of course, if we're
13363     processing a template, there may be no value.   */
13364   type = value ? TREE_TYPE (value) : NULL_TREE;
13365
13366   if (context && context == current_class_type)
13367     /* This enum declaration is local to the class.  We need the full
13368        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13369     decl = build_lang_decl (CONST_DECL, name, type);
13370   else
13371     /* It's a global enum, or it's local to a function.  (Note local to
13372       a function could mean local to a class method.  */
13373     decl = build_decl (CONST_DECL, name, type);
13374
13375   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13376   DECL_INITIAL (decl) = value;
13377   TREE_READONLY (decl) = 1;
13378
13379   if (context && context == current_class_type)
13380     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13381       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13382       things like `S::i' later.)  */
13383     finish_member_declaration (decl);
13384   else
13385     {
13386       pushdecl (decl);
13387       GNU_xref_decl (current_function_decl, decl);
13388     }
13389
13390   /* Add this enumeration constant to the list for this type.  */
13391   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13392 }
13393
13394 \f
13395 /* We're defining DECL.  Make sure that it's type is OK.  */
13396
13397 static void
13398 check_function_type (decl, current_function_parms)
13399      tree decl;
13400      tree current_function_parms;
13401 {
13402   tree fntype = TREE_TYPE (decl);
13403   tree return_type = complete_type (TREE_TYPE (fntype));
13404
13405   /* In a function definition, arg types must be complete.  */
13406   require_complete_types_for_parms (current_function_parms);
13407
13408   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13409     {
13410       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13411
13412       /* Make it return void instead, but don't change the
13413          type of the DECL_RESULT, in case we have a named return value.  */
13414       if (TREE_CODE (fntype) == METHOD_TYPE)
13415         {
13416           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13417           TREE_TYPE (decl)
13418             = build_cplus_method_type (ctype,
13419                                        void_type_node,
13420                                        FUNCTION_ARG_CHAIN (decl));
13421         }
13422       else
13423         TREE_TYPE (decl)
13424           = build_function_type (void_type_node,
13425                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13426       TREE_TYPE (decl)
13427         = build_exception_variant (fntype,
13428                                    TYPE_RAISES_EXCEPTIONS (fntype));
13429     }
13430   else
13431     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13432 }
13433
13434 /* Create the FUNCTION_DECL for a function definition.
13435    DECLSPECS and DECLARATOR are the parts of the declaration;
13436    they describe the function's name and the type it returns,
13437    but twisted together in a fashion that parallels the syntax of C.
13438
13439    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13440    DECLARATOR is really the DECL for the function we are about to
13441    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13442    indicating that the function is an inline defined in-class.
13443
13444    This function creates a binding context for the function body
13445    as well as setting up the FUNCTION_DECL in current_function_decl.
13446
13447    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13448    (it defines a datum instead), we return 0, which tells
13449    yyparse to report a parse error.
13450
13451    For C++, we must first check whether that datum makes any sense.
13452    For example, "class A local_a(1,2);" means that variable local_a
13453    is an aggregate of type A, which should have a constructor
13454    applied to it with the argument list [1, 2].  */
13455
13456 int
13457 start_function (declspecs, declarator, attrs, flags)
13458      tree declspecs, declarator, attrs;
13459      int flags;
13460 {
13461   tree decl1;
13462   tree ctype = NULL_TREE;
13463   tree fntype;
13464   tree restype;
13465   extern int have_extern_spec;
13466   extern int used_extern_spec;
13467   int doing_friend = 0;
13468   struct binding_level *bl;
13469   tree current_function_parms;
13470
13471   /* Sanity check.  */
13472   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13473   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13474
13475   /* This should only be done once on the top most decl.  */
13476   if (have_extern_spec && !used_extern_spec)
13477     {
13478       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13479       used_extern_spec = 1;
13480     }
13481
13482   if (flags & SF_PRE_PARSED)
13483     {
13484       decl1 = declarator;
13485
13486       fntype = TREE_TYPE (decl1);
13487       if (TREE_CODE (fntype) == METHOD_TYPE)
13488         ctype = TYPE_METHOD_BASETYPE (fntype);
13489
13490       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13491          the (lexical) scope of the class in which it is defined.  */
13492       if (!ctype && DECL_FRIEND_P (decl1))
13493         {
13494           ctype = DECL_FRIEND_CONTEXT (decl1);
13495
13496           /* CTYPE could be null here if we're dealing with a template;
13497              for example, `inline friend float foo()' inside a template
13498              will have no CTYPE set.  */
13499           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13500             ctype = NULL_TREE;
13501           else
13502             doing_friend = 1;
13503         }
13504
13505       last_function_parms = DECL_ARGUMENTS (decl1);
13506     }
13507   else
13508     {
13509       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13510       /* If the declarator is not suitable for a function definition,
13511          cause a syntax error.  */
13512       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13513
13514       fntype = TREE_TYPE (decl1);
13515
13516       restype = TREE_TYPE (fntype);
13517       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13518         {
13519           error ("semicolon missing after declaration of `%#T'", restype);
13520           shadow_tag (build_tree_list (NULL_TREE, restype));
13521           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13522           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13523             fntype = build_function_type (integer_type_node,
13524                                           TYPE_ARG_TYPES (fntype));
13525           else
13526             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13527                                               integer_type_node,
13528                                               TYPE_ARG_TYPES (fntype));
13529           TREE_TYPE (decl1) = fntype;
13530         }
13531
13532       if (TREE_CODE (fntype) == METHOD_TYPE)
13533         ctype = TYPE_METHOD_BASETYPE (fntype);
13534       else if (DECL_MAIN_P (decl1))
13535         {
13536           /* If this doesn't return integer_type, complain.  */
13537           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13538             {
13539               if (pedantic || warn_return_type)
13540                 pedwarn ("return type for `main' changed to `int'");
13541               TREE_TYPE (decl1) = fntype = default_function_type;
13542             }
13543         }
13544     }
13545
13546   if (DECL_DECLARED_INLINE_P (decl1)
13547       && lookup_attribute ("noinline", attrs))
13548     warning_with_decl (decl1,
13549                        "inline function `%s' given attribute noinline");
13550
13551   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13552     /* This is a constructor, we must ensure that any default args
13553        introduced by this definition are propagated to the clones
13554        now. The clones are used directly in overload resolution.  */
13555     adjust_clone_args (decl1);
13556
13557   /* Sometimes we don't notice that a function is a static member, and
13558      build a METHOD_TYPE for it.  Fix that up now.  */
13559   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13560       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13561     {
13562       revert_static_member_fn (decl1);
13563       last_function_parms = TREE_CHAIN (last_function_parms);
13564       ctype = NULL_TREE;
13565     }
13566
13567   /* Warn if function was previously implicitly declared
13568      (but not if we warned then).  */
13569   if (! warn_implicit
13570       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13571     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13572
13573   /* Set up current_class_type, and enter the scope of the class, if
13574      appropriate.  */
13575   if (ctype)
13576     push_nested_class (ctype, 1);
13577   else if (DECL_STATIC_FUNCTION_P (decl1))
13578     push_nested_class (DECL_CONTEXT (decl1), 2);
13579
13580   /* Now that we have entered the scope of the class, we must restore
13581      the bindings for any template parameters surrounding DECL1, if it
13582      is an inline member template.  (Order is important; consider the
13583      case where a template parameter has the same name as a field of
13584      the class.)  It is not until after this point that
13585      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13586   if (flags & SF_INCLASS_INLINE)
13587     maybe_begin_member_template_processing (decl1);
13588
13589   /* Effective C++ rule 15.  */
13590   if (warn_ecpp
13591       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13592       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13593     warning ("`operator=' should return a reference to `*this'");
13594
13595   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13596      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13597   if (!DECL_INITIAL (decl1))
13598     DECL_INITIAL (decl1) = error_mark_node;
13599
13600   /* This function exists in static storage.
13601      (This does not mean `static' in the C sense!)  */
13602   TREE_STATIC (decl1) = 1;
13603
13604   /* We must call push_template_decl after current_class_type is set
13605      up.  (If we are processing inline definitions after exiting a
13606      class scope, current_class_type will be NULL_TREE until set above
13607      by push_nested_class.)  */
13608   if (processing_template_decl)
13609     decl1 = push_template_decl (decl1);
13610
13611   /* We are now in the scope of the function being defined.  */
13612   current_function_decl = decl1;
13613
13614   /* Save the parm names or decls from this function's declarator
13615      where store_parm_decls will find them.  */
13616   current_function_parms = last_function_parms;
13617
13618   /* Make sure the parameter and return types are reasonable.  When
13619      you declare a function, these types can be incomplete, but they
13620      must be complete when you define the function.  */
13621   if (! processing_template_decl)
13622     check_function_type (decl1, current_function_parms);
13623
13624   /* Build the return declaration for the function.  */
13625   restype = TREE_TYPE (fntype);
13626   if (!processing_template_decl)
13627     {
13628       if (!DECL_RESULT (decl1))
13629         {
13630           DECL_RESULT (decl1)
13631             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13632           c_apply_type_quals_to_decl (cp_type_quals (restype),
13633                                       DECL_RESULT (decl1));
13634         }
13635     }
13636   else
13637     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13638     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13639
13640   /* Initialize RTL machinery.  We cannot do this until
13641      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13642      even when processing a template; this is how we get
13643      CFUN set up, and our per-function variables initialized.
13644      FIXME factor out the non-RTL stuff.  */
13645   bl = current_binding_level;
13646   init_function_start (decl1, input_filename, lineno);
13647   current_binding_level = bl;
13648
13649   /* Even though we're inside a function body, we still don't want to
13650      call expand_expr to calculate the size of a variable-sized array.
13651      We haven't necessarily assigned RTL to all variables yet, so it's
13652      not safe to try to expand expressions involving them.  */
13653   immediate_size_expand = 0;
13654   cfun->x_dont_save_pending_sizes_p = 1;
13655
13656   /* Start the statement-tree, start the tree now.  */
13657   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13658
13659   /* Let the user know we're compiling this function.  */
13660   announce_function (decl1);
13661
13662   /* Record the decl so that the function name is defined.
13663      If we already have a decl for this name, and it is a FUNCTION_DECL,
13664      use the old decl.  */
13665   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13666     {
13667       /* A specialization is not used to guide overload resolution.  */
13668       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13669           && ! DECL_FUNCTION_MEMBER_P (decl1))
13670         decl1 = pushdecl (decl1);
13671       else
13672         {
13673           /* We need to set the DECL_CONTEXT. */
13674           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13675             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13676           /* And make sure we have enough default args.  */
13677           check_default_args (decl1);
13678         }
13679       fntype = TREE_TYPE (decl1);
13680     }
13681
13682   /* Reset these in case the call to pushdecl changed them.  */
13683   current_function_decl = decl1;
13684   cfun->decl = decl1;
13685
13686   /* If we are (erroneously) defining a function that we have already
13687      defined before, wipe out what we knew before.  */
13688   if (!DECL_PENDING_INLINE_P (decl1)
13689       && DECL_SAVED_FUNCTION_DATA (decl1))
13690     {
13691       free (DECL_SAVED_FUNCTION_DATA (decl1));
13692       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13693     }
13694
13695   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13696     {
13697       /* We know that this was set up by `grokclassfn'.  We do not
13698          wait until `store_parm_decls', since evil parse errors may
13699          never get us to that point.  Here we keep the consistency
13700          between `current_class_type' and `current_class_ptr'.  */
13701       tree t = DECL_ARGUMENTS (decl1);
13702
13703       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13704                           162);
13705       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13706                           19990811);
13707
13708       cp_function_chain->x_current_class_ref
13709         = build_indirect_ref (t, NULL);
13710       cp_function_chain->x_current_class_ptr = t;
13711
13712       /* Constructors and destructors need to know whether they're "in
13713          charge" of initializing virtual base classes.  */
13714       t = TREE_CHAIN (t);
13715       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13716         {
13717           current_in_charge_parm = t;
13718           t = TREE_CHAIN (t);
13719         }
13720       if (DECL_HAS_VTT_PARM_P (decl1))
13721         {
13722           if (DECL_NAME (t) != vtt_parm_identifier)
13723             abort ();
13724           current_vtt_parm = t;
13725         }
13726     }
13727
13728   if (DECL_INTERFACE_KNOWN (decl1))
13729     {
13730       tree ctx = decl_function_context (decl1);
13731
13732       if (DECL_NOT_REALLY_EXTERN (decl1))
13733         DECL_EXTERNAL (decl1) = 0;
13734
13735       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13736           && TREE_PUBLIC (ctx))
13737         /* This is a function in a local class in an extern inline
13738            function.  */
13739         comdat_linkage (decl1);
13740     }
13741   /* If this function belongs to an interface, it is public.
13742      If it belongs to someone else's interface, it is also external.
13743      This only affects inlines and template instantiations.  */
13744   else if (interface_unknown == 0
13745            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13746                || flag_alt_external_templates))
13747     {
13748       if (DECL_DECLARED_INLINE_P (decl1)
13749           || DECL_TEMPLATE_INSTANTIATION (decl1)
13750           || processing_template_decl)
13751         {
13752           DECL_EXTERNAL (decl1)
13753             = (interface_only
13754                || (DECL_DECLARED_INLINE_P (decl1)
13755                    && ! flag_implement_inlines
13756                    && !DECL_VINDEX (decl1)));
13757
13758           /* For WIN32 we also want to put these in linkonce sections.  */
13759           maybe_make_one_only (decl1);
13760         }
13761       else
13762         DECL_EXTERNAL (decl1) = 0;
13763       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13764       DECL_INTERFACE_KNOWN (decl1) = 1;
13765     }
13766   else if (interface_unknown && interface_only
13767            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13768                || flag_alt_external_templates))
13769     {
13770       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13771          interface, we will have interface_only set but not
13772          interface_known.  In that case, we don't want to use the normal
13773          heuristics because someone will supply a #pragma implementation
13774          elsewhere, and deducing it here would produce a conflict.  */
13775       comdat_linkage (decl1);
13776       DECL_EXTERNAL (decl1) = 0;
13777       DECL_INTERFACE_KNOWN (decl1) = 1;
13778       DECL_DEFER_OUTPUT (decl1) = 1;
13779     }
13780   else
13781     {
13782       /* This is a definition, not a reference.
13783          So clear DECL_EXTERNAL.  */
13784       DECL_EXTERNAL (decl1) = 0;
13785
13786       if ((DECL_DECLARED_INLINE_P (decl1)
13787            || DECL_TEMPLATE_INSTANTIATION (decl1))
13788           && ! DECL_INTERFACE_KNOWN (decl1)
13789           /* Don't try to defer nested functions for now.  */
13790           && ! decl_function_context (decl1))
13791         DECL_DEFER_OUTPUT (decl1) = 1;
13792       else
13793         DECL_INTERFACE_KNOWN (decl1) = 1;
13794     }
13795
13796   pushlevel (0);
13797   current_binding_level->parm_flag = 1;
13798
13799   cplus_decl_attributes (&decl1, attrs, 0);
13800
13801   /* Promote the value to int before returning it.  */
13802   if (c_promoting_integer_type_p (restype))
13803     restype = type_promotes_to (restype);
13804
13805   if (DECL_RESULT (decl1) == NULL_TREE)
13806     {
13807       DECL_RESULT (decl1)
13808         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13809       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13810       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13811     }
13812
13813   ++function_depth;
13814
13815   if (DECL_DESTRUCTOR_P (decl1))
13816     {
13817       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13818       DECL_CONTEXT (dtor_label) = current_function_decl;
13819     }
13820
13821   start_fname_decls ();
13822
13823   store_parm_decls (current_function_parms);
13824
13825   return 1;
13826 }
13827 \f
13828 /* Store the parameter declarations into the current function declaration.
13829    This is called after parsing the parameter declarations, before
13830    digesting the body of the function.
13831
13832    Also install to binding contour return value identifier, if any.  */
13833
13834 static void
13835 store_parm_decls (current_function_parms)
13836      tree current_function_parms;
13837 {
13838   register tree fndecl = current_function_decl;
13839   register tree parm;
13840
13841   /* This is a chain of any other decls that came in among the parm
13842      declarations.  If a parm is declared with  enum {foo, bar} x;
13843      then CONST_DECLs for foo and bar are put here.  */
13844   tree nonparms = NULL_TREE;
13845
13846   if (current_function_parms)
13847     {
13848       /* This case is when the function was defined with an ANSI prototype.
13849          The parms already have decls, so we need not do anything here
13850          except record them as in effect
13851          and complain if any redundant old-style parm decls were written.  */
13852
13853       tree specparms = current_function_parms;
13854       tree next;
13855
13856       /* Must clear this because it might contain TYPE_DECLs declared
13857              at class level.  */
13858       storedecls (NULL_TREE);
13859
13860       /* If we're doing semantic analysis, then we'll call pushdecl
13861              for each of these.  We must do them in reverse order so that
13862              they end in the correct forward order.  */
13863       specparms = nreverse (specparms);
13864
13865       for (parm = specparms; parm; parm = next)
13866         {
13867           next = TREE_CHAIN (parm);
13868           if (TREE_CODE (parm) == PARM_DECL)
13869             {
13870               if (DECL_NAME (parm) == NULL_TREE
13871                   || TREE_CODE (parm) != VOID_TYPE)
13872                 pushdecl (parm);
13873               else
13874                 error ("parameter `%D' declared void", parm);
13875             }
13876           else
13877             {
13878               /* If we find an enum constant or a type tag,
13879                  put it aside for the moment.  */
13880               TREE_CHAIN (parm) = NULL_TREE;
13881               nonparms = chainon (nonparms, parm);
13882             }
13883         }
13884
13885       /* Get the decls in their original chain order and record in the
13886          function.  This is all and only the PARM_DECLs that were
13887          pushed into scope by the loop above.  */
13888       DECL_ARGUMENTS (fndecl) = getdecls ();
13889       storetags (gettags ());
13890     }
13891   else
13892     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13893
13894   /* Now store the final chain of decls for the arguments
13895      as the decl-chain of the current lexical scope.
13896      Put the enumerators in as well, at the front so that
13897      DECL_ARGUMENTS is not modified.  */
13898   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13899
13900   /* Do the starting of the exception specifications, if we have any.  */
13901   if (flag_exceptions && !processing_template_decl
13902       && flag_enforce_eh_specs
13903       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13904     current_eh_spec_block = begin_eh_spec_block ();
13905 }
13906
13907 \f
13908 /* We have finished doing semantic analysis on DECL, but have not yet
13909    generated RTL for its body.  Save away our current state, so that
13910    when we want to generate RTL later we know what to do.  */
13911
13912 static void
13913 save_function_data (decl)
13914      tree decl;
13915 {
13916   struct cp_language_function *f;
13917
13918   /* Save the language-specific per-function data so that we can
13919      get it back when we really expand this function.  */
13920   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13921                       19990908);
13922
13923   /* Make a copy.  */
13924   f = ((struct cp_language_function *)
13925        xmalloc (sizeof (struct cp_language_function)));
13926   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13927   DECL_SAVED_FUNCTION_DATA (decl) = f;
13928
13929   /* Clear out the bits we don't need.  */
13930   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13931   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13932   f->x_named_label_uses = NULL;
13933   f->bindings = NULL;
13934   f->x_local_names = NULL;
13935
13936   /* When we get back here again, we will be expanding.  */
13937   f->x_expanding_p = 1;
13938
13939   /* If we've already decided that we cannot inline this function, we
13940      must remember that fact when we actually go to expand the
13941      function.  */
13942   if (current_function_cannot_inline)
13943     {
13944       f->cannot_inline = current_function_cannot_inline;
13945       DECL_INLINE (decl) = 0;
13946     }
13947 }
13948
13949 /* Add a note to mark the beginning of the main body of the constructor.
13950    This is used to set up the data structures for the cleanup regions for
13951    fully-constructed bases and members.  */
13952
13953 static void
13954 begin_constructor_body ()
13955 {
13956   tree ctor_stmt = build_stmt (CTOR_STMT);
13957   CTOR_BEGIN_P (ctor_stmt) = 1;
13958   add_stmt (ctor_stmt);
13959 }
13960
13961 /* Add a note to mark the end of the main body of the constructor.  This is
13962    used to end the cleanup regions for fully-constructed bases and
13963    members.  */
13964
13965 static void
13966 finish_constructor_body ()
13967 {
13968   /* Mark the end of the cleanups for a partially constructed object.
13969
13970      ??? These should really be handled automatically by closing the block,
13971      as with the destructor cleanups; the only difference is that these are
13972      only run if an exception is thrown.  */
13973   add_stmt (build_stmt (CTOR_STMT));
13974 }
13975
13976 /* Do all the processing for the beginning of a destructor; set up the
13977    vtable pointers and cleanups for bases and members.  */
13978
13979 static void
13980 begin_destructor_body ()
13981 {
13982   tree if_stmt;
13983   tree compound_stmt;
13984
13985   /* If the dtor is empty, and we know there is not any possible
13986      way we could use any vtable entries, before they are possibly
13987      set by a base class dtor, we don't have to setup the vtables,
13988      as we know that any base class dtor will set up any vtables
13989      it needs.  We avoid MI, because one base class dtor can do a
13990      virtual dispatch to an overridden function that would need to
13991      have a non-related vtable set up, we cannot avoid setting up
13992      vtables in that case.  We could change this to see if there
13993      is just one vtable.
13994
13995      ??? In the destructor for a class, the vtables are set
13996      appropriately for that class.  There will be no non-related
13997      vtables.  jason 2001-12-11.  */
13998   if_stmt = begin_if_stmt ();
13999
14000   /* If it is not safe to avoid setting up the vtables, then
14001      someone will change the condition to be boolean_true_node.
14002      (Actually, for now, we do not have code to set the condition
14003      appropriately, so we just assume that we always need to
14004      initialize the vtables.)  */
14005   finish_if_stmt_cond (boolean_true_node, if_stmt);
14006   current_vcalls_possible_p = &IF_COND (if_stmt);
14007
14008   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14009
14010   /* Make all virtual function table pointers in non-virtual base
14011      classes point to CURRENT_CLASS_TYPE's virtual function
14012      tables.  */
14013   initialize_vtbl_ptrs (current_class_ptr);
14014
14015   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14016   finish_then_clause (if_stmt);
14017   finish_if_stmt ();
14018
14019   /* And insert cleanups for our bases and members so that they
14020      will be properly destroyed if we throw.  */
14021   push_base_cleanups ();
14022 }
14023
14024 /* At the end of every destructor we generate code to delete the object if
14025    necessary.  Do that now.  */
14026
14027 static void
14028 finish_destructor_body ()
14029 {
14030   tree exprstmt;
14031
14032   /* In a virtual destructor, we must call delete.  */
14033   if (DECL_VIRTUAL_P (current_function_decl))
14034     {
14035       tree if_stmt;
14036       tree virtual_size = c_sizeof (current_class_type);
14037
14038       /* [class.dtor]
14039
14040       At the point of definition of a virtual destructor (including
14041       an implicit definition), non-placement operator delete shall
14042       be looked up in the scope of the destructor's class and if
14043       found shall be accessible and unambiguous.  */
14044       exprstmt = build_op_delete_call
14045         (DELETE_EXPR, current_class_ptr, virtual_size,
14046          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14047
14048       if_stmt = begin_if_stmt ();
14049       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14050                                   current_in_charge_parm,
14051                                   integer_one_node),
14052                            if_stmt);
14053       finish_expr_stmt (exprstmt);
14054       finish_then_clause (if_stmt);
14055       finish_if_stmt ();
14056     }
14057 }
14058
14059 /* Do the necessary processing for the beginning of a function body, which
14060    in this case includes member-initializers, but not the catch clauses of
14061    a function-try-block.  Currently, this means opening a binding level
14062    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14063    In other functions, this isn't necessary, but it doesn't hurt.  */
14064
14065 tree
14066 begin_function_body ()
14067 {
14068   tree stmt;
14069
14070   if (processing_template_decl)
14071     /* Do nothing now.  */;
14072   else
14073     /* Always keep the BLOCK node associated with the outermost pair of
14074        curly braces of a function.  These are needed for correct
14075        operation of dwarfout.c.  */
14076     keep_next_level (1);
14077
14078   stmt = begin_compound_stmt (0);
14079   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14080
14081   if (processing_template_decl)
14082     /* Do nothing now.  */;
14083   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14084     begin_constructor_body ();
14085   else if (DECL_DESTRUCTOR_P (current_function_decl))
14086     begin_destructor_body ();
14087
14088   return stmt;
14089 }
14090
14091 /* Do the processing for the end of a function body.  Currently, this means
14092    closing out the cleanups for fully-constructed bases and members, and in
14093    the case of the destructor, deleting the object if desired.  Again, this
14094    is only meaningful for [cd]tors, since they are the only functions where
14095    there is a significant distinction between the main body and any
14096    function catch clauses.  Handling, say, main() return semantics here
14097    would be wrong, as flowing off the end of a function catch clause for
14098    main() would also need to return 0.  */
14099
14100 void
14101 finish_function_body (compstmt)
14102      tree compstmt;
14103 {
14104   if (processing_template_decl)
14105     /* Do nothing now.  */;
14106   else if (DECL_DESTRUCTOR_P (current_function_decl))
14107     /* Any return from a destructor will end up here.  Put it before the
14108        cleanups so that an explicit return doesn't duplicate them.  */
14109     add_stmt (build_stmt (LABEL_STMT, dtor_label));
14110
14111   /* Close the block; in a destructor, run the member cleanups.  */
14112   finish_compound_stmt (0, compstmt);
14113
14114   if (processing_template_decl)
14115     /* Do nothing now.  */;
14116   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14117     finish_constructor_body ();
14118   else if (DECL_DESTRUCTOR_P (current_function_decl))
14119     finish_destructor_body ();
14120 }
14121
14122 /* Finish up a function declaration and compile that function
14123    all the way to assembler language output.  The free the storage
14124    for the function definition.
14125
14126    FLAGS is a bitwise or of the following values:
14127      2 - INCLASS_INLINE
14128        We just finished processing the body of an in-class inline
14129        function definition.  (This processing will have taken place
14130        after the class definition is complete.)  */
14131
14132 tree
14133 finish_function (flags)
14134      int flags;
14135 {
14136   register tree fndecl = current_function_decl;
14137   tree fntype, ctype = NULL_TREE;
14138   int inclass_inline = (flags & 2) != 0;
14139   int nested;
14140
14141   /* When we get some parse errors, we can end up without a
14142      current_function_decl, so cope.  */
14143   if (fndecl == NULL_TREE)
14144     return error_mark_node;
14145
14146   nested = function_depth > 1;
14147   fntype = TREE_TYPE (fndecl);
14148
14149   /*  TREE_READONLY (fndecl) = 1;
14150       This caused &foo to be of type ptr-to-const-function
14151       which then got a warning when stored in a ptr-to-function variable.  */
14152
14153   my_friendly_assert (building_stmt_tree (), 20000911);
14154
14155   finish_fname_decls ();
14156
14157   /* For a cloned function, we've already got all the code we need;
14158      there's no need to add any extra bits.  */
14159   if (!DECL_CLONED_FUNCTION_P (fndecl))
14160     {
14161       if (DECL_MAIN_P (current_function_decl))
14162         {
14163           /* Make it so that `main' always returns 0 by default.  */
14164 #ifdef VMS_TARGET
14165           finish_return_stmt (integer_one_node);
14166 #else
14167           finish_return_stmt (integer_zero_node);
14168 #endif
14169         }
14170
14171       /* Finish dealing with exception specifiers.  */
14172       if (flag_exceptions && !processing_template_decl
14173           && flag_enforce_eh_specs
14174           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14175         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14176                               (TREE_TYPE (current_function_decl)),
14177                               current_eh_spec_block);
14178     }
14179
14180   /* If we're saving up tree structure, tie off the function now.  */
14181   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14182
14183   /* This must come after expand_function_end because cleanups might
14184      have declarations (from inline functions) that need to go into
14185      this function's blocks.  */
14186
14187   /* If the current binding level isn't the outermost binding level
14188      for this function, either there is a bug, or we have experienced
14189      syntax errors and the statement tree is malformed.  */
14190   if (current_binding_level->parm_flag != 1)
14191     {
14192       /* Make sure we have already experienced errors.  */
14193       if (errorcount == 0)
14194         abort ();
14195
14196       /* Throw away the broken statement tree and extra binding
14197          levels.  */
14198       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14199
14200       while (current_binding_level->parm_flag != 1)
14201         {
14202           if (current_binding_level->parm_flag == 2)
14203             pop_nested_class ();
14204           else
14205             poplevel (0, 0, 0);
14206         }
14207     }
14208   poplevel (1, 0, 1);
14209
14210   /* Set up the named return value optimization, if we can.  Here, we
14211      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14212      for the nrv.  genrtl_start_function and declare_return_variable
14213      handle making the nrv and RESULT_DECL share space.  */
14214   if (current_function_return_value)
14215     {
14216       tree r = current_function_return_value;
14217       /* This is only worth doing for fns that return in memory--and
14218          simpler, since we don't have to worry about promoted modes.  */
14219       if (r != error_mark_node
14220           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14221         {
14222           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14223           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14224                                         nullify_returns_r, r);
14225         }
14226       else
14227         /* Clear it so genrtl_start_function and declare_return_variable
14228            know we're not optimizing.  */
14229         current_function_return_value = NULL_TREE;
14230     }
14231
14232   /* Remember that we were in class scope.  */
14233   if (current_class_name)
14234     ctype = current_class_type;
14235
14236   /* Must mark the RESULT_DECL as being in this function.  */
14237   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14238
14239   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14240      to the FUNCTION_DECL node itself.  */
14241   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14242
14243   /* Save away current state, if appropriate.  */
14244   if (!processing_template_decl)
14245     save_function_data (fndecl);
14246
14247   /* If this function calls `setjmp' it cannot be inlined.  When
14248      `longjmp' is called it is not guaranteed to restore the value of
14249      local variables that have been modified since the call to
14250      `setjmp'.  So, if were to inline this function into some caller
14251      `c', then when we `longjmp', we might not restore all variables
14252      in `c'.  (It might seem, at first blush, that there's no way for
14253      this function to modify local variables in `c', but their
14254      addresses may have been stored somewhere accessible to this
14255      function.)  */
14256   if (!processing_template_decl && calls_setjmp_p (fndecl))
14257     DECL_UNINLINABLE (fndecl) = 1;
14258
14259   /* Clear out memory we no longer need.  */
14260   free_after_parsing (cfun);
14261   /* Since we never call rest_of_compilation, we never clear
14262      CFUN.  Do so explicitly.  */
14263   free_after_compilation (cfun);
14264   cfun = NULL;
14265
14266   /* If this is a in-class inline definition, we may have to pop the
14267      bindings for the template parameters that we added in
14268      maybe_begin_member_template_processing when start_function was
14269      called.  */
14270   if (inclass_inline)
14271     maybe_end_member_template_processing ();
14272
14273   /* Leave the scope of the class.  */
14274   if (ctype)
14275     pop_nested_class ();
14276
14277   --function_depth;
14278
14279   /* Clean up.  */
14280   if (! nested)
14281     /* Let the error reporting routines know that we're outside a
14282        function.  For a nested function, this value is used in
14283        pop_cp_function_context and then reset via pop_function_context.  */
14284     current_function_decl = NULL_TREE;
14285
14286   return fndecl;
14287 }
14288 \f
14289 /* Create the FUNCTION_DECL for a function definition.
14290    DECLSPECS and DECLARATOR are the parts of the declaration;
14291    they describe the return type and the name of the function,
14292    but twisted together in a fashion that parallels the syntax of C.
14293
14294    This function creates a binding context for the function body
14295    as well as setting up the FUNCTION_DECL in current_function_decl.
14296
14297    Returns a FUNCTION_DECL on success.
14298
14299    If the DECLARATOR is not suitable for a function (it defines a datum
14300    instead), we return 0, which tells yyparse to report a parse error.
14301
14302    May return void_type_node indicating that this method is actually
14303    a friend.  See grokfield for more details.
14304
14305    Came here with a `.pushlevel' .
14306
14307    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14308    CHANGES TO CODE IN `grokfield'.  */
14309
14310 tree
14311 start_method (declspecs, declarator, attrlist)
14312      tree declarator, declspecs, attrlist;
14313 {
14314   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14315                                 &attrlist);
14316
14317   /* Something too ugly to handle.  */
14318   if (fndecl == NULL_TREE)
14319     return NULL_TREE;
14320
14321   if (attrlist)
14322     cplus_decl_attributes (&fndecl, attrlist, 0);
14323
14324   /* Pass friends other than inline friend functions back.  */
14325   if (fndecl == void_type_node)
14326     return fndecl;
14327
14328   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14329     /* Not a function, tell parser to report parse error.  */
14330     return NULL_TREE;
14331
14332   if (DECL_IN_AGGR_P (fndecl))
14333     {
14334       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14335         {
14336           if (DECL_CONTEXT (fndecl)
14337               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14338             error ("`%D' is already defined in class `%T'", fndecl,
14339                       DECL_CONTEXT (fndecl));
14340         }
14341       return void_type_node;
14342     }
14343
14344   check_template_shadow (fndecl);
14345
14346   DECL_DECLARED_INLINE_P (fndecl) = 1;
14347
14348   if (flag_default_inline)
14349     DECL_INLINE (fndecl) = 1;
14350
14351   /* We process method specializations in finish_struct_1.  */
14352   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14353     fndecl = push_template_decl (fndecl);
14354
14355   if (! DECL_FRIEND_P (fndecl))
14356     {
14357       if (TREE_CHAIN (fndecl))
14358         {
14359           fndecl = copy_node (fndecl);
14360           TREE_CHAIN (fndecl) = NULL_TREE;
14361         }
14362       grok_special_member_properties (fndecl);
14363     }
14364
14365   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14366
14367   /* Make a place for the parms */
14368   pushlevel (0);
14369   current_binding_level->parm_flag = 1;
14370
14371   DECL_IN_AGGR_P (fndecl) = 1;
14372   return fndecl;
14373 }
14374
14375 /* Go through the motions of finishing a function definition.
14376    We don't compile this method until after the whole class has
14377    been processed.
14378
14379    FINISH_METHOD must return something that looks as though it
14380    came from GROKFIELD (since we are defining a method, after all).
14381
14382    This is called after parsing the body of the function definition.
14383    STMTS is the chain of statements that makes up the function body.
14384
14385    DECL is the ..._DECL that `start_method' provided.  */
14386
14387 tree
14388 finish_method (decl)
14389      tree decl;
14390 {
14391   register tree fndecl = decl;
14392   tree old_initial;
14393
14394   register tree link;
14395
14396   if (decl == void_type_node)
14397     return decl;
14398
14399   old_initial = DECL_INITIAL (fndecl);
14400
14401   /* Undo the level for the parms (from start_method).
14402      This is like poplevel, but it causes nothing to be
14403      saved.  Saving information here confuses symbol-table
14404      output routines.  Besides, this information will
14405      be correctly output when this method is actually
14406      compiled.  */
14407
14408   /* Clear out the meanings of the local variables of this level;
14409      also record in each decl which block it belongs to.  */
14410
14411   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14412     {
14413       if (DECL_NAME (link) != NULL_TREE)
14414         pop_binding (DECL_NAME (link), link);
14415       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14416       DECL_CONTEXT (link) = NULL_TREE;
14417     }
14418
14419   GNU_xref_end_scope ((size_t) current_binding_level,
14420                       (size_t) current_binding_level->level_chain,
14421                       current_binding_level->parm_flag,
14422                       current_binding_level->keep);
14423
14424   poplevel (0, 0, 0);
14425
14426   DECL_INITIAL (fndecl) = old_initial;
14427
14428   /* We used to check if the context of FNDECL was different from
14429      current_class_type as another way to get inside here.  This didn't work
14430      for String.cc in libg++.  */
14431   if (DECL_FRIEND_P (fndecl))
14432     {
14433       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14434         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14435       decl = void_type_node;
14436     }
14437
14438   return decl;
14439 }
14440 \f
14441 /* Called when a new struct TYPE is defined.
14442    If this structure or union completes the type of any previous
14443    variable declaration, lay it out and output its rtl.  */
14444
14445 void
14446 hack_incomplete_structures (type)
14447      tree type;
14448 {
14449   tree *list;
14450   struct binding_level *level;
14451
14452   if (!type) /* Don't do this for class templates.  */
14453     return;
14454
14455   if (namespace_bindings_p ())
14456     {
14457       level = 0;
14458       list = &namespace_scope_incomplete;
14459     }
14460   else
14461     {
14462       level = innermost_nonclass_level ();
14463       list = &level->incomplete;
14464     }
14465
14466   while (1)
14467     {
14468       while (*list)
14469         {
14470           tree decl = TREE_VALUE (*list);
14471           if ((decl && TREE_TYPE (decl) == type)
14472               || (TREE_TYPE (decl)
14473                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14474                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14475             {
14476               int toplevel = toplevel_bindings_p ();
14477               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14478                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14479                 layout_type (TREE_TYPE (decl));
14480               layout_decl (decl, 0);
14481               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14482               if (! toplevel)
14483                 {
14484                   tree cleanup;
14485                   expand_decl (decl);
14486                   cleanup = maybe_build_cleanup (decl);
14487                   expand_decl_init (decl);
14488                   if (! expand_decl_cleanup (decl, cleanup))
14489                     error ("parser lost in parsing declaration of `%D'",
14490                               decl);
14491                 }
14492               *list = TREE_CHAIN (*list);
14493             }
14494           else
14495             list = &TREE_CHAIN (*list);
14496         }
14497
14498       /* Keep looking through artificial binding levels generated
14499          for local variables.  */
14500       if (level && level->keep == 2)
14501         {
14502           level = level->level_chain;
14503           list = &level->incomplete;
14504         }
14505       else
14506         break;
14507     }
14508 }
14509
14510 /* If DECL is of a type which needs a cleanup, build that cleanup
14511    here.  */
14512
14513 tree
14514 maybe_build_cleanup (decl)
14515      tree decl;
14516 {
14517   tree type = TREE_TYPE (decl);
14518
14519   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14520     {
14521       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14522       tree rval;
14523
14524       if (TREE_CODE (type) == ARRAY_TYPE)
14525         rval = decl;
14526       else
14527         {
14528           mark_addressable (decl);
14529           rval = build_unary_op (ADDR_EXPR, decl, 0);
14530         }
14531
14532       /* Optimize for space over speed here.  */
14533       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14534           || flag_expensive_optimizations)
14535         flags |= LOOKUP_NONVIRTUAL;
14536
14537       rval = build_delete (TREE_TYPE (rval), rval,
14538                            sfk_complete_destructor, flags, 0);
14539
14540       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14541           && ! TYPE_HAS_DESTRUCTOR (type))
14542         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14543                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14544
14545       return rval;
14546     }
14547   return 0;
14548 }
14549 \f
14550 /* When a stmt has been parsed, this function is called.  */
14551
14552 void
14553 finish_stmt ()
14554 {
14555   /* Always assume this statement was not an expression statement.  If
14556      it actually was an expression statement, its our callers
14557      responsibility to fix this up.  */
14558   last_expr_type = NULL_TREE;
14559 }
14560
14561 /* DECL was originally constructed as a non-static member function,
14562    but turned out to be static.  Update it accordingly.  */
14563
14564 void
14565 revert_static_member_fn (decl)
14566      tree decl;
14567 {
14568   tree tmp;
14569   tree function = TREE_TYPE (decl);
14570   tree args = TYPE_ARG_TYPES (function);
14571
14572   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14573       != TYPE_UNQUALIFIED)
14574     error ("static member function `%#D' declared with type qualifiers",
14575               decl);
14576
14577   args = TREE_CHAIN (args);
14578   tmp = build_function_type (TREE_TYPE (function), args);
14579   tmp = build_qualified_type (tmp, cp_type_quals (function));
14580   tmp = build_exception_variant (tmp,
14581                                  TYPE_RAISES_EXCEPTIONS (function));
14582   TREE_TYPE (decl) = tmp;
14583   if (DECL_ARGUMENTS (decl))
14584     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14585   DECL_STATIC_FUNCTION_P (decl) = 1;
14586 }
14587
14588 /* Initialize the variables used during compilation of a C++
14589    function.  */
14590
14591 static void
14592 push_cp_function_context (f)
14593      struct function *f;
14594 {
14595   struct cp_language_function *p
14596     = ((struct cp_language_function *)
14597        xcalloc (1, sizeof (struct cp_language_function)));
14598   f->language = (struct language_function *) p;
14599
14600   /* It takes an explicit call to expand_body to generate RTL for a
14601      function.  */
14602   expanding_p = 0;
14603
14604   /* Whenever we start a new function, we destroy temporaries in the
14605      usual way.  */
14606   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14607 }
14608
14609 /* Free the language-specific parts of F, now that we've finished
14610    compiling the function.  */
14611
14612 static void
14613 pop_cp_function_context (f)
14614      struct function *f;
14615 {
14616   if (f->language)
14617     {
14618       struct cp_language_function *cp =
14619         (struct cp_language_function *) f->language;
14620       if (cp->x_local_names)
14621         VARRAY_FREE (cp->x_local_names);
14622       free (f->language);
14623     }
14624   f->language = 0;
14625 }
14626
14627 /* Mark P for GC.  */
14628
14629 static void
14630 mark_lang_function (p)
14631      struct cp_language_function *p;
14632 {
14633   if (!p)
14634     return;
14635
14636   mark_c_language_function (&p->base);
14637
14638   ggc_mark_tree (p->x_dtor_label);
14639   ggc_mark_tree (p->x_current_class_ptr);
14640   ggc_mark_tree (p->x_current_class_ref);
14641   ggc_mark_tree (p->x_eh_spec_block);
14642   ggc_mark_tree_varray (p->x_local_names);
14643
14644   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14645   mark_binding_level (&p->bindings);
14646   mark_pending_inlines (&p->unparsed_inlines);
14647 }
14648
14649 /* Mark the language-specific data in F for GC.  */
14650
14651 static void
14652 mark_cp_function_context (f)
14653      struct function *f;
14654 {
14655   mark_lang_function ((struct cp_language_function *) f->language);
14656 }
14657
14658 void
14659 lang_mark_tree (t)
14660      tree t;
14661 {
14662   enum tree_code code = TREE_CODE (t);
14663   if (code == IDENTIFIER_NODE)
14664     {
14665       struct lang_identifier *li = (struct lang_identifier *) t;
14666       struct lang_id2 *li2 = li->x;
14667       ggc_mark_tree (li->namespace_bindings);
14668       ggc_mark_tree (li->bindings);
14669       ggc_mark_tree (li->class_value);
14670       ggc_mark_tree (li->class_template_info);
14671
14672       if (li2)
14673         {
14674           ggc_mark_tree (li2->label_value);
14675           ggc_mark_tree (li2->implicit_decl);
14676           ggc_mark_tree (li2->error_locus);
14677         }
14678     }
14679   else if (code == CPLUS_BINDING)
14680     {
14681       if (BINDING_HAS_LEVEL_P (t))
14682         mark_binding_level (&BINDING_LEVEL (t));
14683       else
14684         ggc_mark_tree (BINDING_SCOPE (t));
14685       ggc_mark_tree (BINDING_VALUE (t));
14686     }
14687   else if (code == OVERLOAD)
14688     ggc_mark_tree (OVL_FUNCTION (t));
14689   else if (code == TEMPLATE_PARM_INDEX)
14690     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14691   else if (TREE_CODE_CLASS (code) == 'd')
14692     {
14693       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14694
14695       if (ld)
14696         {
14697           ggc_mark (ld);
14698           c_mark_lang_decl (&ld->decl_flags.base);
14699           if (!DECL_GLOBAL_CTOR_P (t)
14700               && !DECL_GLOBAL_DTOR_P (t)
14701               && !DECL_THUNK_P (t)
14702               && !DECL_DISCRIMINATOR_P (t))
14703             ggc_mark_tree (ld->decl_flags.u2.access);
14704           else if (DECL_THUNK_P (t))
14705             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14706           if (TREE_CODE (t) != NAMESPACE_DECL)
14707             ggc_mark_tree (ld->decl_flags.u.template_info);
14708           else
14709             mark_binding_level (&NAMESPACE_LEVEL (t));
14710           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14711             {
14712               ggc_mark_tree (ld->befriending_classes);
14713               ggc_mark_tree (ld->context);
14714               ggc_mark_tree (ld->cloned_function);
14715               if (TREE_CODE (t) == TYPE_DECL)
14716                 ggc_mark_tree (ld->u.sorted_fields);
14717               else if (TREE_CODE (t) == FUNCTION_DECL
14718                        && !DECL_PENDING_INLINE_P (t))
14719                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14720             }
14721         }
14722     }
14723   else if (TREE_CODE_CLASS (code) == 't')
14724     {
14725       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14726
14727       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14728                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14729         {
14730           ggc_mark (lt);
14731           ggc_mark_tree (lt->primary_base);
14732           ggc_mark_tree (lt->vfields);
14733           ggc_mark_tree (lt->vbases);
14734           ggc_mark_tree (lt->tags);
14735           ggc_mark_tree (lt->size);
14736           ggc_mark_tree (lt->pure_virtuals);
14737           ggc_mark_tree (lt->friend_classes);
14738           ggc_mark_tree (lt->rtti);
14739           ggc_mark_tree (lt->methods);
14740           ggc_mark_tree (lt->template_info);
14741           ggc_mark_tree (lt->befriending_classes);
14742         }
14743       else if (lt)
14744         /* In the case of pointer-to-member function types, the
14745            TYPE_LANG_SPECIFIC is really just a tree.  */
14746         ggc_mark_tree ((tree) lt);
14747     }
14748 }
14749
14750 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14751    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14752
14753 tree
14754 identifier_global_value (t)
14755      tree t;
14756 {
14757   return IDENTIFIER_GLOBAL_VALUE (t);
14758 }
14759
14760 /* Build the void_list_node (void_type_node having been created).  */
14761 tree
14762 build_void_list_node ()
14763 {
14764   tree t = build_tree_list (NULL_TREE, void_type_node);
14765   TREE_PARMLIST (t) = 1;
14766   return t;
14767 }
14768
14769 static int
14770 cp_missing_noreturn_ok_p (decl)
14771      tree decl;
14772 {
14773   /* A missing noreturn is ok for the `main' function.  */
14774   return DECL_MAIN_P (decl);
14775 }