gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "ggc.h"
  46
  47 extern int current_class_depth;
  48
  49 extern tree global_namespace;
  50
  51 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  52
  53 #ifndef BOOL_TYPE_SIZE
  54 #ifdef SLOW_BYTE_ACCESS
  55 /* In the new ABI, `bool' has size and alignment `1', on all
  56    platforms.  */
  57 #define BOOL_TYPE_SIZE \
  58   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  59 #else
  60 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  61 #endif
  62 #endif
  63
  64 /* We let tm.h override the types used here, to handle trivial differences
  65    such as the choice of unsigned int or long unsigned int for size_t.
  66    When machines start needing nontrivial differences in the size type,
  67    it would be best to do something here to figure out automatically
  68    from other information what type to use.  */
  69
  70 #ifndef SIZE_TYPE
  71 #define SIZE_TYPE "long unsigned int"
  72 #endif
  73
  74 #ifndef PTRDIFF_TYPE
  75 #define PTRDIFF_TYPE "long int"
  76 #endif
  77
  78 #ifndef WCHAR_TYPE
  79 #define WCHAR_TYPE "int"
  80 #endif
  81
  82 #ifndef WINT_TYPE
  83 #define WINT_TYPE "unsigned int"
  84 #endif
  85
  86 #ifndef INTMAX_TYPE
  87 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  88                      ? "int"                                    \
  89                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  90                         ? "long int"                            \
  91                         : "long long int"))
  92 #endif
  93
  94 #ifndef UINTMAX_TYPE
  95 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  96                      ? "unsigned int"                           \
  97                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  98                         ? "long unsigned int"                   \
  99                         : "long long unsigned int"))
 100 #endif
 101
 102 static tree grokparms                           PARAMS ((tree, int));
 103 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 104
 105 static void push_binding_level PARAMS ((struct binding_level *, int,
 106                                       int));
 107 static void pop_binding_level PARAMS ((void));
 108 static void suspend_binding_level PARAMS ((void));
 109 static void resume_binding_level PARAMS ((struct binding_level *));
 110 static struct binding_level *make_binding_level PARAMS ((void));
 111 static void declare_namespace_level PARAMS ((void));
 112 static int decl_jump_unsafe PARAMS ((tree));
 113 static void storedecls PARAMS ((tree));
 114 static void require_complete_types_for_parms PARAMS ((tree));
 115 static int ambi_op_p PARAMS ((enum tree_code));
 116 static int unary_op_p PARAMS ((enum tree_code));
 117 static tree store_bindings PARAMS ((tree, tree));
 118 static tree lookup_tag_reverse PARAMS ((tree, tree));
 119 static tree obscure_complex_init PARAMS ((tree, tree));
 120 static tree lookup_name_real PARAMS ((tree, int, int, int));
 121 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 122 static void grok_reference_init PARAMS ((tree, tree, tree));
 123 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 124                               enum overload_flags, tree,
 125                               tree, int, int, int, int, int, int, tree));
 126 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 127 static tree lookup_tag PARAMS ((enum tree_code, tree,
 128                               struct binding_level *, int));
 129 static void set_identifier_type_value_with_scope
 130         PARAMS ((tree, tree, struct binding_level *));
 131 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 132 static void record_unknown_type PARAMS ((tree, const char *));
 133 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 134 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 135 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 136                                   int));
 137 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 138 static void check_for_uninitialized_const_var PARAMS ((tree));
 139 static unsigned long typename_hash PARAMS ((hash_table_key));
 140 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 141 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 142 static int add_binding PARAMS ((tree, tree));
 143 static void pop_binding PARAMS ((tree, tree));
 144 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 145 static tree find_binding PARAMS ((tree, tree));
 146 static tree select_decl PARAMS ((tree, int));
 147 static int lookup_flags PARAMS ((int, int));
 148 static tree qualify_lookup PARAMS ((tree, int));
 149 static tree record_builtin_java_type PARAMS ((const char *, int));
 150 static const char *tag_name PARAMS ((enum tag_types code));
 151 static void find_class_binding_level PARAMS ((void));
 152 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 153 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 154 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 155 static int walk_globals_r PARAMS ((tree, void *));
 156 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 157 static tree make_label_decl PARAMS ((tree, int));
 158 static void use_label PARAMS ((tree));
 159 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 160                                            const char *, int));
 161 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 162 static void check_switch_goto PARAMS ((struct binding_level *));
 163 static void check_previous_gotos PARAMS ((tree));
 164 static void pop_label PARAMS ((tree, tree));
 165 static void pop_labels PARAMS ((tree));
 166 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 167 static void layout_var_decl PARAMS ((tree));
 168 static void maybe_commonize_var PARAMS ((tree));
 169 static tree check_initializer PARAMS ((tree, tree));
 170 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 171 static void push_cp_function_context PARAMS ((struct function *));
 172 static void pop_cp_function_context PARAMS ((struct function *));
 173 static void mark_binding_level PARAMS ((void *));
 174 static void mark_named_label_lists PARAMS ((void *, void *));
 175 static void mark_cp_function_context PARAMS ((struct function *));
 176 static void mark_saved_scope PARAMS ((void *));
 177 static void mark_lang_function PARAMS ((struct cp_language_function *));
 178 static void save_function_data PARAMS ((tree));
 179 static void check_function_type PARAMS ((tree, tree));
 180 static void destroy_local_var PARAMS ((tree));
 181 static void finish_constructor_body PARAMS ((void));
 182 static void finish_destructor_body PARAMS ((void));
 183 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 184 static tree get_atexit_node PARAMS ((void));
 185 static tree get_dso_handle_node PARAMS ((void));
 186 static tree start_cleanup_fn PARAMS ((void));
 187 static void end_cleanup_fn PARAMS ((void));
 188 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 189 static void initialize_predefined_identifiers PARAMS ((void));
 190 static tree check_special_function_return_type
 191   PARAMS ((special_function_kind, tree, tree, tree));
 192 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 193 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 194 static void store_parm_decls PARAMS ((tree));
 195
 196 #if defined (DEBUG_CP_BINDING_LEVELS)
 197 static void indent PARAMS ((void));
 198 #endif
 199
 200 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 201 tree error_mark_list;
 202
 203 /* The following symbols are subsumed in the cp_global_trees array, and
 204    listed here individually for documentation purposes.
 205
 206    C++ extensions
 207         tree wchar_decl_node;
 208
 209         tree vtable_entry_type;
 210         tree delta_type_node;
 211 #if 0
 212    Old rtti stuff.
 213         tree __baselist_desc_type_node;
 214         tree __i_desc_type_node, __m_desc_type_node;
 215         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 216 #endif
 217         tree __t_desc_type_node;
 218 #if 0
 219         tree __tp_desc_type_node;
 220 #endif
 221         tree ti_desc_type_node;
 222         tree bltn_desc_type_node, ptr_desc_type_node;
 223         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 224         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 225         tree ptm_desc_type_node;
 226         tree base_desc_type_node;
 227 #if 0
 228    Not needed yet?  May be needed one day?
 229         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 230         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 231         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 232 #endif
 233
 234         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 235         tree unknown_type_node;
 236
 237    Array type `vtable_entry_type[]'
 238
 239         tree vtbl_type_node;
 240         tree vtbl_ptr_type_node;
 241
 242    Namespaces,
 243
 244         tree std_node;
 245         tree abi_node;
 246
 247    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 248    one that the user will declare, but sufficient to be called
 249    by routines that want to abort the program.
 250
 251         tree abort_fndecl;
 252
 253    The FUNCTION_DECL for the default `::operator delete'.
 254
 255         tree global_delete_fndecl;
 256
 257    Used by RTTI
 258         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 259         tree tinfo_var_id;
 260
 261 */
 262
 263 tree cp_global_trees[CPTI_MAX];
 264
 265 /* Indicates that there is a type value in some namespace, although
 266    that is not necessarily in scope at the moment.  */
 267
 268 static tree global_type_node;
 269
 270 /* If non-zero, this is the number of times we have entered the `std'
 271    namespace when we are treating that namespace as an alias for the
 272    global namespace.  */
 273 static int in_fake_std;
 274
 275 /* Expect only namespace names now. */
 276 static int only_namespace_names;
 277
 278 /* Used only for jumps to as-yet undefined labels, since jumps to
 279    defined labels can have their validity checked immediately.  */
 280
 281 struct named_label_use_list
 282 {
 283   struct binding_level *binding_level;
 284   tree names_in_scope;
 285   tree label_decl;
 286   const char *filename_o_goto;
 287   int lineno_o_goto;
 288   struct named_label_use_list *next;
 289 };
 290
 291 #define named_label_uses cp_function_chain->x_named_label_uses
 292
 293 /* A list of objects which have constructors or destructors
 294    which reside in the global scope.  The decl is stored in
 295    the TREE_VALUE slot and the initializer is stored
 296    in the TREE_PURPOSE slot.  */
 297 tree static_aggregates;
 298
 299 /* -- end of C++ */
 300
 301 /* A node for the integer constants 2, and 3.  */
 302
 303 tree integer_two_node, integer_three_node;
 304
 305 /* Parsing a function declarator leaves here a chain of structure
 306    and enum types declared in the parmlist.  */
 307
 308 static tree last_function_parm_tags;
 309
 310 /* Similar, for last_function_parm_tags.  */
 311 tree last_function_parms;
 312 static tree current_function_parm_tags;
 313
 314 /* A list of all LABEL_DECLs in the function that have names.  Here so
 315    we can clear out their names' definitions at the end of the
 316    function, and so we can check the validity of jumps to these labels.  */
 317
 318 struct named_label_list
 319 {
 320   struct binding_level *binding_level;
 321   tree names_in_scope;
 322   tree old_value;
 323   tree label_decl;
 324   tree bad_decls;
 325   int eh_region;
 326   struct named_label_list *next;
 327 };
 328
 329 #define named_labels cp_function_chain->x_named_labels
 330
 331 /* Set to 0 at beginning of a function definition, and whenever
 332    a label (case or named) is defined.  Set to value of expression
 333    returned from function when that value can be transformed into
 334    a named return value.  */
 335
 336 tree current_function_return_value;
 337
 338 /* Nonzero means use the ISO C94 dialect of C.  */
 339
 340 int flag_isoc94;
 341
 342 /* Nonzero means use the ISO C99 dialect of C.  */
 343
 344 int flag_isoc99;
 345
 346 /* Nonzero means we are a hosted implementation for code shared with C.  */
 347
 348 int flag_hosted = 1;
 349
 350 /* Nonzero means add default format_arg attributes for functions not
 351    in ISO C.  */
 352
 353 int flag_noniso_default_format_attributes = 1;
 354
 355 /* Nonzero means give `double' the same size as `float'.  */
 356
 357 extern int flag_short_double;
 358
 359 /* Nonzero if we want to conserve space in the .o files.  We do this
 360    by putting uninitialized data and runtime initialized data into
 361    .common instead of .data at the expense of not flagging multiple
 362    definitions.  */
 363 extern int flag_conserve_space;
 364 \f
 365 /* C and C++ flags are in decl2.c.  */
 366
 367 /* Flag used when debugging spew.c */
 368
 369 extern int spew_debug;
 370
 371 /* A expression of value 0 with the same precision as a sizetype
 372    node, but signed.  */
 373 tree signed_size_zero_node;
 374
 375 /* The name of the anonymous namespace, throughout this translation
 376    unit.  */
 377 tree anonymous_namespace_name;
 378
 379 /* The number of function bodies which we are currently processing.
 380    (Zero if we are at namespace scope, one inside the body of a
 381    function, two inside the body of a function in a local class, etc.)  */
 382 int function_depth;
 383 \f
 384 /* For each binding contour we allocate a binding_level structure
 385    which records the names defined in that contour.
 386    Contours include:
 387     0) the global one
 388     1) one for each function definition,
 389        where internal declarations of the parameters appear.
 390     2) one for each compound statement,
 391        to record its declarations.
 392
 393    The current meaning of a name can be found by searching the levels
 394    from the current one out to the global one.
 395
 396    Off to the side, may be the class_binding_level.  This exists only
 397    to catch class-local declarations.  It is otherwise nonexistent.
 398
 399    Also there may be binding levels that catch cleanups that must be
 400    run when exceptions occur.  Thus, to see whether a name is bound in
 401    the current scope, it is not enough to look in the
 402    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 403    instead.  */
 404
 405 /* Note that the information in the `names' component of the global contour
 406    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 407
 408 struct binding_level
 409   {
 410     /* A chain of _DECL nodes for all variables, constants, functions,
 411        and typedef types.  These are in the reverse of the order
 412        supplied.  There may be OVERLOADs on this list, too, but they
 413        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 414     tree names;
 415
 416     /* A list of structure, union and enum definitions, for looking up
 417        tag names.
 418        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 419        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 420        or ENUMERAL_TYPE node.
 421
 422        C++: the TREE_VALUE nodes can be simple types for
 423        component_bindings.  */
 424     tree tags;
 425
 426     /* A list of USING_DECL nodes. */
 427     tree usings;
 428
 429     /* A list of used namespaces. PURPOSE is the namespace,
 430        VALUE the common ancestor with this binding_level's namespace. */
 431     tree using_directives;
 432
 433     /* If this binding level is the binding level for a class, then
 434        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 435        is the name of an entity bound in the class; the TREE_VALUE is
 436        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 437        when leaving class scope, we can restore the
 438        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 439        the DECL bound by this name in the class.  */
 440     tree class_shadowed;
 441
 442     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 443        is used for all binding levels.  */
 444     tree type_shadowed;
 445
 446     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 447        label in this scope.  The TREE_PURPOSE is the previous value of
 448        the IDENTIFIER_LABEL VALUE.  */
 449     tree shadowed_labels;
 450
 451     /* For each level (except not the global one),
 452        a chain of BLOCK nodes for all the levels
 453        that were entered and exited one level down.  */
 454     tree blocks;
 455
 456     /* The _TYPE node for this level, if parm_flag == 2.  */
 457     tree this_class;
 458
 459     /* The binding level which this one is contained in (inherits from).  */
 460     struct binding_level *level_chain;
 461
 462     /* List of decls in `names' that have incomplete
 463        structure or union types.  */
 464     tree incomplete;
 465
 466     /* List of VAR_DECLS saved from a previous for statement.
 467        These would be dead in ISO-conforming code, but might
 468        be referenced in ARM-era code.  These are stored in a
 469        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 470     tree dead_vars_from_for;
 471
 472     /* 1 for the level that holds the parameters of a function.
 473        2 for the level that holds a class declaration.  */
 474     unsigned parm_flag : 2;
 475
 476     /* 1 means make a BLOCK for this level regardless of all else.
 477        2 for temporary binding contours created by the compiler.  */
 478     unsigned keep : 2;
 479
 480     /* Nonzero if this level "doesn't exist" for tags.  */
 481     unsigned tag_transparent : 1;
 482
 483     /* Nonzero if this level can safely have additional
 484        cleanup-needing variables added to it.  */
 485     unsigned more_cleanups_ok : 1;
 486     unsigned have_cleanups : 1;
 487
 488     /* Nonzero if this scope is for storing the decls for template
 489        parameters and generic decls; these decls will be discarded and
 490        replaced with a TEMPLATE_DECL.  */
 491     unsigned template_parms_p : 1;
 492
 493     /* Nonzero if this scope corresponds to the `<>' in a
 494        `template <>' clause.  Whenever this flag is set,
 495        TEMPLATE_PARMS_P will be set as well.  */
 496     unsigned template_spec_p : 1;
 497
 498     /* This is set for a namespace binding level.  */
 499     unsigned namespace_p : 1;
 500
 501     /* True if this level is that of a for-statement where we need to
 502        worry about ambiguous (ARM or ISO) scope rules.  */
 503     unsigned is_for_scope : 1;
 504
 505     /* True if this level corresponds to an EH region, as for a try block.
 506        Currently this information is only available while building the
 507        tree structure.  */
 508     unsigned eh_region : 1;
 509
 510     /* Four bits left for this word.  */
 511
 512 #if defined(DEBUG_CP_BINDING_LEVELS)
 513     /* Binding depth at which this level began.  */
 514     unsigned binding_depth;
 515 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 516   };
 517
 518 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 519
 520 /* The binding level currently in effect.  */
 521
 522 #define current_binding_level                   \
 523   (cfun                                         \
 524    ? cp_function_chain->bindings                \
 525    : scope_chain->bindings)
 526
 527 /* The binding level of the current class, if any.  */
 528
 529 #define class_binding_level scope_chain->class_bindings
 530
 531 /* A chain of binding_level structures awaiting reuse.  */
 532
 533 static struct binding_level *free_binding_level;
 534
 535 /* The outermost binding level, for names of file scope.
 536    This is created when the compiler is started and exists
 537    through the entire run.  */
 538
 539 static struct binding_level *global_binding_level;
 540
 541 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 542
 543 static int keep_next_level_flag;
 544
 545 #if defined(DEBUG_CP_BINDING_LEVELS)
 546 static int binding_depth = 0;
 547 static int is_class_level = 0;
 548
 549 static void
 550 indent ()
 551 {
 552   register unsigned i;
 553
 554   for (i = 0; i < binding_depth*2; i++)
 555     putc (' ', stderr);
 556 }
 557 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 558
 559 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 560
 561 static void
 562 push_binding_level (newlevel, tag_transparent, keep)
 563      struct binding_level *newlevel;
 564      int tag_transparent, keep;
 565 {
 566   /* Add this level to the front of the chain (stack) of levels that
 567      are active.  */
 568   bzero ((char*) newlevel, sizeof (struct binding_level));
 569   newlevel->level_chain = current_binding_level;
 570   current_binding_level = newlevel;
 571   newlevel->tag_transparent = tag_transparent;
 572   newlevel->more_cleanups_ok = 1;
 573
 574   newlevel->keep = keep;
 575 #if defined(DEBUG_CP_BINDING_LEVELS)
 576   newlevel->binding_depth = binding_depth;
 577   indent ();
 578   fprintf (stderr, "push %s level 0x%08x line %d\n",
 579            (is_class_level) ? "class" : "block", newlevel, lineno);
 580   is_class_level = 0;
 581   binding_depth++;
 582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 583 }
 584
 585 /* Find the innermost enclosing class scope, and reset
 586    CLASS_BINDING_LEVEL appropriately.  */
 587
 588 static void
 589 find_class_binding_level ()
 590 {
 591   struct binding_level *level = current_binding_level;
 592
 593   while (level && level->parm_flag != 2)
 594     level = level->level_chain;
 595   if (level && level->parm_flag == 2)
 596     class_binding_level = level;
 597   else
 598     class_binding_level = 0;
 599 }
 600
 601 static void
 602 pop_binding_level ()
 603 {
 604   if (global_binding_level)
 605     {
 606       /* Cannot pop a level, if there are none left to pop.  */
 607       if (current_binding_level == global_binding_level)
 608         my_friendly_abort (123);
 609     }
 610   /* Pop the current level, and free the structure for reuse.  */
 611 #if defined(DEBUG_CP_BINDING_LEVELS)
 612   binding_depth--;
 613   indent ();
 614   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 615           (is_class_level) ? "class" : "block",
 616           current_binding_level, lineno);
 617   if (is_class_level != (current_binding_level == class_binding_level))
 618     {
 619       indent ();
 620       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 621     }
 622   is_class_level = 0;
 623 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 624   {
 625     register struct binding_level *level = current_binding_level;
 626     current_binding_level = current_binding_level->level_chain;
 627     level->level_chain = free_binding_level;
 628 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 629     if (level->binding_depth != binding_depth)
 630       abort ();
 631 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 632     free_binding_level = level;
 633     find_class_binding_level ();
 634   }
 635 }
 636
 637 static void
 638 suspend_binding_level ()
 639 {
 640   if (class_binding_level)
 641     current_binding_level = class_binding_level;
 642
 643   if (global_binding_level)
 644     {
 645       /* Cannot suspend a level, if there are none left to suspend.  */
 646       if (current_binding_level == global_binding_level)
 647         my_friendly_abort (123);
 648     }
 649   /* Suspend the current level.  */
 650 #if defined(DEBUG_CP_BINDING_LEVELS)
 651   binding_depth--;
 652   indent ();
 653   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 654           (is_class_level) ? "class" : "block",
 655           current_binding_level, lineno);
 656   if (is_class_level != (current_binding_level == class_binding_level))
 657     {
 658       indent ();
 659       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 660     }
 661   is_class_level = 0;
 662 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 663   current_binding_level = current_binding_level->level_chain;
 664   find_class_binding_level ();
 665 }
 666
 667 static void
 668 resume_binding_level (b)
 669      struct binding_level *b;
 670 {
 671   /* Resuming binding levels is meant only for namespaces,
 672      and those cannot nest into classes. */
 673   my_friendly_assert(!class_binding_level, 386);
 674   /* Also, resuming a non-directly nested namespace is a no-no.  */
 675   my_friendly_assert(b->level_chain == current_binding_level, 386);
 676   current_binding_level = b;
 677 #if defined(DEBUG_CP_BINDING_LEVELS)
 678   b->binding_depth = binding_depth;
 679   indent ();
 680   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 681            (is_class_level) ? "class" : "block", b, lineno);
 682   is_class_level = 0;
 683   binding_depth++;
 684 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 685 }
 686 \f
 687 /* Create a new `struct binding_level'.  */
 688
 689 static
 690 struct binding_level *
 691 make_binding_level ()
 692 {
 693   /* NOSTRICT */
 694   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 695 }
 696
 697 /* Nonzero if we are currently in the global binding level.  */
 698
 699 int
 700 global_bindings_p ()
 701 {
 702   return current_binding_level == global_binding_level;
 703 }
 704
 705 /* Return the innermost binding level that is not for a class scope.  */
 706
 707 static struct binding_level *
 708 innermost_nonclass_level ()
 709 {
 710   struct binding_level *b;
 711
 712   b = current_binding_level;
 713   while (b->parm_flag == 2)
 714     b = b->level_chain;
 715
 716   return b;
 717 }
 718
 719 /* Nonzero if we are currently in a toplevel binding level.  This
 720    means either the global binding level or a namespace in a toplevel
 721    binding level.  Since there are no non-toplevel namespace levels,
 722    this really means any namespace or template parameter level.  We
 723    also include a class whose context is toplevel.  */
 724
 725 int
 726 toplevel_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p || b->template_parms_p;
 731 }
 732
 733 /* Nonzero if this is a namespace scope, or if we are defining a class
 734    which is itself at namespace scope, or whose enclosing class is
 735    such a class, etc.  */
 736
 737 int
 738 namespace_bindings_p ()
 739 {
 740   struct binding_level *b = innermost_nonclass_level ();
 741
 742   return b->namespace_p;
 743 }
 744
 745 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 746    unconditionally.  Otherwise, use the normal logic to decide whether
 747    or not to create a BLOCK.  */
 748
 749 void
 750 keep_next_level (keep)
 751      int keep;
 752 {
 753   keep_next_level_flag = keep;
 754 }
 755
 756 /* Nonzero if the current level needs to have a BLOCK made.  */
 757
 758 int
 759 kept_level_p ()
 760 {
 761   return (current_binding_level->blocks != NULL_TREE
 762           || current_binding_level->keep
 763           || current_binding_level->names != NULL_TREE
 764           || (current_binding_level->tags != NULL_TREE
 765               && !current_binding_level->tag_transparent));
 766 }
 767
 768 static void
 769 declare_namespace_level ()
 770 {
 771   current_binding_level->namespace_p = 1;
 772 }
 773
 774 /* Returns non-zero if this scope was created to store template
 775    parameters.  */
 776
 777 int
 778 template_parm_scope_p ()
 779 {
 780   return current_binding_level->template_parms_p;
 781 }
 782
 783 /* Returns the kind of template specialization we are currently
 784    processing, given that it's declaration contained N_CLASS_SCOPES
 785    explicit scope qualifications.  */
 786
 787 tmpl_spec_kind
 788 current_tmpl_spec_kind (n_class_scopes)
 789      int n_class_scopes;
 790 {
 791   int n_template_parm_scopes = 0;
 792   int seen_specialization_p = 0;
 793   int innermost_specialization_p = 0;
 794   struct binding_level *b;
 795
 796   /* Scan through the template parameter scopes.  */
 797   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 798     {
 799       /* If we see a specialization scope inside a parameter scope,
 800          then something is wrong.  That corresponds to a declaration
 801          like:
 802
 803             template <class T> template <> ...
 804
 805          which is always illegal since [temp.expl.spec] forbids the
 806          specialization of a class member template if the enclosing
 807          class templates are not explicitly specialized as well.  */
 808       if (b->template_spec_p)
 809         {
 810           if (n_template_parm_scopes == 0)
 811             innermost_specialization_p = 1;
 812           else
 813             seen_specialization_p = 1;
 814         }
 815       else if (seen_specialization_p == 1)
 816         return tsk_invalid_member_spec;
 817
 818       ++n_template_parm_scopes;
 819     }
 820
 821   /* Handle explicit instantiations.  */
 822   if (processing_explicit_instantiation)
 823     {
 824       if (n_template_parm_scopes != 0)
 825         /* We've seen a template parameter list during an explicit
 826            instantiation.  For example:
 827
 828              template <class T> template void f(int);
 829
 830            This is erroneous.  */
 831         return tsk_invalid_expl_inst;
 832       else
 833         return tsk_expl_inst;
 834     }
 835
 836   if (n_template_parm_scopes < n_class_scopes)
 837     /* We've not seen enough template headers to match all the
 838        specialized classes present.  For example:
 839
 840          template <class T> void R<T>::S<T>::f(int);
 841
 842        This is illegal; there needs to be one set of template
 843        parameters for each class.  */
 844     return tsk_insufficient_parms;
 845   else if (n_template_parm_scopes == n_class_scopes)
 846     /* We're processing a non-template declaration (even though it may
 847        be a member of a template class.)  For example:
 848
 849          template <class T> void S<T>::f(int);
 850
 851        The `class T' maches the `S<T>', leaving no template headers
 852        corresponding to the `f'.  */
 853     return tsk_none;
 854   else if (n_template_parm_scopes > n_class_scopes + 1)
 855     /* We've got too many template headers.  For example:
 856
 857          template <> template <class T> void f (T);
 858
 859        There need to be more enclosing classes.  */
 860     return tsk_excessive_parms;
 861   else
 862     /* This must be a template.  It's of the form:
 863
 864          template <class T> template <class U> void S<T>::f(U);
 865
 866        This is a specialization if the innermost level was a
 867        specialization; otherwise it's just a definition of the
 868        template.  */
 869     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 870 }
 871
 872 void
 873 set_class_shadows (shadows)
 874      tree shadows;
 875 {
 876   class_binding_level->class_shadowed = shadows;
 877 }
 878
 879 /* Enter a new binding level.
 880    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 881    not for that of tags.  */
 882
 883 void
 884 pushlevel (tag_transparent)
 885      int tag_transparent;
 886 {
 887   struct binding_level *newlevel;
 888
 889   if (cfun && !doing_semantic_analysis_p ())
 890     return;
 891
 892   /* Reuse or create a struct for this binding level.  */
 893 #if defined(DEBUG_CP_BINDING_LEVELS)
 894   if (0)
 895 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 896   if (free_binding_level)
 897 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 898     {
 899       newlevel = free_binding_level;
 900       free_binding_level = free_binding_level->level_chain;
 901     }
 902   else
 903     newlevel = make_binding_level ();
 904
 905   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 906   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 907   keep_next_level_flag = 0;
 908 }
 909
 910 /* Enter a new scope.  The KIND indicates what kind of scope is being
 911    created.  */
 912
 913 void
 914 begin_scope (sk)
 915      scope_kind sk;
 916 {
 917   pushlevel (0);
 918
 919   switch (sk)
 920     {
 921     case sk_template_spec:
 922       current_binding_level->template_spec_p = 1;
 923       /* Fall through.  */
 924
 925     case sk_template_parms:
 926       current_binding_level->template_parms_p = 1;
 927       break;
 928
 929     default:
 930       my_friendly_abort (20000309);
 931     }
 932 }
 933
 934 /* Exit the current scope.  */
 935
 936 void
 937 finish_scope ()
 938 {
 939   poplevel (0, 0, 0);
 940 }
 941
 942 void
 943 note_level_for_for ()
 944 {
 945   current_binding_level->is_for_scope = 1;
 946 }
 947
 948 /* Record that the current binding level represents a try block.  */
 949
 950 void
 951 note_level_for_eh ()
 952 {
 953   current_binding_level->eh_region = 1;
 954 }
 955
 956 /* For a binding between a name and an entity at a block scope,
 957    this is the `struct binding_level' for the block.  */
 958 #define BINDING_LEVEL(NODE) \
 959    (((struct tree_binding*)NODE)->scope.level)
 960
 961 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 962    level at which this declaration is being bound.  */
 963
 964 static void
 965 push_binding (id, decl, level)
 966      tree id;
 967      tree decl;
 968      struct binding_level* level;
 969 {
 970   tree binding;
 971
 972   binding = make_node (CPLUS_BINDING);
 973
 974   /* Now, fill in the binding information.  */
 975   BINDING_VALUE (binding) = decl;
 976   BINDING_TYPE (binding) = NULL_TREE;
 977   BINDING_LEVEL (binding) = level;
 978   INHERITED_VALUE_BINDING_P (binding) = 0;
 979   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 980   BINDING_HAS_LEVEL_P (binding) = 1;
 981
 982   /* And put it on the front of the list of bindings for ID.  */
 983   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 984   IDENTIFIER_BINDING (id) = binding;
 985 }
 986
 987 /* ID is already bound in the current scope.  But, DECL is an
 988    additional binding for ID in the same scope.  This is the `struct
 989    stat' hack whereby a non-typedef class-name or enum-name can be
 990    bound at the same level as some other kind of entity.  It's the
 991    responsibility of the caller to check that inserting this name is
 992    legal here.  Returns nonzero if the new binding was successful.  */
 993 static int
 994 add_binding (id, decl)
 995      tree id;
 996      tree decl;
 997 {
 998   tree binding = IDENTIFIER_BINDING (id);
 999   int ok = 1;
1000
1001   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1002     /* The new name is the type name.  */
1003     BINDING_TYPE (binding) = decl;
1004   else if (!BINDING_VALUE (binding))
1005     /* This situation arises when push_class_level_binding moves an
1006        inherited type-binding out of the way to make room for a new
1007        value binding.  */
1008     BINDING_VALUE (binding) = decl;
1009   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1010            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1011     {
1012       /* The old binding was a type name.  It was placed in
1013          BINDING_VALUE because it was thought, at the point it was
1014          declared, to be the only entity with such a name.  Move the
1015          type name into the type slot; it is now hidden by the new
1016          binding.  */
1017       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1018       BINDING_VALUE (binding) = decl;
1019       INHERITED_VALUE_BINDING_P (binding) = 0;
1020     }
1021   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1022            && TREE_CODE (decl) == TYPE_DECL
1023            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1024            && same_type_p (TREE_TYPE (decl),
1025                            TREE_TYPE (BINDING_VALUE (binding))))
1026     /* We have two typedef-names, both naming the same type to have
1027        the same name.  This is OK because of:
1028
1029          [dcl.typedef]
1030
1031          In a given scope, a typedef specifier can be used to redefine
1032          the name of any type declared in that scope to refer to the
1033          type to which it already refers.  */
1034     ok = 0;
1035   /* There can be two block-scope declarations of the same variable,
1036      so long as they are `extern' declarations.  */
1037   else if (TREE_CODE (decl) == VAR_DECL
1038            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1039            && DECL_EXTERNAL (decl)
1040            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1041     {
1042       duplicate_decls (decl, BINDING_VALUE (binding));
1043       ok = 0;
1044     }
1045   else
1046     {
1047       cp_error ("declaration of `%#D'", decl);
1048       cp_error_at ("conflicts with previous declaration `%#D'",
1049                    BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052
1053   return ok;
1054 }
1055
1056 /* Add DECL to the list of things declared in B.  */
1057
1058 static void
1059 add_decl_to_level (decl, b)
1060      tree decl;
1061      struct binding_level *b;
1062 {
1063   /* We build up the list in reverse order, and reverse it later if
1064      necessary.  */
1065   TREE_CHAIN (decl) = b->names;
1066   b->names = decl;
1067 }
1068
1069 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1070    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1071    doesn't really belong to this binding level, that it got here
1072    through a using-declaration.  */
1073
1074 void
1075 push_local_binding (id, decl, flags)
1076      tree id;
1077      tree decl;
1078      int flags;
1079 {
1080   struct binding_level *b;
1081
1082   /* Skip over any local classes.  This makes sense if we call
1083      push_local_binding with a friend decl of a local class.  */
1084   b = current_binding_level;
1085   while (b->parm_flag == 2)
1086     b = b->level_chain;
1087
1088   if (lookup_name_current_level (id))
1089     {
1090       /* Supplement the existing binding.  */
1091       if (!add_binding (id, decl))
1092         /* It didn't work.  Something else must be bound at this
1093            level.  Do not add DECL to the list of things to pop
1094            later.  */
1095         return;
1096     }
1097   else
1098     /* Create a new binding.  */
1099     push_binding (id, decl, b);
1100
1101   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1102     /* We must put the OVERLOAD into a TREE_LIST since the
1103        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1104        decls that got here through a using-declaration.  */
1105     decl = build_tree_list (NULL_TREE, decl);
1106
1107   /* And put DECL on the list of things declared by the current
1108      binding level.  */
1109   add_decl_to_level (decl, b);
1110 }
1111
1112 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1113    binding was successful.  */
1114
1115 int
1116 push_class_binding (id, decl)
1117      tree id;
1118      tree decl;
1119 {
1120   int result = 1;
1121   tree binding = IDENTIFIER_BINDING (id);
1122   tree context;
1123
1124   /* Note that we declared this value so that we can issue an error if
1125      this an illegal redeclaration of a name already used for some
1126      other purpose.  */
1127   note_name_declared_in_class (id, decl);
1128
1129   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1130     /* Supplement the existing binding.  */
1131     result = add_binding (id, decl);
1132   else
1133     /* Create a new binding.  */
1134     push_binding (id, decl, class_binding_level);
1135
1136   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1137      class-level declaration.  Note that we do not use DECL here
1138      because of the possibility of the `struct stat' hack; if DECL is
1139      a class-name or enum-name we might prefer a field-name, or some
1140      such.  */
1141   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1142
1143   /* If this is a binding from a base class, mark it as such.  */
1144   binding = IDENTIFIER_BINDING (id);
1145   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1146     {
1147       /* Any implicit typename must be from a base-class.  The
1148          context for an implicit typename declaration is always
1149          the derived class in which the lookup was done, so the checks
1150          based on the context of DECL below will not trigger.  */
1151       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1152         INHERITED_VALUE_BINDING_P (binding) = 1;
1153       else
1154         {
1155           if (TREE_CODE (decl) == OVERLOAD)
1156             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1157           else
1158             {
1159               my_friendly_assert (DECL_P (decl), 0);
1160               context = CP_DECL_CONTEXT (decl);
1161             }
1162
1163           if (is_properly_derived_from (current_class_type, context))
1164             INHERITED_VALUE_BINDING_P (binding) = 1;
1165           else
1166             INHERITED_VALUE_BINDING_P (binding) = 0;
1167         }
1168     }
1169   else if (BINDING_VALUE (binding) == decl)
1170     /* We only encounter a TREE_LIST when push_class_decls detects an
1171        ambiguity.  Such an ambiguity can be overridden by a definition
1172        in this class.  */
1173     INHERITED_VALUE_BINDING_P (binding) = 1;
1174
1175   return result;
1176 }
1177
1178 /* Remove the binding for DECL which should be the innermost binding
1179    for ID.  */
1180
1181 static void
1182 pop_binding (id, decl)
1183      tree id;
1184      tree decl;
1185 {
1186   tree binding;
1187
1188   if (id == NULL_TREE)
1189     /* It's easiest to write the loops that call this function without
1190        checking whether or not the entities involved have names.  We
1191        get here for such an entity.  */
1192     return;
1193
1194   /* Get the innermost binding for ID.  */
1195   binding = IDENTIFIER_BINDING (id);
1196
1197   /* The name should be bound.  */
1198   my_friendly_assert (binding != NULL_TREE, 0);
1199
1200   /* The DECL will be either the ordinary binding or the type
1201      binding for this identifier.  Remove that binding.  */
1202   if (BINDING_VALUE (binding) == decl)
1203     BINDING_VALUE (binding) = NULL_TREE;
1204   else if (BINDING_TYPE (binding) == decl)
1205     BINDING_TYPE (binding) = NULL_TREE;
1206   else
1207     my_friendly_abort (0);
1208
1209   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1210     /* We're completely done with the innermost binding for this
1211        identifier.  Unhook it from the list of bindings.  */
1212     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1213 }
1214
1215 /* When a label goes out of scope, check to see if that label was used
1216    in a valid manner, and issue any appropriate warnings or errors.  */
1217
1218 static void
1219 pop_label (label, old_value)
1220      tree label;
1221      tree old_value;
1222 {
1223   if (!processing_template_decl && doing_semantic_analysis_p ())
1224     {
1225       if (DECL_INITIAL (label) == NULL_TREE)
1226         {
1227           cp_error_at ("label `%D' used but not defined", label);
1228           /* Avoid crashing later.  */
1229           define_label (input_filename, 1, DECL_NAME (label));
1230         }
1231       else if (warn_unused_label && !TREE_USED (label))
1232         cp_warning_at ("label `%D' defined but not used", label);
1233     }
1234
1235   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1236 }
1237
1238 /* At the end of a function, all labels declared within the function
1239    go out of scope.  BLOCK is the top-level block for the
1240    function.  */
1241
1242 static void
1243 pop_labels (block)
1244      tree block;
1245 {
1246   struct named_label_list *link;
1247
1248   /* Clear out the definitions of all label names, since their scopes
1249      end here.  */
1250   for (link = named_labels; link; link = link->next)
1251     {
1252       pop_label (link->label_decl, link->old_value);
1253       /* Put the labels into the "variables" of the top-level block,
1254          so debugger can see them.  */
1255       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1256       BLOCK_VARS (block) = link->label_decl;
1257     }
1258
1259   named_labels = NULL;
1260 }
1261
1262 /* Exit a binding level.
1263    Pop the level off, and restore the state of the identifier-decl mappings
1264    that were in effect when this level was entered.
1265
1266    If KEEP == 1, this level had explicit declarations, so
1267    and create a "block" (a BLOCK node) for the level
1268    to record its declarations and subblocks for symbol table output.
1269
1270    If FUNCTIONBODY is nonzero, this level is the body of a function,
1271    so create a block as if KEEP were set and also clear out all
1272    label names.
1273
1274    If REVERSE is nonzero, reverse the order of decls before putting
1275    them into the BLOCK.  */
1276
1277 tree
1278 poplevel (keep, reverse, functionbody)
1279      int keep;
1280      int reverse;
1281      int functionbody;
1282 {
1283   register tree link;
1284   /* The chain of decls was accumulated in reverse order.
1285      Put it into forward order, just for cleanliness.  */
1286   tree decls;
1287   int tmp = functionbody;
1288   int real_functionbody;
1289   tree tags;
1290   tree subblocks;
1291   tree block = NULL_TREE;
1292   tree decl;
1293   int leaving_for_scope;
1294
1295   if (cfun && !doing_semantic_analysis_p ())
1296     return NULL_TREE;
1297
1298   my_friendly_assert (current_binding_level->parm_flag != 2,
1299                       19990916);
1300
1301   real_functionbody = (current_binding_level->keep == 2
1302                        ? ((functionbody = 0), tmp) : functionbody);
1303   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1304   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1305
1306   my_friendly_assert (!current_binding_level->class_shadowed,
1307                       19990414);
1308
1309   /* We used to use KEEP == 2 to indicate that the new block should go
1310      at the beginning of the list of blocks at this binding level,
1311      rather than the end.  This hack is no longer used.  */
1312   my_friendly_assert (keep == 0 || keep == 1, 0);
1313
1314   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1315                       (HOST_WIDE_INT) current_binding_level->level_chain,
1316                       current_binding_level->parm_flag,
1317                       current_binding_level->keep);
1318
1319   if (current_binding_level->keep == 1)
1320     keep = 1;
1321
1322   /* Any uses of undefined labels, and any defined labels, now operate
1323      under constraints of next binding contour.  */
1324   if (cfun && !functionbody)
1325     {
1326       struct binding_level *level_chain;
1327       level_chain = current_binding_level->level_chain;
1328       if (level_chain)
1329         {
1330           struct named_label_use_list *uses;
1331           struct named_label_list *labels;
1332           for (labels = named_labels; labels; labels = labels->next)
1333             if (labels->binding_level == current_binding_level)
1334               {
1335                 tree decl;
1336                 if (current_binding_level->eh_region)
1337                   labels->eh_region = 1;
1338                 for (decl = labels->names_in_scope; decl;
1339                      decl = TREE_CHAIN (decl))
1340                   if (decl_jump_unsafe (decl))
1341                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1342                                                    labels->bad_decls);
1343                 labels->binding_level = level_chain;
1344                 labels->names_in_scope = level_chain->names;
1345               }
1346
1347           for (uses = named_label_uses; uses; uses = uses->next)
1348             if (uses->binding_level == current_binding_level)
1349               {
1350                 uses->binding_level = level_chain;
1351                 uses->names_in_scope = level_chain->names;
1352               }
1353         }
1354     }
1355
1356   /* Get the decls in the order they were written.
1357      Usually current_binding_level->names is in reverse order.
1358      But parameter decls were previously put in forward order.  */
1359
1360   if (reverse)
1361     current_binding_level->names
1362       = decls = nreverse (current_binding_level->names);
1363   else
1364     decls = current_binding_level->names;
1365
1366   /* Output any nested inline functions within this block
1367      if they weren't already output.  */
1368   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1369     if (TREE_CODE (decl) == FUNCTION_DECL
1370         && ! TREE_ASM_WRITTEN (decl)
1371         && DECL_INITIAL (decl) != NULL_TREE
1372         && TREE_ADDRESSABLE (decl)
1373         && decl_function_context (decl) == current_function_decl)
1374       {
1375         /* If this decl was copied from a file-scope decl
1376            on account of a block-scope extern decl,
1377            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1378         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1379           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1380         else
1381           {
1382             push_function_context ();
1383             output_inline_function (decl);
1384             pop_function_context ();
1385           }
1386       }
1387
1388   /* When not in function-at-a-time mode, expand_end_bindings will
1389      warn about unused variables.  But, in function-at-a-time mode
1390      expand_end_bindings is not passed the list of variables in the
1391      current scope, and therefore no warning is emitted.  So, we
1392      explicitly warn here.  */
1393   if (!processing_template_decl)
1394     warn_about_unused_variables (getdecls ());
1395
1396   /* If there were any declarations or structure tags in that level,
1397      or if this level is a function body,
1398      create a BLOCK to record them for the life of this function.  */
1399   block = NULL_TREE;
1400   if (keep == 1 || functionbody)
1401     block = make_node (BLOCK);
1402   if (block != NULL_TREE)
1403     {
1404       BLOCK_VARS (block) = decls;
1405       BLOCK_SUBBLOCKS (block) = subblocks;
1406     }
1407
1408   /* In each subblock, record that this is its superior.  */
1409   if (keep >= 0)
1410     for (link = subblocks; link; link = TREE_CHAIN (link))
1411       BLOCK_SUPERCONTEXT (link) = block;
1412
1413   /* We still support the old for-scope rules, whereby the variables
1414      in a for-init statement were in scope after the for-statement
1415      ended.  We only use the new rules in flag_new_for_scope is
1416      nonzero.  */
1417   leaving_for_scope
1418     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1419
1420   /* Remove declarations for all the DECLs in this level.  */
1421   for (link = decls; link; link = TREE_CHAIN (link))
1422     {
1423       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1424           && DECL_NAME (link))
1425         {
1426           tree outer_binding
1427             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1428           tree ns_binding;
1429
1430           if (!outer_binding)
1431             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1432           else
1433             ns_binding = NULL_TREE;
1434
1435           if (outer_binding
1436               && (BINDING_LEVEL (outer_binding)
1437                   == current_binding_level->level_chain))
1438             /* We have something like:
1439
1440                  int i;
1441                  for (int i; ;);
1442
1443                and we are leaving the `for' scope.  There's no reason to
1444                keep the binding of the inner `i' in this case.  */
1445             pop_binding (DECL_NAME (link), link);
1446           else if ((outer_binding
1447                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1448                         == TYPE_DECL))
1449                    || (ns_binding
1450                        && TREE_CODE (ns_binding) == TYPE_DECL))
1451             /* Here, we have something like:
1452
1453                  typedef int I;
1454
1455                  void f () {
1456                    for (int I; ;);
1457                  }
1458
1459                We must pop the for-scope binding so we know what's a
1460                type and what isn't.  */
1461             pop_binding (DECL_NAME (link), link);
1462           else
1463             {
1464               /* Mark this VAR_DECL as dead so that we can tell we left it
1465                  there only for backward compatibility.  */
1466               DECL_DEAD_FOR_LOCAL (link) = 1;
1467
1468               /* Keep track of what should of have happenned when we
1469                  popped the binding.  */
1470               if (outer_binding && BINDING_VALUE (outer_binding))
1471                 DECL_SHADOWED_FOR_VAR (link)
1472                   = BINDING_VALUE (outer_binding);
1473
1474               /* Add it to the list of dead variables in the next
1475                  outermost binding to that we can remove these when we
1476                  leave that binding.  */
1477               current_binding_level->level_chain->dead_vars_from_for
1478                 = tree_cons (NULL_TREE, link,
1479                              current_binding_level->level_chain->
1480                              dead_vars_from_for);
1481
1482               /* Although we don't pop the CPLUS_BINDING, we do clear
1483                  its BINDING_LEVEL since the level is going away now.  */
1484               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1485                 = 0;
1486             }
1487         }
1488       else
1489         {
1490           /* Remove the binding.  */
1491           decl = link;
1492           if (TREE_CODE (decl) == TREE_LIST)
1493             decl = TREE_VALUE (decl);
1494           if (DECL_P (decl))
1495             pop_binding (DECL_NAME (decl), decl);
1496           else if (TREE_CODE (decl) == OVERLOAD)
1497             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1498           else
1499             my_friendly_abort (0);
1500         }
1501     }
1502
1503   /* Remove declarations for any `for' variables from inner scopes
1504      that we kept around.  */
1505   for (link = current_binding_level->dead_vars_from_for;
1506        link; link = TREE_CHAIN (link))
1507     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1508
1509   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1510   for (link = current_binding_level->type_shadowed;
1511        link; link = TREE_CHAIN (link))
1512     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1513
1514   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1515   for (link = current_binding_level->shadowed_labels;
1516        link;
1517        link = TREE_CHAIN (link))
1518     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1519
1520   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1521      list if a `using' declaration put them there.  The debugging
1522      back-ends won't understand OVERLOAD, so we remove them here.
1523      Because the BLOCK_VARS are (temporarily) shared with
1524      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1525      popped all the bindings.  */
1526   if (block)
1527     {
1528       tree* d;
1529
1530       for (d = &BLOCK_VARS (block); *d; )
1531         {
1532           if (TREE_CODE (*d) == TREE_LIST)
1533             *d = TREE_CHAIN (*d);
1534           else
1535             d = &TREE_CHAIN (*d);
1536         }
1537     }
1538
1539   /* If the level being exited is the top level of a function,
1540      check over all the labels.  */
1541   if (functionbody)
1542     {
1543       /* Since this is the top level block of a function, the vars are
1544          the function's parameters.  Don't leave them in the BLOCK
1545          because they are found in the FUNCTION_DECL instead.  */
1546       BLOCK_VARS (block) = 0;
1547       pop_labels (block);
1548     }
1549
1550   tmp = current_binding_level->keep;
1551
1552   pop_binding_level ();
1553   if (functionbody)
1554     DECL_INITIAL (current_function_decl) = block;
1555   else if (block)
1556     current_binding_level->blocks
1557       = chainon (current_binding_level->blocks, block);
1558
1559   /* If we did not make a block for the level just exited,
1560      any blocks made for inner levels
1561      (since they cannot be recorded as subblocks in that level)
1562      must be carried forward so they will later become subblocks
1563      of something else.  */
1564   else if (subblocks)
1565     current_binding_level->blocks
1566       = chainon (current_binding_level->blocks, subblocks);
1567
1568   /* Each and every BLOCK node created here in `poplevel' is important
1569      (e.g. for proper debugging information) so if we created one
1570      earlier, mark it as "used".  */
1571   if (block)
1572     TREE_USED (block) = 1;
1573
1574   /* Take care of compiler's internal binding structures.  */
1575   if (tmp == 2)
1576     {
1577       tree scope_stmts;
1578
1579       scope_stmts
1580         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1581       if (block)
1582         {
1583           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1584           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1585         }
1586
1587       block = poplevel (keep, reverse, functionbody);
1588     }
1589
1590   return block;
1591 }
1592
1593 /* Delete the node BLOCK from the current binding level.
1594    This is used for the block inside a stmt expr ({...})
1595    so that the block can be reinserted where appropriate.  */
1596
1597 void
1598 delete_block (block)
1599      tree block;
1600 {
1601   tree t;
1602   if (current_binding_level->blocks == block)
1603     current_binding_level->blocks = TREE_CHAIN (block);
1604   for (t = current_binding_level->blocks; t;)
1605     {
1606       if (TREE_CHAIN (t) == block)
1607         TREE_CHAIN (t) = TREE_CHAIN (block);
1608       else
1609         t = TREE_CHAIN (t);
1610     }
1611   TREE_CHAIN (block) = NULL_TREE;
1612   /* Clear TREE_USED which is always set by poplevel.
1613      The flag is set again if insert_block is called.  */
1614   TREE_USED (block) = 0;
1615 }
1616
1617 /* Insert BLOCK at the end of the list of subblocks of the
1618    current binding level.  This is used when a BIND_EXPR is expanded,
1619    to handle the BLOCK node inside the BIND_EXPR.  */
1620
1621 void
1622 insert_block (block)
1623      tree block;
1624 {
1625   TREE_USED (block) = 1;
1626   current_binding_level->blocks
1627     = chainon (current_binding_level->blocks, block);
1628 }
1629
1630 /* Set the BLOCK node for the innermost scope
1631    (the one we are currently in).  */
1632
1633 void
1634 set_block (block)
1635     tree block ATTRIBUTE_UNUSED;
1636 {
1637   /* The RTL expansion machinery requires us to provide this callback,
1638      but it is not applicable in function-at-a-time mode.  */
1639   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1640 }
1641
1642 /* Do a pushlevel for class declarations.  */
1643
1644 void
1645 pushlevel_class ()
1646 {
1647   register struct binding_level *newlevel;
1648
1649   /* Reuse or create a struct for this binding level.  */
1650 #if defined(DEBUG_CP_BINDING_LEVELS)
1651   if (0)
1652 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1653   if (free_binding_level)
1654 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1655     {
1656       newlevel = free_binding_level;
1657       free_binding_level = free_binding_level->level_chain;
1658     }
1659   else
1660     newlevel = make_binding_level ();
1661
1662 #if defined(DEBUG_CP_BINDING_LEVELS)
1663   is_class_level = 1;
1664 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1665
1666   push_binding_level (newlevel, 0, 0);
1667
1668   class_binding_level = current_binding_level;
1669   class_binding_level->parm_flag = 2;
1670   class_binding_level->this_class = current_class_type;
1671 }
1672
1673 /* ...and a poplevel for class declarations.  */
1674
1675 void
1676 poplevel_class ()
1677 {
1678   register struct binding_level *level = class_binding_level;
1679   tree shadowed;
1680
1681   my_friendly_assert (level != 0, 354);
1682
1683   /* If we're leaving a toplevel class, don't bother to do the setting
1684      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1685      shouldn't even be used when current_class_type isn't set, and second,
1686      if we don't touch it here, we're able to use the cache effect if the
1687      next time we're entering a class scope, it is the same class.  */
1688   if (current_class_depth != 1)
1689     {
1690       struct binding_level* b;
1691
1692       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1693       for (shadowed = level->class_shadowed;
1694            shadowed;
1695            shadowed = TREE_CHAIN (shadowed))
1696         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1697
1698       /* Find the next enclosing class, and recreate
1699          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1700       b = level->level_chain;
1701       while (b && b->parm_flag != 2)
1702         b = b->level_chain;
1703
1704       if (b)
1705         for (shadowed = b->class_shadowed;
1706              shadowed;
1707              shadowed = TREE_CHAIN (shadowed))
1708           {
1709             tree t;
1710
1711             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1712             while (t && BINDING_LEVEL (t) != b)
1713               t = TREE_CHAIN (t);
1714
1715             if (t)
1716               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1717                 = BINDING_VALUE (t);
1718           }
1719     }
1720   else
1721     /* Remember to save what IDENTIFIER's were bound in this scope so we
1722        can recover from cache misses.  */
1723     {
1724       previous_class_type = current_class_type;
1725       previous_class_values = class_binding_level->class_shadowed;
1726     }
1727   for (shadowed = level->type_shadowed;
1728        shadowed;
1729        shadowed = TREE_CHAIN (shadowed))
1730     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1731
1732   /* Remove the bindings for all of the class-level declarations.  */
1733   for (shadowed = level->class_shadowed;
1734        shadowed;
1735        shadowed = TREE_CHAIN (shadowed))
1736     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1737
1738   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1739                       (HOST_WIDE_INT) class_binding_level->level_chain,
1740                       class_binding_level->parm_flag,
1741                       class_binding_level->keep);
1742
1743   /* Now, pop out of the binding level which we created up in the
1744      `pushlevel_class' routine.  */
1745 #if defined(DEBUG_CP_BINDING_LEVELS)
1746   is_class_level = 1;
1747 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1748
1749   pop_binding_level ();
1750 }
1751
1752 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1753    for any names in enclosing classes.  */
1754
1755 void
1756 clear_identifier_class_values ()
1757 {
1758   tree t;
1759
1760   if (!class_binding_level)
1761     return;
1762
1763   for (t = class_binding_level->class_shadowed;
1764        t;
1765        t = TREE_CHAIN (t))
1766     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1767 }
1768
1769 /* Returns non-zero if T is a virtual function table.  */
1770
1771 int
1772 vtable_decl_p (t, data)
1773      tree t;
1774      void *data ATTRIBUTE_UNUSED;
1775 {
1776   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1777 }
1778
1779 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1780    functions.  */
1781
1782 int
1783 vtype_decl_p (t, data)
1784      tree t;
1785      void *data ATTRIBUTE_UNUSED;
1786 {
1787   return (TREE_CODE (t) == TYPE_DECL
1788           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1789           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1790 }
1791
1792 /* Return the declarations that are members of the namespace NS.  */
1793
1794 tree
1795 cp_namespace_decls (ns)
1796      tree ns;
1797 {
1798   return NAMESPACE_LEVEL (ns)->names;
1799 }
1800
1801 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1802    itself, calling F for each.  The DATA is passed to F as well.  */
1803
1804 static int
1805 walk_namespaces_r (namespace, f, data)
1806      tree namespace;
1807      walk_namespaces_fn f;
1808      void *data;
1809 {
1810   tree current;
1811   int result = 0;
1812
1813   result |= (*f) (namespace, data);
1814
1815   for (current = cp_namespace_decls (namespace);
1816        current;
1817        current = TREE_CHAIN (current))
1818     {
1819       if (TREE_CODE (current) != NAMESPACE_DECL
1820           || DECL_NAMESPACE_ALIAS (current))
1821         continue;
1822       if (!DECL_LANG_SPECIFIC (current))
1823         {
1824           /* Hmm. std. */
1825           my_friendly_assert (current == fake_std_node, 393);
1826           continue;
1827         }
1828
1829       /* We found a namespace.  */
1830       result |= walk_namespaces_r (current, f, data);
1831     }
1832
1833   return result;
1834 }
1835
1836 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1837    F as well.  */
1838
1839 int
1840 walk_namespaces (f, data)
1841      walk_namespaces_fn f;
1842      void *data;
1843 {
1844   return walk_namespaces_r (global_namespace, f, data);
1845 }
1846
1847 struct walk_globals_data {
1848   walk_globals_pred p;
1849   walk_globals_fn f;
1850   void *data;
1851 };
1852
1853 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1854    for which P returns non-zero, call F with its address.  If any call
1855    to F returns a non-zero value, return a non-zero value.  */
1856
1857 static int
1858 walk_globals_r (namespace, data)
1859      tree namespace;
1860      void *data;
1861 {
1862   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1863   walk_globals_pred p = wgd->p;
1864   walk_globals_fn f = wgd->f;
1865   void *d = wgd->data;
1866   tree *t;
1867   int result = 0;
1868
1869   t = &NAMESPACE_LEVEL (namespace)->names;
1870
1871   while (*t)
1872     {
1873       tree glbl = *t;
1874
1875       if ((*p) (glbl, d))
1876         result |= (*f) (t, d);
1877
1878       /* If F changed *T, then *T still points at the next item to
1879          examine.  */
1880       if (*t == glbl)
1881         t = &TREE_CHAIN (*t);
1882     }
1883
1884   return result;
1885 }
1886
1887 /* Walk the global declarations.  Whenever one is found for which P
1888    returns non-zero, call F with its address.  If any call to F
1889    returns a non-zero value, return a non-zero value.  */
1890
1891 int
1892 walk_globals (p, f, data)
1893      walk_globals_pred p;
1894      walk_globals_fn f;
1895      void *data;
1896 {
1897   struct walk_globals_data wgd;
1898   wgd.p = p;
1899   wgd.f = f;
1900   wgd.data = data;
1901
1902   return walk_namespaces (walk_globals_r, &wgd);
1903 }
1904
1905 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1906    DATA is non-NULL, this is the last time we will call
1907    wrapup_global_declarations for this NAMESPACE.  */
1908
1909 int
1910 wrapup_globals_for_namespace (namespace, data)
1911      tree namespace;
1912      void *data;
1913 {
1914   tree globals = cp_namespace_decls (namespace);
1915   int len = list_length (globals);
1916   tree *vec = (tree *) alloca (sizeof (tree) * len);
1917   int i;
1918   int result;
1919   tree decl;
1920   int last_time = (data != 0);
1921
1922   if (last_time && namespace == global_namespace)
1923     /* Let compile_file handle the global namespace.  */
1924     return 0;
1925
1926   /* Process the decls in reverse order--earliest first.
1927      Put them into VEC from back to front, then take out from front.  */
1928
1929   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1930     {
1931       /* Pretend we've output an unused static variable.  This ensures
1932          that the toplevel __FUNCTION__ etc won't be emitted, unless
1933          needed. */
1934       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1935           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1936         {
1937           TREE_ASM_WRITTEN (decl) = 1;
1938           DECL_IGNORED_P (decl) = 1;
1939         }
1940       vec[len - i - 1] = decl;
1941     }
1942
1943   if (last_time)
1944     {
1945       check_global_declarations (vec, len);
1946       return 0;
1947     }
1948
1949   /* Temporarily mark vtables as external.  That prevents
1950      wrapup_global_declarations from writing them out; we must process
1951      them ourselves in finish_vtable_vardecl.  */
1952   for (i = 0; i < len; ++i)
1953     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1954       {
1955         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1956         DECL_EXTERNAL (vec[i]) = 1;
1957       }
1958
1959   /* Write out any globals that need to be output.  */
1960   result = wrapup_global_declarations (vec, len);
1961
1962   /* Undo the hack to DECL_EXTERNAL above.  */
1963   for (i = 0; i < len; ++i)
1964     if (vtable_decl_p (vec[i], /*data=*/0)
1965         && DECL_NOT_REALLY_EXTERN (vec[i]))
1966       {
1967         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1968         DECL_EXTERNAL (vec[i]) = 0;
1969       }
1970
1971   return result;
1972 }
1973
1974 \f
1975 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1976
1977 static void
1978 mark_binding_level (arg)
1979      void *arg;
1980 {
1981   struct binding_level *lvl = *(struct binding_level **)arg;
1982
1983   for (; lvl; lvl = lvl->level_chain)
1984     {
1985       ggc_mark_tree (lvl->names);
1986       ggc_mark_tree (lvl->tags);
1987       ggc_mark_tree (lvl->usings);
1988       ggc_mark_tree (lvl->using_directives);
1989       ggc_mark_tree (lvl->class_shadowed);
1990       ggc_mark_tree (lvl->type_shadowed);
1991       ggc_mark_tree (lvl->shadowed_labels);
1992       ggc_mark_tree (lvl->blocks);
1993       ggc_mark_tree (lvl->this_class);
1994       ggc_mark_tree (lvl->incomplete);
1995       ggc_mark_tree (lvl->dead_vars_from_for);
1996     }
1997 }
1998
1999 static void
2000 mark_named_label_lists (labs, uses)
2001      void *labs;
2002      void *uses;
2003 {
2004   struct named_label_list *l = *(struct named_label_list **)labs;
2005   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2006
2007   for (; l; l = l->next)
2008     {
2009       ggc_mark (l);
2010       mark_binding_level (l->binding_level);
2011       ggc_mark_tree (l->old_value);
2012       ggc_mark_tree (l->label_decl);
2013       ggc_mark_tree (l->bad_decls);
2014     }
2015
2016   for (; u; u = u->next)
2017     ggc_mark (u);
2018 }
2019 \f
2020 /* For debugging.  */
2021 static int no_print_functions = 0;
2022 static int no_print_builtins = 0;
2023
2024 void
2025 print_binding_level (lvl)
2026      struct binding_level *lvl;
2027 {
2028   tree t;
2029   int i = 0, len;
2030   fprintf (stderr, " blocks=");
2031   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2032   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2033            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2034   if (lvl->tag_transparent)
2035     fprintf (stderr, " tag-transparent");
2036   if (lvl->more_cleanups_ok)
2037     fprintf (stderr, " more-cleanups-ok");
2038   if (lvl->have_cleanups)
2039     fprintf (stderr, " have-cleanups");
2040   fprintf (stderr, "\n");
2041   if (lvl->names)
2042     {
2043       fprintf (stderr, " names:\t");
2044       /* We can probably fit 3 names to a line?  */
2045       for (t = lvl->names; t; t = TREE_CHAIN (t))
2046         {
2047           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2048             continue;
2049           if (no_print_builtins
2050               && (TREE_CODE (t) == TYPE_DECL)
2051               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2052             continue;
2053
2054           /* Function decls tend to have longer names.  */
2055           if (TREE_CODE (t) == FUNCTION_DECL)
2056             len = 3;
2057           else
2058             len = 2;
2059           i += len;
2060           if (i > 6)
2061             {
2062               fprintf (stderr, "\n\t");
2063               i = len;
2064             }
2065           print_node_brief (stderr, "", t, 0);
2066           if (t == error_mark_node)
2067             break;
2068         }
2069       if (i)
2070         fprintf (stderr, "\n");
2071     }
2072   if (lvl->tags)
2073     {
2074       fprintf (stderr, " tags:\t");
2075       i = 0;
2076       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2077         {
2078           if (TREE_PURPOSE (t) == NULL_TREE)
2079             len = 3;
2080           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2081             len = 2;
2082           else
2083             len = 4;
2084           i += len;
2085           if (i > 5)
2086             {
2087               fprintf (stderr, "\n\t");
2088               i = len;
2089             }
2090           if (TREE_PURPOSE (t) == NULL_TREE)
2091             {
2092               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2093               fprintf (stderr, ">");
2094             }
2095           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2096             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2097           else
2098             {
2099               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2100               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2101               fprintf (stderr, ">");
2102             }
2103         }
2104       if (i)
2105         fprintf (stderr, "\n");
2106     }
2107   if (lvl->class_shadowed)
2108     {
2109       fprintf (stderr, " class-shadowed:");
2110       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2111         {
2112           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2113         }
2114       fprintf (stderr, "\n");
2115     }
2116   if (lvl->type_shadowed)
2117     {
2118       fprintf (stderr, " type-shadowed:");
2119       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2120         {
2121           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2122         }
2123       fprintf (stderr, "\n");
2124     }
2125 }
2126
2127 void
2128 print_other_binding_stack (stack)
2129      struct binding_level *stack;
2130 {
2131   struct binding_level *level;
2132   for (level = stack; level != global_binding_level; level = level->level_chain)
2133     {
2134       fprintf (stderr, "binding level ");
2135       fprintf (stderr, HOST_PTR_PRINTF, level);
2136       fprintf (stderr, "\n");
2137       print_binding_level (level);
2138     }
2139 }
2140
2141 void
2142 print_binding_stack ()
2143 {
2144   struct binding_level *b;
2145   fprintf (stderr, "current_binding_level=");
2146   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2147   fprintf (stderr, "\nclass_binding_level=");
2148   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2149   fprintf (stderr, "\nglobal_binding_level=");
2150   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2151   fprintf (stderr, "\n");
2152   if (class_binding_level)
2153     {
2154       for (b = class_binding_level; b; b = b->level_chain)
2155         if (b == current_binding_level)
2156           break;
2157       if (b)
2158         b = class_binding_level;
2159       else
2160         b = current_binding_level;
2161     }
2162   else
2163     b = current_binding_level;
2164   print_other_binding_stack (b);
2165   fprintf (stderr, "global:\n");
2166   print_binding_level (global_binding_level);
2167 }
2168
2169 /* Namespace binding access routines: The namespace_bindings field of
2170    the identifier is polymorphic, with three possible values:
2171    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2172    indicating the BINDING_VALUE of global_namespace. */
2173
2174 /* Check whether the a binding for the name to scope is known.
2175    Assumes that the bindings of the name are already a list
2176    of bindings. Returns the binding found, or NULL_TREE. */
2177
2178 static tree
2179 find_binding (name, scope)
2180      tree name;
2181      tree scope;
2182 {
2183   tree iter, prev = NULL_TREE;
2184
2185   scope = ORIGINAL_NAMESPACE (scope);
2186
2187   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2188        iter = TREE_CHAIN (iter))
2189     {
2190       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2191       if (BINDING_SCOPE (iter) == scope)
2192         {
2193           /* Move binding found to the front of the list, so
2194              subsequent lookups will find it faster. */
2195           if (prev)
2196             {
2197               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2198               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2199               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2200             }
2201           return iter;
2202         }
2203       prev = iter;
2204     }
2205   return NULL_TREE;
2206 }
2207
2208 /* Always returns a binding for name in scope. If the
2209    namespace_bindings is not a list, convert it to one first.
2210    If no binding is found, make a new one. */
2211
2212 tree
2213 binding_for_name (name, scope)
2214      tree name;
2215      tree scope;
2216 {
2217   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2218   tree result;
2219
2220   scope = ORIGINAL_NAMESPACE (scope);
2221
2222   if (b && TREE_CODE (b) != CPLUS_BINDING)
2223     {
2224       /* Get rid of optimization for global scope. */
2225       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2226       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2227       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2228     }
2229   if (b && (result = find_binding (name, scope)))
2230     return result;
2231   /* Not found, make a new one. */
2232   result = make_node (CPLUS_BINDING);
2233   TREE_CHAIN (result) = b;
2234   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2235   BINDING_SCOPE (result) = scope;
2236   BINDING_TYPE (result) = NULL_TREE;
2237   BINDING_VALUE (result) = NULL_TREE;
2238   return result;
2239 }
2240
2241 /* Return the binding value for name in scope, considering that
2242    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2243
2244 tree
2245 namespace_binding (name, scope)
2246      tree name;
2247      tree scope;
2248 {
2249   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2250   if (b == NULL_TREE)
2251     return NULL_TREE;
2252   if (scope == NULL_TREE)
2253     scope = global_namespace;
2254   if (TREE_CODE (b) != CPLUS_BINDING)
2255     return (scope == global_namespace) ? b : NULL_TREE;
2256   name = find_binding (name,scope);
2257   if (name == NULL_TREE)
2258     return name;
2259   return BINDING_VALUE (name);
2260 }
2261
2262 /* Set the binding value for name in scope. If modifying the binding
2263    of global_namespace is attempted, try to optimize it. */
2264
2265 void
2266 set_namespace_binding (name, scope, val)
2267      tree name;
2268      tree scope;
2269      tree val;
2270 {
2271   tree b;
2272
2273   if (scope == NULL_TREE)
2274     scope = global_namespace;
2275
2276   if (scope == global_namespace)
2277     {
2278       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2279       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2280         {
2281           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2282           return;
2283         }
2284     }
2285   b = binding_for_name (name, scope);
2286   BINDING_VALUE (b) = val;
2287 }
2288
2289 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2290    select a name that is unique to this compilation unit.  */
2291
2292 void
2293 push_namespace (name)
2294      tree name;
2295 {
2296   tree d = NULL_TREE;
2297   int need_new = 1;
2298   int implicit_use = 0;
2299   int global = 0;
2300   if (!global_namespace)
2301     {
2302       /* This must be ::. */
2303       my_friendly_assert (name == get_identifier ("::"), 377);
2304       global = 1;
2305     }
2306   else if (!name)
2307     {
2308       /* The name of anonymous namespace is unique for the translation
2309          unit.  */
2310       if (!anonymous_namespace_name)
2311         anonymous_namespace_name = get_file_function_name ('N');
2312       name = anonymous_namespace_name;
2313       d = IDENTIFIER_NAMESPACE_VALUE (name);
2314       if (d)
2315         /* Reopening anonymous namespace.  */
2316         need_new = 0;
2317       implicit_use = 1;
2318     }
2319   else if (current_namespace == global_namespace
2320            && !flag_honor_std
2321            && name == std_identifier)
2322     {
2323       in_fake_std++;
2324       return;
2325     }
2326   else
2327     {
2328       /* Check whether this is an extended namespace definition. */
2329       d = IDENTIFIER_NAMESPACE_VALUE (name);
2330       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2331         {
2332           need_new = 0;
2333           if (DECL_NAMESPACE_ALIAS (d))
2334             {
2335               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2336                         d, DECL_NAMESPACE_ALIAS (d));
2337               d = DECL_NAMESPACE_ALIAS (d);
2338             }
2339         }
2340     }
2341
2342   if (need_new)
2343     {
2344       /* Make a new namespace, binding the name to it. */
2345       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2346       /* The global namespace is not pushed, and the global binding
2347          level is set elsewhere.  */
2348       if (!global)
2349         {
2350           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2351           d = pushdecl (d);
2352           pushlevel (0);
2353           declare_namespace_level ();
2354           NAMESPACE_LEVEL (d) = current_binding_level;
2355         }
2356     }
2357   else
2358     resume_binding_level (NAMESPACE_LEVEL (d));
2359
2360   if (implicit_use)
2361     do_using_directive (d);
2362   /* Enter the name space. */
2363   current_namespace = d;
2364 }
2365
2366 /* Pop from the scope of the current namespace.  */
2367
2368 void
2369 pop_namespace ()
2370 {
2371   if (current_namespace == global_namespace)
2372     {
2373       my_friendly_assert (in_fake_std > 0, 980421);
2374       in_fake_std--;
2375       return;
2376     }
2377   current_namespace = CP_DECL_CONTEXT (current_namespace);
2378   /* The binding level is not popped, as it might be re-opened later.  */
2379   suspend_binding_level ();
2380 }
2381
2382 /* Push into the scope of the namespace NS, even if it is deeply
2383    nested within another namespace.  */
2384
2385 void
2386 push_nested_namespace (ns)
2387      tree ns;
2388 {
2389   if (ns == global_namespace)
2390     push_to_top_level ();
2391   else
2392     {
2393       push_nested_namespace (CP_DECL_CONTEXT (ns));
2394       push_namespace (DECL_NAME (ns));
2395     }
2396 }
2397
2398 /* Pop back from the scope of the namespace NS, which was previously
2399    entered with push_nested_namespace.  */
2400
2401 void
2402 pop_nested_namespace (ns)
2403      tree ns;
2404 {
2405   while (ns != global_namespace)
2406     {
2407       pop_namespace ();
2408       ns = CP_DECL_CONTEXT (ns);
2409     }
2410
2411   pop_from_top_level ();
2412 }
2413
2414 \f
2415 /* Subroutines for reverting temporarily to top-level for instantiation
2416    of templates and such.  We actually need to clear out the class- and
2417    local-value slots of all identifiers, so that only the global values
2418    are at all visible.  Simply setting current_binding_level to the global
2419    scope isn't enough, because more binding levels may be pushed.  */
2420 struct saved_scope *scope_chain;
2421
2422 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2423
2424 static void
2425 mark_saved_scope (arg)
2426      void *arg;
2427 {
2428   struct saved_scope *t = *(struct saved_scope **)arg;
2429   while (t)
2430     {
2431       mark_binding_level (&t->class_bindings);
2432       ggc_mark_tree (t->old_bindings);
2433       ggc_mark_tree (t->old_namespace);
2434       ggc_mark_tree (t->class_name);
2435       ggc_mark_tree (t->class_type);
2436       ggc_mark_tree (t->access_specifier);
2437       ggc_mark_tree (t->function_decl);
2438       if (t->lang_base)
2439         ggc_mark_tree_varray (t->lang_base);
2440       ggc_mark_tree (t->lang_name);
2441       ggc_mark_tree (t->template_parms);
2442       ggc_mark_tree (t->x_previous_class_type);
2443       ggc_mark_tree (t->x_previous_class_values);
2444       ggc_mark_tree (t->x_saved_tree);
2445       ggc_mark_tree (t->incomplete);
2446       ggc_mark_tree (t->lookups);
2447
2448       mark_stmt_tree (&t->x_stmt_tree);
2449       mark_binding_level (&t->bindings);
2450       t = t->prev;
2451     }
2452 }
2453
2454 static tree
2455 store_bindings (names, old_bindings)
2456      tree names, old_bindings;
2457 {
2458   tree t;
2459   for (t = names; t; t = TREE_CHAIN (t))
2460     {
2461       tree binding, t1, id;
2462
2463       if (TREE_CODE (t) == TREE_LIST)
2464         id = TREE_PURPOSE (t);
2465       else
2466         id = DECL_NAME (t);
2467
2468       if (!id
2469           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2470              we have no IDENTIFIER_BINDING if we have left the class
2471              scope, but cached the class-level declarations.  */
2472           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2473         continue;
2474
2475       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2476         if (TREE_VEC_ELT (t1, 0) == id)
2477           goto skip_it;
2478
2479       binding = make_tree_vec (4);
2480
2481       if (id)
2482         {
2483           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2484           TREE_VEC_ELT (binding, 0) = id;
2485           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2486           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2487           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2488           IDENTIFIER_BINDING (id) = NULL_TREE;
2489           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2490         }
2491       TREE_CHAIN (binding) = old_bindings;
2492       old_bindings = binding;
2493     skip_it:
2494       ;
2495     }
2496   return old_bindings;
2497 }
2498
2499 void
2500 maybe_push_to_top_level (pseudo)
2501      int pseudo;
2502 {
2503   struct saved_scope *s;
2504   struct binding_level *b;
2505   tree old_bindings;
2506   int need_pop;
2507
2508   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2509
2510   b = scope_chain ? current_binding_level : 0;
2511
2512   /* If we're in the middle of some function, save our state.  */
2513   if (cfun)
2514     {
2515       need_pop = 1;
2516       push_function_context_to (NULL_TREE);
2517     }
2518   else
2519     need_pop = 0;
2520
2521   old_bindings = NULL_TREE;
2522   if (scope_chain && previous_class_type)
2523     old_bindings = store_bindings (previous_class_values, old_bindings);
2524
2525   /* Have to include global_binding_level, because class-level decls
2526      aren't listed anywhere useful.  */
2527   for (; b; b = b->level_chain)
2528     {
2529       tree t;
2530
2531       /* Template IDs are inserted into the global level. If they were
2532          inserted into namespace level, finish_file wouldn't find them
2533          when doing pending instantiations. Therefore, don't stop at
2534          namespace level, but continue until :: .  */
2535       if (b == global_binding_level || (pseudo && b->template_parms_p))
2536         break;
2537
2538       old_bindings = store_bindings (b->names, old_bindings);
2539       /* We also need to check class_shadowed to save class-level type
2540          bindings, since pushclass doesn't fill in b->names.  */
2541       if (b->parm_flag == 2)
2542         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2543
2544       /* Unwind type-value slots back to top level.  */
2545       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2546         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2547     }
2548   s->prev = scope_chain;
2549   s->old_bindings = old_bindings;
2550   s->bindings = b;
2551   s->need_pop_function_context = need_pop;
2552   s->function_decl = current_function_decl;
2553
2554   scope_chain = s;
2555   current_function_decl = NULL_TREE;
2556   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2557   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2558   current_lang_name = lang_name_cplusplus;
2559   current_namespace = global_namespace;
2560 }
2561
2562 void
2563 push_to_top_level ()
2564 {
2565   maybe_push_to_top_level (0);
2566 }
2567
2568 void
2569 pop_from_top_level ()
2570 {
2571   struct saved_scope *s = scope_chain;
2572   tree t;
2573
2574   /* Clear out class-level bindings cache.  */
2575   if (previous_class_type)
2576     invalidate_class_lookup_cache ();
2577
2578   VARRAY_FREE (current_lang_base);
2579
2580   scope_chain = s->prev;
2581   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2582     {
2583       tree id = TREE_VEC_ELT (t, 0);
2584       if (id)
2585         {
2586           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2587           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2588           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2589         }
2590     }
2591
2592   /* If we were in the middle of compiling a function, restore our
2593      state.  */
2594   if (s->need_pop_function_context)
2595     pop_function_context_from (NULL_TREE);
2596   current_function_decl = s->function_decl;
2597
2598   free (s);
2599 }
2600 \f
2601 /* Push a definition of struct, union or enum tag "name".
2602    into binding_level "b".   "type" should be the type node,
2603    We assume that the tag "name" is not already defined.
2604
2605    Note that the definition may really be just a forward reference.
2606    In that case, the TYPE_SIZE will be a NULL_TREE.
2607
2608    C++ gratuitously puts all these tags in the name space.  */
2609
2610 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2611    record the shadowed value for this binding contour.  TYPE is
2612    the type that ID maps to.  */
2613
2614 static void
2615 set_identifier_type_value_with_scope (id, type, b)
2616      tree id;
2617      tree type;
2618      struct binding_level *b;
2619 {
2620   if (!b->namespace_p)
2621     {
2622       /* Shadow the marker, not the real thing, so that the marker
2623          gets restored later. */
2624       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2625       b->type_shadowed
2626         = tree_cons (id, old_type_value, b->type_shadowed);
2627     }
2628   else
2629     {
2630       tree binding = binding_for_name (id, current_namespace);
2631       BINDING_TYPE (binding) = type;
2632       /* Store marker instead of real type. */
2633       type = global_type_node;
2634     }
2635   SET_IDENTIFIER_TYPE_VALUE (id, type);
2636 }
2637
2638 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2639
2640 void
2641 set_identifier_type_value (id, type)
2642      tree id;
2643      tree type;
2644 {
2645   set_identifier_type_value_with_scope (id, type, current_binding_level);
2646 }
2647
2648 /* Return the type associated with id. */
2649
2650 tree
2651 identifier_type_value (id)
2652      tree id;
2653 {
2654   /* There is no type with that name, anywhere. */
2655   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2656     return NULL_TREE;
2657   /* This is not the type marker, but the real thing. */
2658   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2659     return REAL_IDENTIFIER_TYPE_VALUE (id);
2660   /* Have to search for it. It must be on the global level, now.
2661      Ask lookup_name not to return non-types. */
2662   id = lookup_name_real (id, 2, 1, 0);
2663   if (id)
2664     return TREE_TYPE (id);
2665   return NULL_TREE;
2666 }
2667
2668 /* Pop off extraneous binding levels left over due to syntax errors.
2669
2670    We don't pop past namespaces, as they might be valid.  */
2671
2672 void
2673 pop_everything ()
2674 {
2675 #ifdef DEBUG_CP_BINDING_LEVELS
2676   fprintf (stderr, "XXX entering pop_everything ()\n");
2677 #endif
2678   while (!toplevel_bindings_p ())
2679     {
2680       if (current_binding_level->parm_flag == 2)
2681         pop_nested_class ();
2682       else
2683         poplevel (0, 0, 0);
2684     }
2685 #ifdef DEBUG_CP_BINDING_LEVELS
2686   fprintf (stderr, "XXX leaving pop_everything ()\n");
2687 #endif
2688 }
2689
2690 /* The type TYPE is being declared.  If it is a class template, or a
2691    specialization of a class template, do any processing required and
2692    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2693    being declared a friend.  B is the binding level at which this TYPE
2694    should be bound.
2695
2696    Returns the TYPE_DECL for TYPE, which may have been altered by this
2697    processing.  */
2698
2699 static tree
2700 maybe_process_template_type_declaration (type, globalize, b)
2701      tree type;
2702      int globalize;
2703      struct binding_level* b;
2704 {
2705   tree decl = TYPE_NAME (type);
2706
2707   if (processing_template_parmlist)
2708     /* You can't declare a new template type in a template parameter
2709        list.  But, you can declare a non-template type:
2710
2711          template <class A*> struct S;
2712
2713        is a forward-declaration of `A'.  */
2714     ;
2715   else
2716     {
2717       maybe_check_template_type (type);
2718
2719       my_friendly_assert (IS_AGGR_TYPE (type)
2720                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2721
2722
2723       if (processing_template_decl)
2724         {
2725           /* This may change after the call to
2726              push_template_decl_real, but we want the original value.  */
2727           tree name = DECL_NAME (decl);
2728
2729           decl = push_template_decl_real (decl, globalize);
2730           /* If the current binding level is the binding level for the
2731              template parameters (see the comment in
2732              begin_template_parm_list) and the enclosing level is a class
2733              scope, and we're not looking at a friend, push the
2734              declaration of the member class into the class scope.  In the
2735              friend case, push_template_decl will already have put the
2736              friend into global scope, if appropriate.  */
2737           if (TREE_CODE (type) != ENUMERAL_TYPE
2738               && !globalize && b->template_parms_p
2739               && b->level_chain->parm_flag == 2)
2740             {
2741               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2742               /* Put this tag on the list of tags for the class, since
2743                  that won't happen below because B is not the class
2744                  binding level, but is instead the pseudo-global level.  */
2745               b->level_chain->tags =
2746                 tree_cons (name, type, b->level_chain->tags);
2747               if (!COMPLETE_TYPE_P (current_class_type))
2748                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2749             }
2750         }
2751     }
2752
2753   return decl;
2754 }
2755
2756 /* In C++, you don't have to write `struct S' to refer to `S'; you
2757    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2758    if the user had written `typedef struct S S'.  Create and return
2759    the TYPE_DECL for TYPE.  */
2760
2761 tree
2762 create_implicit_typedef (name, type)
2763      tree name;
2764      tree type;
2765 {
2766   tree decl;
2767
2768   decl = build_decl (TYPE_DECL, name, type);
2769   DECL_ARTIFICIAL (decl) = 1;
2770   /* There are other implicit type declarations, like the one *within*
2771      a class that allows you to write `S::S'.  We must distinguish
2772      amongst these.  */
2773   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2774   TYPE_NAME (type) = decl;
2775
2776   return decl;
2777 }
2778
2779 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2780    Normally put it into the inner-most non-tag-transparent scope,
2781    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2782    The latter is needed for implicit declarations.  */
2783
2784 void
2785 pushtag (name, type, globalize)
2786      tree name, type;
2787      int globalize;
2788 {
2789   register struct binding_level *b;
2790
2791   b = current_binding_level;
2792   while (b->tag_transparent
2793          || (globalize && b->parm_flag == 2))
2794     b = b->level_chain;
2795
2796   b->tags = tree_cons (name, type, b->tags);
2797
2798   if (name)
2799     {
2800       /* Do C++ gratuitous typedefing.  */
2801       if (IDENTIFIER_TYPE_VALUE (name) != type)
2802         {
2803           register tree d = NULL_TREE;
2804           int in_class = 0;
2805           tree context = TYPE_CONTEXT (type);
2806
2807           if (! context)
2808             {
2809               tree cs = current_scope ();
2810
2811               if (! globalize)
2812                 context = cs;
2813               else if (cs != NULL_TREE && TYPE_P (cs))
2814                 /* When declaring a friend class of a local class, we want
2815                    to inject the newly named class into the scope
2816                    containing the local class, not the namespace scope.  */
2817                 context = decl_function_context (get_type_decl (cs));
2818             }
2819           if (!context)
2820             context = current_namespace;
2821
2822           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2823               || b->parm_flag == 2)
2824             in_class = 1;
2825
2826           if (current_lang_name == lang_name_java)
2827             TYPE_FOR_JAVA (type) = 1;
2828
2829           d = create_implicit_typedef (name, type);
2830           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2831           if (! in_class)
2832             set_identifier_type_value_with_scope (name, type, b);
2833
2834           d = maybe_process_template_type_declaration (type,
2835                                                        globalize, b);
2836
2837           if (b->parm_flag == 2)
2838             {
2839               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2840                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2841                    class.  But if it's a member template class, we
2842                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2843                    is done later.  */
2844                 finish_member_declaration (d);
2845               else
2846                 pushdecl_class_level (d);
2847             }
2848           else
2849             d = pushdecl_with_scope (d, b);
2850
2851           if (ANON_AGGRNAME_P (name))
2852             DECL_IGNORED_P (d) = 1;
2853
2854           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2855           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2856
2857           /* If this is a local class, keep track of it.  We need this
2858              information for name-mangling, and so that it is possible to find
2859              all function definitions in a translation unit in a convenient
2860              way.  (It's otherwise tricky to find a member function definition
2861              it's only pointed to from within a local class.)  */
2862           if (TYPE_CONTEXT (type)
2863               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2864               && !processing_template_decl)
2865             VARRAY_PUSH_TREE (local_classes, type);
2866
2867           if (!uses_template_parms (type))
2868             {
2869               if (flag_new_abi)
2870                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2871               else
2872                 DECL_ASSEMBLER_NAME (d)
2873                   = get_identifier (build_overload_name (type, 1, 1));
2874             }
2875         }
2876       if (b->parm_flag == 2)
2877         {
2878           if (!COMPLETE_TYPE_P (current_class_type))
2879             CLASSTYPE_TAGS (current_class_type) = b->tags;
2880         }
2881     }
2882
2883   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2884     /* Use the canonical TYPE_DECL for this node.  */
2885     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2886   else
2887     {
2888       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2889          will be the tagged type we just added to the current
2890          binding level.  This fake NULL-named TYPE_DECL node helps
2891          dwarfout.c to know when it needs to output a
2892          representation of a tagged type, and it also gives us a
2893          convenient place to record the "scope start" address for
2894          the tagged type.  */
2895
2896       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2897       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2898     }
2899 }
2900
2901 /* Counter used to create anonymous type names.  */
2902
2903 static int anon_cnt = 0;
2904
2905 /* Return an IDENTIFIER which can be used as a name for
2906    anonymous structs and unions.  */
2907
2908 tree
2909 make_anon_name ()
2910 {
2911   char buf[32];
2912
2913   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2914   return get_identifier (buf);
2915 }
2916
2917 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2918    This keeps dbxout from getting confused.  */
2919
2920 void
2921 clear_anon_tags ()
2922 {
2923   register struct binding_level *b;
2924   register tree tags;
2925   static int last_cnt = 0;
2926
2927   /* Fast out if no new anon names were declared.  */
2928   if (last_cnt == anon_cnt)
2929     return;
2930
2931   b = current_binding_level;
2932   while (b->tag_transparent)
2933     b = b->level_chain;
2934   tags = b->tags;
2935   while (tags)
2936     {
2937       /* A NULL purpose means we have already processed all tags
2938          from here to the end of the list.  */
2939       if (TREE_PURPOSE (tags) == NULL_TREE)
2940         break;
2941       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2942         TREE_PURPOSE (tags) = NULL_TREE;
2943       tags = TREE_CHAIN (tags);
2944     }
2945   last_cnt = anon_cnt;
2946 }
2947 \f
2948 /* Subroutine of duplicate_decls: return truthvalue of whether
2949    or not types of these decls match.
2950
2951    For C++, we must compare the parameter list so that `int' can match
2952    `int&' in a parameter position, but `int&' is not confused with
2953    `const int&'.  */
2954
2955 int
2956 decls_match (newdecl, olddecl)
2957      tree newdecl, olddecl;
2958 {
2959   int types_match;
2960
2961   if (newdecl == olddecl)
2962     return 1;
2963
2964   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2965     /* If the two DECLs are not even the same kind of thing, we're not
2966        interested in their types.  */
2967     return 0;
2968
2969   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2970     {
2971       tree f1 = TREE_TYPE (newdecl);
2972       tree f2 = TREE_TYPE (olddecl);
2973       tree p1 = TYPE_ARG_TYPES (f1);
2974       tree p2 = TYPE_ARG_TYPES (f2);
2975
2976       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2977           && ! (DECL_EXTERN_C_P (newdecl)
2978                 && DECL_EXTERN_C_P (olddecl)))
2979         return 0;
2980
2981       if (TREE_CODE (f1) != TREE_CODE (f2))
2982         return 0;
2983
2984       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2985         {
2986           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2987               && (DECL_BUILT_IN (olddecl)
2988 #ifndef NO_IMPLICIT_EXTERN_C
2989                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2990                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2991 #endif
2992               ))
2993             {
2994               types_match = self_promoting_args_p (p1);
2995               if (p1 == void_list_node)
2996                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2997             }
2998 #ifndef NO_IMPLICIT_EXTERN_C
2999           else if (p1 == NULL_TREE
3000                    && (DECL_EXTERN_C_P (olddecl)
3001                        && DECL_IN_SYSTEM_HEADER (olddecl)
3002                        && !DECL_CLASS_SCOPE_P (olddecl))
3003                    && (DECL_EXTERN_C_P (newdecl)
3004                        && DECL_IN_SYSTEM_HEADER (newdecl)
3005                        && !DECL_CLASS_SCOPE_P (newdecl)))
3006             {
3007               types_match = self_promoting_args_p (p2);
3008               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3009             }
3010 #endif
3011           else
3012             types_match = compparms (p1, p2);
3013         }
3014       else
3015         types_match = 0;
3016     }
3017   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3018     {
3019       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3020                                 DECL_TEMPLATE_PARMS (olddecl)))
3021         return 0;
3022
3023       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3024           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3025         return 0;
3026
3027       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3028         types_match = 1;
3029       else
3030         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3031                                    DECL_TEMPLATE_RESULT (newdecl));
3032     }
3033   else
3034     {
3035       if (TREE_TYPE (newdecl) == error_mark_node)
3036         types_match = TREE_TYPE (olddecl) == error_mark_node;
3037       else if (TREE_TYPE (olddecl) == NULL_TREE)
3038         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3039       else if (TREE_TYPE (newdecl) == NULL_TREE)
3040         types_match = 0;
3041       else
3042         types_match = comptypes (TREE_TYPE (newdecl),
3043                                  TREE_TYPE (olddecl),
3044                                  COMPARE_REDECLARATION);
3045     }
3046
3047   return types_match;
3048 }
3049
3050 /* If NEWDECL is `static' and an `extern' was seen previously,
3051    warn about it.  OLDDECL is the previous declaration.
3052
3053    Note that this does not apply to the C++ case of declaring
3054    a variable `extern const' and then later `const'.
3055
3056    Don't complain about built-in functions, since they are beyond
3057    the user's control.  */
3058
3059 static void
3060 warn_extern_redeclared_static (newdecl, olddecl)
3061      tree newdecl, olddecl;
3062 {
3063   static const char *explicit_extern_static_warning
3064     = "`%D' was declared `extern' and later `static'";
3065   static const char *implicit_extern_static_warning
3066     = "`%D' was declared implicitly `extern' and later `static'";
3067
3068   tree name;
3069
3070   if (TREE_CODE (newdecl) == TYPE_DECL
3071       || TREE_CODE (newdecl) == TEMPLATE_DECL
3072       || TREE_CODE (newdecl) == CONST_DECL)
3073     return;
3074
3075   /* Don't get confused by static member functions; that's a different
3076      use of `static'.  */
3077   if (TREE_CODE (newdecl) == FUNCTION_DECL
3078       && DECL_STATIC_FUNCTION_P (newdecl))
3079     return;
3080
3081   /* If the old declaration was `static', or the new one isn't, then
3082      then everything is OK.  */
3083   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3084     return;
3085
3086   /* It's OK to declare a builtin function as `static'.  */
3087   if (TREE_CODE (olddecl) == FUNCTION_DECL
3088       && DECL_ARTIFICIAL (olddecl))
3089     return;
3090
3091   name = DECL_ASSEMBLER_NAME (newdecl);
3092   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3093               ? implicit_extern_static_warning
3094               : explicit_extern_static_warning, newdecl);
3095   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3096 }
3097
3098 /* Handle when a new declaration NEWDECL has the same name as an old
3099    one OLDDECL in the same binding contour.  Prints an error message
3100    if appropriate.
3101
3102    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3103    Otherwise, return 0.  */
3104
3105 int
3106 duplicate_decls (newdecl, olddecl)
3107      tree newdecl, olddecl;
3108 {
3109   unsigned olddecl_uid = DECL_UID (olddecl);
3110   int olddecl_friend = 0, types_match = 0;
3111   int new_defines_function = 0;
3112
3113   if (newdecl == olddecl)
3114     return 1;
3115
3116   types_match = decls_match (newdecl, olddecl);
3117
3118   /* If either the type of the new decl or the type of the old decl is an
3119      error_mark_node, then that implies that we have already issued an
3120      error (earlier) for some bogus type specification, and in that case,
3121      it is rather pointless to harass the user with yet more error message
3122      about the same declaration, so just pretend the types match here.  */
3123   if (TREE_TYPE (newdecl) == error_mark_node
3124       || TREE_TYPE (olddecl) == error_mark_node)
3125     types_match = 1;
3126
3127   /* Check for redeclaration and other discrepancies. */
3128   if (TREE_CODE (olddecl) == FUNCTION_DECL
3129       && DECL_ARTIFICIAL (olddecl))
3130     {
3131       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3132         {
3133           /* If you declare a built-in or predefined function name as static,
3134              the old definition is overridden, but optionally warn this was a
3135              bad choice of name.  */
3136           if (! TREE_PUBLIC (newdecl))
3137             {
3138               if (warn_shadow)
3139                 cp_warning ("shadowing %s function `%#D'",
3140                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3141                             olddecl);
3142               /* Discard the old built-in function.  */
3143               return 0;
3144             }
3145           /* If the built-in is not ansi, then programs can override
3146              it even globally without an error.  */
3147           else if (! DECL_BUILT_IN (olddecl))
3148             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3149                         olddecl, newdecl);
3150           else
3151             {
3152               cp_error ("declaration of `%#D'", newdecl);
3153               cp_error ("conflicts with built-in declaration `%#D'",
3154                         olddecl);
3155             }
3156           return 0;
3157         }
3158       else if (!types_match)
3159         {
3160           if ((DECL_EXTERN_C_P (newdecl)
3161                && DECL_EXTERN_C_P (olddecl))
3162               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3163                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3164             {
3165               /* A near match; override the builtin.  */
3166
3167               if (TREE_PUBLIC (newdecl))
3168                 {
3169                   cp_warning ("new declaration `%#D'", newdecl);
3170                   cp_warning ("ambiguates built-in declaration `%#D'",
3171                               olddecl);
3172                 }
3173               else if (warn_shadow)
3174                 cp_warning ("shadowing %s function `%#D'",
3175                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3176                             olddecl);
3177             }
3178           else
3179             /* Discard the old built-in function.  */
3180             return 0;
3181         }
3182
3183       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3184         {
3185           /* If a builtin function is redeclared as `static', merge
3186              the declarations, but make the original one static.  */
3187           DECL_THIS_STATIC (olddecl) = 1;
3188           TREE_PUBLIC (olddecl) = 0;
3189
3190           /* Make the old declaration consistent with the new one so
3191              that all remnants of the builtin-ness of this function
3192              will be banished.  */
3193           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3194           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3195           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3196           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3197                                        newdecl);
3198         }
3199     }
3200   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3201     {
3202       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3203            && TREE_CODE (newdecl) != TYPE_DECL
3204            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3205                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3206           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3207               && TREE_CODE (olddecl) != TYPE_DECL
3208               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3209                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3210                         == TYPE_DECL))))
3211         {
3212           /* We do nothing special here, because C++ does such nasty
3213              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3214              get shadowed, and know that if we need to find a TYPE_DECL
3215              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3216              slot of the identifier.  */
3217           return 0;
3218         }
3219
3220       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3221            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3222           || (TREE_CODE (olddecl) == FUNCTION_DECL
3223               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3224         return 0;
3225
3226       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3227       if (TREE_CODE (olddecl) == TREE_LIST)
3228         olddecl = TREE_VALUE (olddecl);
3229       cp_error_at ("previous declaration of `%#D'", olddecl);
3230
3231       /* New decl is completely inconsistent with the old one =>
3232          tell caller to replace the old one.  */
3233
3234       return 0;
3235     }
3236   else if (!types_match)
3237     {
3238       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3239         /* These are certainly not duplicate declarations; they're
3240            from different scopes.  */
3241         return 0;
3242
3243       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3244         {
3245           /* The name of a class template may not be declared to refer to
3246              any other template, class, function, object, namespace, value,
3247              or type in the same scope.  */
3248           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3249               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3250             {
3251               cp_error ("declaration of template `%#D'", newdecl);
3252               cp_error_at ("conflicts with previous declaration `%#D'",
3253                            olddecl);
3254             }
3255           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3256                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3257                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3258                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3259                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3260                                            DECL_TEMPLATE_PARMS (olddecl)))
3261             {
3262               cp_error ("new declaration `%#D'", newdecl);
3263               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3264             }
3265           return 0;
3266         }
3267       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3268         {
3269           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3270             {
3271               cp_error ("declaration of C function `%#D' conflicts with",
3272                         newdecl);
3273               cp_error_at ("previous declaration `%#D' here", olddecl);
3274             }
3275           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3276                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3277             {
3278               cp_error ("new declaration `%#D'", newdecl);
3279               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3280             }
3281           else
3282             return 0;
3283         }
3284
3285       /* Already complained about this, so don't do so again.  */
3286       else if (current_class_type == NULL_TREE
3287           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3288         {
3289           cp_error ("conflicting types for `%#D'", newdecl);
3290           cp_error_at ("previous declaration as `%#D'", olddecl);
3291         }
3292     }
3293   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3294             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3295                  && (!DECL_TEMPLATE_INFO (newdecl)
3296                      || (DECL_TI_TEMPLATE (newdecl)
3297                          != DECL_TI_TEMPLATE (olddecl))))
3298                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3299                     && (!DECL_TEMPLATE_INFO (olddecl)
3300                         || (DECL_TI_TEMPLATE (olddecl)
3301                             != DECL_TI_TEMPLATE (newdecl))))))
3302     /* It's OK to have a template specialization and a non-template
3303        with the same type, or to have specializations of two
3304        different templates with the same type.  Note that if one is a
3305        specialization, and the other is an instantiation of the same
3306        template, that we do not exit at this point.  That situation
3307        can occur if we instantiate a template class, and then
3308        specialize one of its methods.  This situation is legal, but
3309        the declarations must be merged in the usual way.  */
3310     return 0;
3311   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3312            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3313                 && !DECL_USE_TEMPLATE (newdecl))
3314                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3315                    && !DECL_USE_TEMPLATE (olddecl))))
3316     /* One of the declarations is a template instantiation, and the
3317        other is not a template at all.  That's OK.  */
3318     return 0;
3319   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3320            && DECL_NAMESPACE_ALIAS (newdecl)
3321            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3322     /* Redeclaration of namespace alias, ignore it. */
3323     return 1;
3324   else
3325     {
3326       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3327       if (errmsg)
3328         {
3329           cp_error (errmsg, newdecl);
3330           if (DECL_NAME (olddecl) != NULL_TREE)
3331             cp_error_at ((DECL_INITIAL (olddecl)
3332                           && namespace_bindings_p ())
3333                          ? "`%#D' previously defined here"
3334                          : "`%#D' previously declared here", olddecl);
3335         }
3336       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3337                && DECL_INITIAL (olddecl) != NULL_TREE
3338                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3339                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3340         {
3341           /* Prototype decl follows defn w/o prototype.  */
3342           cp_warning_at ("prototype for `%#D'", newdecl);
3343           cp_warning_at ("follows non-prototype definition here", olddecl);
3344         }
3345       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3346                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3347         {
3348           /* extern "C" int foo ();
3349              int foo () { bar (); }
3350              is OK.  */
3351           if (current_lang_stack
3352               == &VARRAY_TREE (current_lang_base, 0))
3353             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3354           else
3355             {
3356               cp_error_at ("previous declaration of `%#D' with %L linkage",
3357                            olddecl, DECL_LANGUAGE (olddecl));
3358               cp_error ("conflicts with new declaration with %L linkage",
3359                         DECL_LANGUAGE (newdecl));
3360             }
3361         }
3362
3363       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3364         ;
3365       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3366         {
3367           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3368           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3369           int i = 1;
3370
3371           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3372             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3373
3374           for (; t1 && t1 != void_list_node;
3375                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3376             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3377               {
3378                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3379                                            TREE_PURPOSE (t2)))
3380                   {
3381                     if (pedantic)
3382                       {
3383                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3384                                     i, newdecl);
3385                         cp_pedwarn_at ("after previous specification in `%#D'",
3386                                        olddecl);
3387                       }
3388                   }
3389                 else
3390                   {
3391                     cp_error ("default argument given for parameter %d of `%#D'",
3392                               i, newdecl);
3393                     cp_error_at ("after previous specification in `%#D'",
3394                                  olddecl);
3395                   }
3396               }
3397
3398           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3399               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3400             {
3401               cp_warning ("`%#D' was used before it was declared inline",
3402                           newdecl);
3403               cp_warning_at ("previous non-inline declaration here",
3404                              olddecl);
3405             }
3406         }
3407     }
3408
3409   /* If new decl is `static' and an `extern' was seen previously,
3410      warn about it.  */
3411   warn_extern_redeclared_static (newdecl, olddecl);
3412
3413   /* We have committed to returning 1 at this point.  */
3414   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3415     {
3416       /* Now that functions must hold information normally held
3417          by field decls, there is extra work to do so that
3418          declaration information does not get destroyed during
3419          definition.  */
3420       if (DECL_VINDEX (olddecl))
3421         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3422       if (DECL_VIRTUAL_CONTEXT (olddecl))
3423         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3424       if (DECL_CONTEXT (olddecl))
3425         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3426       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3427         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3428       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3429       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3430       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3431       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3432       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3433       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3434       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3435       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3436
3437       /* Optionally warn about more than one declaration for the same
3438          name, but don't warn about a function declaration followed by a
3439          definition.  */
3440       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3441           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3442           /* Don't warn about extern decl followed by definition. */
3443           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3444           /* Don't warn about friends, let add_friend take care of it. */
3445           && ! DECL_FRIEND_P (newdecl))
3446         {
3447           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3448           cp_warning_at ("previous declaration of `%D'", olddecl);
3449         }
3450     }
3451
3452   /* Deal with C++: must preserve virtual function table size.  */
3453   if (TREE_CODE (olddecl) == TYPE_DECL)
3454     {
3455       register tree newtype = TREE_TYPE (newdecl);
3456       register tree oldtype = TREE_TYPE (olddecl);
3457
3458       if (newtype != error_mark_node && oldtype != error_mark_node
3459           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3460         {
3461           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3462           CLASSTYPE_FRIEND_CLASSES (newtype)
3463             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3464         }
3465
3466       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3467     }
3468
3469   /* Copy all the DECL_... slots specified in the new decl
3470      except for any that we copy here from the old type.  */
3471   DECL_MACHINE_ATTRIBUTES (newdecl)
3472     = merge_machine_decl_attributes (olddecl, newdecl);
3473
3474   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3475     {
3476       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3477       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3478         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3479                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3480
3481       return 1;
3482     }
3483
3484   if (types_match)
3485     {
3486       /* Automatically handles default parameters.  */
3487       tree oldtype = TREE_TYPE (olddecl);
3488       tree newtype;
3489
3490       /* Merge the data types specified in the two decls.  */
3491       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3492
3493       /* If common_type produces a non-typedef type, just use the old type.  */
3494       if (TREE_CODE (newdecl) == TYPE_DECL
3495           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3496         newtype = oldtype;
3497
3498       if (TREE_CODE (newdecl) == VAR_DECL)
3499         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3500       /* Do this after calling `common_type' so that default
3501          parameters don't confuse us.  */
3502       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3503           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3504               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3505         {
3506           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3507                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3508           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3509                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3510
3511           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3512               && DECL_SOURCE_LINE (olddecl) != 0
3513               && flag_exceptions
3514               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3515                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3516             {
3517               cp_error ("declaration of `%F' throws different exceptions",
3518                         newdecl);
3519               cp_error_at ("than previous declaration `%F'", olddecl);
3520             }
3521         }
3522       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3523
3524       /* Lay the type out, unless already done.  */
3525       if (! same_type_p (newtype, oldtype)
3526           && TREE_TYPE (newdecl) != error_mark_node
3527           && !(processing_template_decl && uses_template_parms (newdecl)))
3528         layout_type (TREE_TYPE (newdecl));
3529
3530       if ((TREE_CODE (newdecl) == VAR_DECL
3531            || TREE_CODE (newdecl) == PARM_DECL
3532            || TREE_CODE (newdecl) == RESULT_DECL
3533            || TREE_CODE (newdecl) == FIELD_DECL
3534            || TREE_CODE (newdecl) == TYPE_DECL)
3535           && !(processing_template_decl && uses_template_parms (newdecl)))
3536         layout_decl (newdecl, 0);
3537
3538       /* Merge the type qualifiers.  */
3539       if (TREE_READONLY (newdecl))
3540         TREE_READONLY (olddecl) = 1;
3541       if (TREE_THIS_VOLATILE (newdecl))
3542         TREE_THIS_VOLATILE (olddecl) = 1;
3543
3544       /* Merge the initialization information.  */
3545       if (DECL_INITIAL (newdecl) == NULL_TREE
3546           && DECL_INITIAL (olddecl) != NULL_TREE)
3547         {
3548           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3549           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3550           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3551           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3552               && DECL_LANG_SPECIFIC (newdecl)
3553               && DECL_LANG_SPECIFIC (olddecl))
3554             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3555         }
3556
3557       /* Merge the section attribute.
3558          We want to issue an error if the sections conflict but that must be
3559          done later in decl_attributes since we are called before attributes
3560          are assigned.  */
3561       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3562         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3563
3564       /* Keep the old rtl since we can safely use it.  */
3565       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3566
3567       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3568         {
3569           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3570             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3571           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3572             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3573           DECL_NO_LIMIT_STACK (newdecl)
3574             |= DECL_NO_LIMIT_STACK (olddecl);
3575         }
3576     }
3577   /* If cannot merge, then use the new type and qualifiers,
3578      and don't preserve the old rtl.  */
3579   else
3580     {
3581       /* Clean out any memory we had of the old declaration.  */
3582       tree oldstatic = value_member (olddecl, static_aggregates);
3583       if (oldstatic)
3584         TREE_VALUE (oldstatic) = error_mark_node;
3585
3586       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3587       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3588       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3589       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3590     }
3591
3592   /* Merge the storage class information.  */
3593   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3594   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3595   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3596   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3597   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3598   if (! DECL_EXTERNAL (olddecl))
3599     DECL_EXTERNAL (newdecl) = 0;
3600
3601   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3602     {
3603       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3604       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3605       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3606       DECL_TEMPLATE_INSTANTIATED (newdecl)
3607         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3608       /* Don't really know how much of the language-specific
3609          values we should copy from old to new.  */
3610       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3611       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3612       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3613       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3614       olddecl_friend = DECL_FRIEND_P (olddecl);
3615
3616       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3617       if (TREE_CODE (newdecl) == FUNCTION_DECL
3618           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3619         DECL_BEFRIENDING_CLASSES (newdecl)
3620           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3621                      DECL_BEFRIENDING_CLASSES (olddecl));
3622     }
3623
3624   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3625     {
3626       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3627           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3628         {
3629           /* If newdecl is not a specialization, then it is not a
3630              template-related function at all.  And that means that we
3631              shoud have exited above, returning 0.  */
3632           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3633                               0);
3634
3635           if (TREE_USED (olddecl))
3636             /* From [temp.expl.spec]:
3637
3638                If a template, a member template or the member of a class
3639                template is explicitly specialized then that
3640                specialization shall be declared before the first use of
3641                that specialization that would cause an implicit
3642                instantiation to take place, in every translation unit in
3643                which such a use occurs.  */
3644             cp_error ("explicit specialization of %D after first use",
3645                       olddecl);
3646
3647           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3648         }
3649       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3650
3651       /* If either decl says `inline', this fn is inline, unless its
3652          definition was passed already.  */
3653       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3654         DECL_INLINE (olddecl) = 1;
3655       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3656
3657       if (! types_match)
3658         {
3659           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3660           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3661           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3662         }
3663       if (! types_match || new_defines_function)
3664         {
3665           /* These need to be copied so that the names are available.
3666              Note that if the types do match, we'll preserve inline
3667              info and other bits, but if not, we won't.  */
3668           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3669           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3670         }
3671       if (new_defines_function)
3672         /* If defining a function declared with other language
3673            linkage, use the previously declared language linkage.  */
3674         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3675       else if (types_match)
3676         {
3677           /* If redeclaring a builtin function, and not a definition,
3678              it stays built in.  */
3679           if (DECL_BUILT_IN (olddecl))
3680             {
3681               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3682               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3683               /* If we're keeping the built-in definition, keep the rtl,
3684                  regardless of declaration matches.  */
3685               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3686             }
3687           else
3688             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3689
3690           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3691           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3692             /* Previously saved insns go together with
3693                the function's previous definition.  */
3694             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3695           /* Don't clear out the arguments if we're redefining a function.  */
3696           if (DECL_ARGUMENTS (olddecl))
3697             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3698         }
3699     }
3700
3701   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3702     {
3703       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3704     }
3705
3706   /* Now preserve various other info from the definition.  */
3707   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3708   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3709   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3710   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3711
3712   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3713     {
3714       int function_size;
3715
3716       function_size = sizeof (struct tree_decl);
3717
3718       bcopy ((char *) newdecl + sizeof (struct tree_common),
3719              (char *) olddecl + sizeof (struct tree_common),
3720              function_size - sizeof (struct tree_common));
3721
3722       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3723         {
3724           /* If newdecl is a template instantiation, it is possible that
3725              the following sequence of events has occurred:
3726
3727              o A friend function was declared in a class template.  The
3728              class template was instantiated.
3729
3730              o The instantiation of the friend declaration was
3731              recorded on the instantiation list, and is newdecl.
3732
3733              o Later, however, instantiate_class_template called pushdecl
3734              on the newdecl to perform name injection.  But, pushdecl in
3735              turn called duplicate_decls when it discovered that another
3736              declaration of a global function with the same name already
3737              existed.
3738
3739              o Here, in duplicate_decls, we decided to clobber newdecl.
3740
3741              If we're going to do that, we'd better make sure that
3742              olddecl, and not newdecl, is on the list of
3743              instantiations so that if we try to do the instantiation
3744              again we won't get the clobbered declaration.  */
3745
3746           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3747           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3748
3749           for (; decls; decls = TREE_CHAIN (decls))
3750             if (TREE_VALUE (decls) == newdecl)
3751               TREE_VALUE (decls) = olddecl;
3752         }
3753     }
3754   else
3755     {
3756       bcopy ((char *) newdecl + sizeof (struct tree_common),
3757              (char *) olddecl + sizeof (struct tree_common),
3758              sizeof (struct tree_decl) - sizeof (struct tree_common)
3759              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3760     }
3761
3762   DECL_UID (olddecl) = olddecl_uid;
3763   if (olddecl_friend)
3764     DECL_FRIEND_P (olddecl) = 1;
3765
3766   /* NEWDECL contains the merged attribute lists.
3767      Update OLDDECL to be the same.  */
3768   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3769
3770   return 1;
3771 }
3772
3773 /* Record a decl-node X as belonging to the current lexical scope.
3774    Check for errors (such as an incompatible declaration for the same
3775    name already seen in the same scope).
3776
3777    Returns either X or an old decl for the same name.
3778    If an old decl is returned, it may have been smashed
3779    to agree with what X says.  */
3780
3781 tree
3782 pushdecl (x)
3783      tree x;
3784 {
3785   register tree t;
3786   register tree name;
3787   int need_new_binding;
3788
3789   /* We shouldn't be calling pushdecl when we're generating RTL for a
3790      function that we already did semantic analysis on previously.  */
3791   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3792                       19990913);
3793
3794   need_new_binding = 1;
3795
3796   if (DECL_TEMPLATE_PARM_P (x))
3797     /* Template parameters have no context; they are not X::T even
3798        when declared within a class or namespace.  */
3799     ;
3800   else
3801     {
3802       if (current_function_decl && x != current_function_decl
3803           /* A local declaration for a function doesn't constitute
3804              nesting.  */
3805           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3806           /* A local declaration for an `extern' variable is in the
3807              scope of the current namespace, not the current
3808              function.  */
3809           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3810           && !DECL_CONTEXT (x))
3811         DECL_CONTEXT (x) = current_function_decl;
3812
3813       /* If this is the declaration for a namespace-scope function,
3814          but the declaration itself is in a local scope, mark the
3815          declaration.  */
3816       if (TREE_CODE (x) == FUNCTION_DECL
3817           && DECL_NAMESPACE_SCOPE_P (x)
3818           && current_function_decl
3819           && x != current_function_decl)
3820         DECL_LOCAL_FUNCTION_P (x) = 1;
3821     }
3822
3823   name = DECL_NAME (x);
3824   if (name)
3825     {
3826       int different_binding_level = 0;
3827
3828       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3829         name = TREE_OPERAND (name, 0);
3830
3831       /* In case this decl was explicitly namespace-qualified, look it
3832          up in its namespace context.  */
3833       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3834           && namespace_bindings_p ())
3835         t = namespace_binding (name, DECL_CONTEXT (x));
3836       else
3837         t = lookup_name_current_level (name);
3838
3839       /* [basic.link] If there is a visible declaration of an entity
3840          with linkage having the same name and type, ignoring entities
3841          declared outside the innermost enclosing namespace scope, the
3842          block scope declaration declares that same entity and
3843          receives the linkage of the previous declaration.  */
3844       if (! t && current_function_decl && x != current_function_decl
3845           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3846           && DECL_EXTERNAL (x))
3847         {
3848           /* Look in block scope.  */
3849           t = IDENTIFIER_VALUE (name);
3850           /* Or in the innermost namespace.  */
3851           if (! t)
3852             t = namespace_binding (name, DECL_CONTEXT (x));
3853           /* Does it have linkage?  */
3854           if (t && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3855             t = NULL_TREE;
3856           if (t)
3857             different_binding_level = 1;
3858         }
3859
3860       /* If we are declaring a function, and the result of name-lookup
3861          was an OVERLOAD, look for an overloaded instance that is
3862          actually the same as the function we are declaring.  (If
3863          there is one, we have to merge our declaration with the
3864          previous declaration.)  */
3865       if (t && TREE_CODE (t) == OVERLOAD)
3866         {
3867           tree match;
3868
3869           if (TREE_CODE (x) == FUNCTION_DECL)
3870             for (match = t; match; match = OVL_NEXT (match))
3871               {
3872                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3873                     == DECL_ASSEMBLER_NAME (x))
3874                   break;
3875               }
3876           else
3877             /* Just choose one.  */
3878             match = t;
3879
3880           if (match)
3881             t = OVL_CURRENT (match);
3882           else
3883             t = NULL_TREE;
3884         }
3885
3886       if (t == error_mark_node)
3887         {
3888           /* error_mark_node is 0 for a while during initialization!  */
3889           t = NULL_TREE;
3890           cp_error_at ("`%#D' used prior to declaration", x);
3891         }
3892       else if (t != NULL_TREE)
3893         {
3894           if (different_binding_level)
3895             {
3896               if (decls_match (x, t))
3897                 /* The standard only says that the local extern
3898                    inherits linkage from the previous decl; in
3899                    particular, default args are not shared.  It would
3900                    be nice to propagate inlining info, though.  FIXME.  */
3901                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3902             }
3903           else if (TREE_CODE (t) == PARM_DECL)
3904             {
3905               if (DECL_CONTEXT (t) == NULL_TREE)
3906                 fatal ("parse errors have confused me too much");
3907
3908               /* Check for duplicate params.  */
3909               if (duplicate_decls (x, t))
3910                 return t;
3911             }
3912           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3913                     || DECL_FUNCTION_TEMPLATE_P (x))
3914                    && is_overloaded_fn (t))
3915             /* Don't do anything just yet. */;
3916           else if (t == wchar_decl_node)
3917             {
3918               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3919                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3920
3921               /* Throw away the redeclaration.  */
3922               return t;
3923             }
3924           else if (TREE_CODE (t) != TREE_CODE (x))
3925             {
3926               if (duplicate_decls (x, t))
3927                 return t;
3928             }
3929           else if (duplicate_decls (x, t))
3930             {
3931               if (TREE_CODE (t) == TYPE_DECL)
3932                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3933               else if (TREE_CODE (t) == FUNCTION_DECL)
3934                 check_default_args (t);
3935
3936               return t;
3937             }
3938           else if (DECL_MAIN_P (x))
3939             {
3940               /* A redeclaration of main, but not a duplicate of the
3941                  previous one.
3942
3943                  [basic.start.main]
3944
3945                  This function shall not be overloaded.  */
3946               cp_error_at ("invalid redeclaration of `%D'", t);
3947               cp_error ("as `%D'", x);
3948               /* We don't try to push this declaration since that
3949                  causes a crash.  */
3950               return x;
3951             }
3952         }
3953
3954       check_template_shadow (x);
3955
3956       /* If this is a function conjured up by the backend, massage it
3957          so it looks friendly.  */
3958       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3959         {
3960           retrofit_lang_decl (x);
3961           DECL_LANGUAGE (x) = lang_c;
3962         }
3963
3964       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3965         {
3966           t = push_overloaded_decl (x, PUSH_LOCAL);
3967           if (t != x)
3968             return t;
3969           if (!namespace_bindings_p ())
3970             /* We do not need to create a binding for this name;
3971                push_overloaded_decl will have already done so if
3972                necessary.  */
3973             need_new_binding = 0;
3974         }
3975       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3976         {
3977           t = push_overloaded_decl (x, PUSH_GLOBAL);
3978           if (t == x)
3979             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3980           return t;
3981         }
3982
3983       /* If declaring a type as a typedef, copy the type (unless we're
3984          at line 0), and install this TYPE_DECL as the new type's typedef
3985          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3986       if (TREE_CODE (x) == TYPE_DECL)
3987         {
3988           tree type = TREE_TYPE (x);
3989           if (DECL_SOURCE_LINE (x) == 0)
3990             {
3991               if (TYPE_NAME (type) == 0)
3992                 TYPE_NAME (type) = x;
3993             }
3994           else if (type != error_mark_node && TYPE_NAME (type) != x
3995                    /* We don't want to copy the type when all we're
3996                       doing is making a TYPE_DECL for the purposes of
3997                       inlining.  */
3998                    && (!TYPE_NAME (type)
3999                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4000             {
4001               DECL_ORIGINAL_TYPE (x) = type;
4002               type = build_type_copy (type);
4003               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4004               TYPE_NAME (type) = x;
4005               TREE_TYPE (x) = type;
4006             }
4007
4008           if (type != error_mark_node
4009               && TYPE_NAME (type)
4010               && TYPE_IDENTIFIER (type))
4011             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4012                                                   current_binding_level);
4013
4014         }
4015
4016       /* Multiple external decls of the same identifier ought to match.
4017
4018          We get warnings about inline functions where they are defined.
4019          We get warnings about other functions from push_overloaded_decl.
4020
4021          Avoid duplicate warnings where they are used.  */
4022       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4023         {
4024           tree decl;
4025
4026           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4027           if (decl && TREE_CODE (decl) == OVERLOAD)
4028             decl = OVL_FUNCTION (decl);
4029
4030           if (decl && decl != error_mark_node
4031               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4032               /* If different sort of thing, we already gave an error.  */
4033               && TREE_CODE (decl) == TREE_CODE (x)
4034               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4035             {
4036               cp_pedwarn ("type mismatch with previous external decl", x);
4037               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4038             }
4039         }
4040
4041       /* This name is new in its binding level.
4042          Install the new declaration and return it.  */
4043       if (namespace_bindings_p ())
4044         {
4045           /* Install a global value.  */
4046
4047           /* If the first global decl has external linkage,
4048              warn if we later see static one.  */
4049           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4050             TREE_PUBLIC (name) = 1;
4051
4052           /* Bind the mangled name for the entity.  In the future, we
4053              should not need to do this; mangled names are an
4054              implementation detail of which the front-end should not
4055              need to be aware.  */
4056           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4057                 && t != NULL_TREE)
4058               /* For an ordinary function, we create a binding from
4059                  the mangled name (i.e., NAME) to the DECL.  But, for
4060                  an `extern "C"' function, the mangled name and the
4061                  ordinary name are the same so we need not do this.  */
4062               && !DECL_EXTERN_C_FUNCTION_P (x))
4063             {
4064               tree mangled_name;
4065
4066               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4067                   || TREE_CODE (x) == NAMESPACE_DECL)
4068                 mangled_name = name;
4069               else
4070                 mangled_name = DECL_ASSEMBLER_NAME (x);
4071
4072               if (TREE_CODE (x) == FUNCTION_DECL)
4073                 my_friendly_assert
4074                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4075                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4076               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4077             }
4078
4079           /* Don't forget if the function was used via an implicit decl.  */
4080           if (IDENTIFIER_IMPLICIT_DECL (name)
4081               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4082             TREE_USED (x) = 1;
4083
4084           /* Don't forget if its address was taken in that way.  */
4085           if (IDENTIFIER_IMPLICIT_DECL (name)
4086               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4087             TREE_ADDRESSABLE (x) = 1;
4088
4089           /* Warn about mismatches against previous implicit decl.  */
4090           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4091               /* If this real decl matches the implicit, don't complain.  */
4092               && ! (TREE_CODE (x) == FUNCTION_DECL
4093                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4094             cp_warning
4095               ("`%D' was previously implicitly declared to return `int'", x);
4096
4097           /* If new decl is `static' and an `extern' was seen previously,
4098              warn about it.  */
4099           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4100             warn_extern_redeclared_static (x, t);
4101         }
4102       else
4103         {
4104           /* Here to install a non-global value.  */
4105           tree oldlocal = IDENTIFIER_VALUE (name);
4106           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4107
4108           if (need_new_binding)
4109             {
4110               push_local_binding (name, x, 0);
4111               /* Because push_local_binding will hook X on to the
4112                  current_binding_level's name list, we don't want to
4113                  do that again below.  */
4114               need_new_binding = 0;
4115             }
4116
4117           /* If this is a TYPE_DECL, push it into the type value slot.  */
4118           if (TREE_CODE (x) == TYPE_DECL)
4119             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4120                                                   current_binding_level);
4121
4122           /* Clear out any TYPE_DECL shadowed by a namespace so that
4123              we won't think this is a type.  The C struct hack doesn't
4124              go through namespaces.  */
4125           if (TREE_CODE (x) == NAMESPACE_DECL)
4126             set_identifier_type_value_with_scope (name, NULL_TREE,
4127                                                   current_binding_level);
4128
4129           if (oldlocal)
4130             {
4131               tree d = oldlocal;
4132
4133               while (oldlocal
4134                      && TREE_CODE (oldlocal) == VAR_DECL
4135                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4136                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4137
4138               if (oldlocal == NULL_TREE)
4139                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4140             }
4141
4142           /* If this is an extern function declaration, see if we
4143              have a global definition or declaration for the function.  */
4144           if (oldlocal == NULL_TREE
4145               && DECL_EXTERNAL (x)
4146               && oldglobal != NULL_TREE
4147               && TREE_CODE (x) == FUNCTION_DECL
4148               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4149             {
4150               /* We have one.  Their types must agree.  */
4151               if (decls_match (x, oldglobal))
4152                 /* OK */;
4153               else
4154                 {
4155                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4156                   cp_warning_at ("global declaration `%#D'", oldglobal);
4157                 }
4158             }
4159           /* If we have a local external declaration,
4160              and no file-scope declaration has yet been seen,
4161              then if we later have a file-scope decl it must not be static.  */
4162           if (oldlocal == NULL_TREE
4163               && oldglobal == NULL_TREE
4164               && DECL_EXTERNAL (x)
4165               && TREE_PUBLIC (x))
4166             TREE_PUBLIC (name) = 1;
4167
4168           /* Warn if shadowing an argument at the top level of the body.  */
4169           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4170               /* Inline decls shadow nothing.  */
4171               && !DECL_FROM_INLINE (x)
4172               && TREE_CODE (oldlocal) == PARM_DECL
4173               /* Don't complain if it's from an enclosing function.  */
4174               && DECL_CONTEXT (oldlocal) == current_function_decl
4175               && TREE_CODE (x) != PARM_DECL)
4176             {
4177               /* Go to where the parms should be and see if we
4178                  find them there.  */
4179               struct binding_level *b = current_binding_level->level_chain;
4180
4181               if (cleanup_label)
4182                 b = b->level_chain;
4183
4184               /* ARM $8.3 */
4185               if (b->parm_flag == 1)
4186                 cp_error ("declaration of `%#D' shadows a parameter", name);
4187             }
4188
4189           /* Maybe warn if shadowing something else.  */
4190           if (warn_shadow && !DECL_EXTERNAL (x)
4191               /* Inline decls shadow nothing.  */
4192               && !DECL_FROM_INLINE (x)
4193               /* No shadow warnings for internally generated vars.  */
4194               && ! DECL_ARTIFICIAL (x)
4195               /* No shadow warnings for vars made for inlining.  */
4196               && ! DECL_FROM_INLINE (x))
4197             {
4198               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4199                 warning ("declaration of `%s' shadows a parameter",
4200                         IDENTIFIER_POINTER (name));
4201               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4202                        && current_class_ptr
4203                        && !TREE_STATIC (name))
4204                 warning ("declaration of `%s' shadows a member of `this'",
4205                         IDENTIFIER_POINTER (name));
4206               else if (oldlocal != NULL_TREE)
4207                 warning ("declaration of `%s' shadows previous local",
4208                         IDENTIFIER_POINTER (name));
4209               else if (oldglobal != NULL_TREE)
4210                 /* XXX shadow warnings in outer-more namespaces */
4211                 warning ("declaration of `%s' shadows global declaration",
4212                         IDENTIFIER_POINTER (name));
4213             }
4214         }
4215
4216       if (TREE_CODE (x) == FUNCTION_DECL)
4217         check_default_args (x);
4218
4219       /* Keep count of variables in this level with incomplete type.  */
4220       if (TREE_CODE (x) == VAR_DECL
4221           && TREE_TYPE (x) != error_mark_node
4222           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4223                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4224               /* RTTI TD entries are created while defining the type_info.  */
4225               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4226                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4227         {
4228           if (namespace_bindings_p ())
4229             namespace_scope_incomplete
4230               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4231           else
4232             current_binding_level->incomplete
4233               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4234         }
4235     }
4236
4237   if (need_new_binding)
4238     add_decl_to_level (x,
4239                        DECL_NAMESPACE_SCOPE_P (x)
4240                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4241                        : current_binding_level);
4242
4243   return x;
4244 }
4245
4246 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4247    caller to set DECL_CONTEXT properly.  */
4248
4249 static tree
4250 pushdecl_with_scope (x, level)
4251      tree x;
4252      struct binding_level *level;
4253 {
4254   register struct binding_level *b;
4255   tree function_decl = current_function_decl;
4256
4257   current_function_decl = NULL_TREE;
4258   if (level->parm_flag == 2)
4259     {
4260       b = class_binding_level;
4261       class_binding_level = level;
4262       pushdecl_class_level (x);
4263       class_binding_level = b;
4264     }
4265   else
4266     {
4267       b = current_binding_level;
4268       current_binding_level = level;
4269       x = pushdecl (x);
4270       current_binding_level = b;
4271     }
4272   current_function_decl = function_decl;
4273   return x;
4274 }
4275
4276 /* Like pushdecl, only it places X in the current namespace,
4277    if appropriate.  */
4278
4279 tree
4280 pushdecl_namespace_level (x)
4281      tree x;
4282 {
4283   register struct binding_level *b = current_binding_level;
4284   register tree t;
4285
4286   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4287
4288   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4289      what we want.  */
4290   if (TREE_CODE (x) == TYPE_DECL)
4291     {
4292       tree name = DECL_NAME (x);
4293       tree newval;
4294       tree *ptr = (tree *)0;
4295       for (; b != global_binding_level; b = b->level_chain)
4296         {
4297           tree shadowed = b->type_shadowed;
4298           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4299             if (TREE_PURPOSE (shadowed) == name)
4300               {
4301                 ptr = &TREE_VALUE (shadowed);
4302                 /* Can't break out of the loop here because sometimes
4303                    a binding level will have duplicate bindings for
4304                    PT names.  It's gross, but I haven't time to fix it.  */
4305               }
4306         }
4307       newval = TREE_TYPE (x);
4308       if (ptr == (tree *)0)
4309         {
4310           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4311              up here if this is changed to an assertion.  --KR  */
4312           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4313         }
4314       else
4315         {
4316           *ptr = newval;
4317         }
4318     }
4319   return t;
4320 }
4321
4322 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4323    if appropriate.  */
4324
4325 tree
4326 pushdecl_top_level (x)
4327      tree x;
4328 {
4329   push_to_top_level ();
4330   x = pushdecl_namespace_level (x);
4331   pop_from_top_level ();
4332   return x;
4333 }
4334
4335 /* Make the declaration of X appear in CLASS scope.  */
4336
4337 void
4338 pushdecl_class_level (x)
4339      tree x;
4340 {
4341   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4342      scope looks for the pre-mangled name.  */
4343   register tree name;
4344
4345   if (TREE_CODE (x) == OVERLOAD)
4346     x = OVL_CURRENT (x);
4347   name = DECL_NAME (x);
4348
4349   if (name)
4350     {
4351       push_class_level_binding (name, x);
4352       if (TREE_CODE (x) == TYPE_DECL)
4353         set_identifier_type_value (name, TREE_TYPE (x));
4354     }
4355   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4356     {
4357       tree f;
4358
4359       for (f = TYPE_FIELDS (TREE_TYPE (x));
4360            f;
4361            f = TREE_CHAIN (f))
4362         pushdecl_class_level (f);
4363     }
4364 }
4365
4366 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4367    DECL, or a modified version thereof.  */
4368
4369 tree
4370 maybe_push_decl (decl)
4371      tree decl;
4372 {
4373   tree type = TREE_TYPE (decl);
4374
4375   /* Add this decl to the current binding level, but not if it comes
4376      from another scope, e.g. a static member variable.  TEM may equal
4377      DECL or it may be a previous decl of the same name.  */
4378   if (decl == error_mark_node
4379       || (TREE_CODE (decl) != PARM_DECL
4380           && DECL_CONTEXT (decl) != NULL_TREE
4381           /* Definitions of namespace members outside their namespace are
4382              possible. */
4383           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4384       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4385       || TREE_CODE (type) == UNKNOWN_TYPE
4386       /* The declaration of a template specialization does not affect
4387          the functions available for overload resolution, so we do not
4388          call pushdecl.  */
4389       || (TREE_CODE (decl) == FUNCTION_DECL
4390           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4391     return decl;
4392   else
4393     return pushdecl (decl);
4394 }
4395
4396 /* Make the declaration(s) of X appear in CLASS scope
4397    under the name NAME.  */
4398
4399 void
4400 push_class_level_binding (name, x)
4401      tree name;
4402      tree x;
4403 {
4404   tree binding;
4405   /* The class_binding_level will be NULL if x is a template
4406      parameter name in a member template.  */
4407   if (!class_binding_level)
4408     return;
4409
4410   /* Make sure that this new member does not have the same name
4411      as a template parameter.  */
4412   if (TYPE_BEING_DEFINED (current_class_type))
4413     check_template_shadow (x);
4414
4415   /* If this declaration shadows a declaration from an enclosing
4416      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4417      we leave this class.  Record the shadowed declaration here.  */
4418   binding = IDENTIFIER_BINDING (name);
4419   if (binding
4420       && ((TREE_CODE (x) == OVERLOAD
4421            && BINDING_VALUE (binding)
4422            && is_overloaded_fn (BINDING_VALUE (binding)))
4423           || INHERITED_VALUE_BINDING_P (binding)))
4424     {
4425       tree shadow;
4426       tree old_decl;
4427
4428       /* If the old binding was from a base class, and was for a tag
4429          name, slide it over to make room for the new binding.  The
4430          old binding is still visible if explicitly qualified with a
4431          class-key.  */
4432       if (INHERITED_VALUE_BINDING_P (binding)
4433           && BINDING_VALUE (binding)
4434           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4435           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4436           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4437         {
4438           old_decl = BINDING_TYPE (binding);
4439           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4440           BINDING_VALUE (binding) = NULL_TREE;
4441           INHERITED_VALUE_BINDING_P (binding) = 0;
4442         }
4443       else
4444         old_decl = BINDING_VALUE (binding);
4445
4446       /* There was already a binding for X containing fewer
4447          functions than are named in X.  Find the previous
4448          declaration of X on the class-shadowed list, and update it.  */
4449       for (shadow = class_binding_level->class_shadowed;
4450            shadow;
4451            shadow = TREE_CHAIN (shadow))
4452         if (TREE_PURPOSE (shadow) == name
4453             && TREE_TYPE (shadow) == old_decl)
4454           {
4455             BINDING_VALUE (binding) = x;
4456             INHERITED_VALUE_BINDING_P (binding) = 0;
4457             TREE_TYPE (shadow) = x;
4458             return;
4459           }
4460     }
4461
4462   /* If we didn't replace an existing binding, put the binding on the
4463      stack of bindings for the identifier, and update
4464      IDENTIFIER_CLASS_VALUE.  */
4465   if (push_class_binding (name, x))
4466     {
4467       class_binding_level->class_shadowed
4468         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4469                      class_binding_level->class_shadowed);
4470       /* Record the value we are binding NAME to so that we can know
4471          what to pop later.  */
4472       TREE_TYPE (class_binding_level->class_shadowed) = x;
4473     }
4474 }
4475
4476 /* Insert another USING_DECL into the current binding level, returning
4477    this declaration. If this is a redeclaration, do nothing, and
4478    return NULL_TREE if this not in namespace scope (in namespace
4479    scope, a using decl might extend any previous bindings).  */
4480
4481 tree
4482 push_using_decl (scope, name)
4483      tree scope;
4484      tree name;
4485 {
4486   tree decl;
4487
4488   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4489   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4490   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4491     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4492       break;
4493   if (decl)
4494     return namespace_bindings_p () ? decl : NULL_TREE;
4495   decl = build_lang_decl (USING_DECL, name, void_type_node);
4496   DECL_INITIAL (decl) = scope;
4497   TREE_CHAIN (decl) = current_binding_level->usings;
4498   current_binding_level->usings = decl;
4499   return decl;
4500 }
4501
4502 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4503    changed (i.e. there was already a directive), or the fresh
4504    TREE_LIST otherwise.  */
4505
4506 tree
4507 push_using_directive (used)
4508      tree used;
4509 {
4510   tree ud = current_binding_level->using_directives;
4511   tree iter, ancestor;
4512
4513   /* Check if we already have this. */
4514   if (purpose_member (used, ud) != NULL_TREE)
4515     return NULL_TREE;
4516
4517   /* Recursively add all namespaces used. */
4518   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4519     push_using_directive (TREE_PURPOSE (iter));
4520
4521   ancestor = namespace_ancestor (current_decl_namespace (), used);
4522   ud = current_binding_level->using_directives;
4523   ud = tree_cons (used, ancestor, ud);
4524   current_binding_level->using_directives = ud;
4525   return ud;
4526 }
4527
4528 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4529    other definitions already in place.  We get around this by making
4530    the value of the identifier point to a list of all the things that
4531    want to be referenced by that name.  It is then up to the users of
4532    that name to decide what to do with that list.
4533
4534    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4535    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4536
4537    FLAGS is a bitwise-or of the following values:
4538      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4539                  namespace scope.
4540      PUSH_USING: DECL is being pushed as the result of a using
4541                  declaration.
4542
4543    The value returned may be a previous declaration if we guessed wrong
4544    about what language DECL should belong to (C or C++).  Otherwise,
4545    it's always DECL (and never something that's not a _DECL).  */
4546
4547 tree
4548 push_overloaded_decl (decl, flags)
4549      tree decl;
4550      int flags;
4551 {
4552   tree name = DECL_NAME (decl);
4553   tree old;
4554   tree new_binding;
4555   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4556
4557   if (doing_global)
4558     old = namespace_binding (name, DECL_CONTEXT (decl));
4559   else
4560     old = lookup_name_current_level (name);
4561
4562   if (old)
4563     {
4564       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4565         {
4566           tree t = TREE_TYPE (old);
4567           if (IS_AGGR_TYPE (t) && warn_shadow
4568               && (! DECL_IN_SYSTEM_HEADER (decl)
4569                   || ! DECL_IN_SYSTEM_HEADER (old)))
4570             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4571           old = NULL_TREE;
4572         }
4573       else if (is_overloaded_fn (old))
4574         {
4575           tree tmp;
4576
4577           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4578             {
4579               tree fn = OVL_CURRENT (tmp);
4580
4581               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4582                   && !(flags & PUSH_USING)
4583                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4584                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4585                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4586                           decl, fn);
4587
4588               if (duplicate_decls (decl, fn))
4589                 return fn;
4590             }
4591         }
4592       else if (old == error_mark_node)
4593         /* Ignore the undefined symbol marker.  */
4594         old = NULL_TREE;
4595       else
4596         {
4597           cp_error_at ("previous non-function declaration `%#D'", old);
4598           cp_error ("conflicts with function declaration `%#D'", decl);
4599           return decl;
4600         }
4601     }
4602
4603   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4604     {
4605       if (old && TREE_CODE (old) != OVERLOAD)
4606         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4607       else
4608         new_binding = ovl_cons (decl, old);
4609       if (flags & PUSH_USING)
4610         OVL_USED (new_binding) = 1;
4611     }
4612   else
4613     /* NAME is not ambiguous.  */
4614     new_binding = decl;
4615
4616   if (doing_global)
4617     set_namespace_binding (name, current_namespace, new_binding);
4618   else
4619     {
4620       /* We only create an OVERLOAD if there was a previous binding at
4621          this level, or if decl is a template. In the former case, we
4622          need to remove the old binding and replace it with the new
4623          binding.  We must also run through the NAMES on the binding
4624          level where the name was bound to update the chain.  */
4625
4626       if (TREE_CODE (new_binding) == OVERLOAD && old)
4627         {
4628           tree *d;
4629
4630           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4631                *d;
4632                d = &TREE_CHAIN (*d))
4633             if (*d == old
4634                 || (TREE_CODE (*d) == TREE_LIST
4635                     && TREE_VALUE (*d) == old))
4636               {
4637                 if (TREE_CODE (*d) == TREE_LIST)
4638                   /* Just replace the old binding with the new.  */
4639                   TREE_VALUE (*d) = new_binding;
4640                 else
4641                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4642                   *d = tree_cons (NULL_TREE, new_binding,
4643                                   TREE_CHAIN (*d));
4644
4645                 /* And update the CPLUS_BINDING node.  */
4646                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4647                   = new_binding;
4648                 return decl;
4649               }
4650
4651           /* We should always find a previous binding in this case.  */
4652           my_friendly_abort (0);
4653         }
4654
4655       /* Install the new binding.  */
4656       push_local_binding (name, new_binding, flags);
4657     }
4658
4659   return decl;
4660 }
4661 \f
4662 /* Generate an implicit declaration for identifier FUNCTIONID
4663    as a function of type int ().  Print a warning if appropriate.  */
4664
4665 tree
4666 implicitly_declare (functionid)
4667      tree functionid;
4668 {
4669   register tree decl;
4670
4671   /* We used to reuse an old implicit decl here,
4672      but this loses with inline functions because it can clobber
4673      the saved decl chains.  */
4674   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4675
4676   DECL_EXTERNAL (decl) = 1;
4677   TREE_PUBLIC (decl) = 1;
4678
4679   /* ISO standard says implicit declarations are in the innermost block.
4680      So we record the decl in the standard fashion.  */
4681   pushdecl (decl);
4682   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4683
4684   if (warn_implicit
4685       /* Only one warning per identifier.  */
4686       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4687     {
4688       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4689     }
4690
4691   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4692
4693   return decl;
4694 }
4695
4696 /* Return zero if the declaration NEWDECL is valid
4697    when the declaration OLDDECL (assumed to be for the same name)
4698    has already been seen.
4699    Otherwise return an error message format string with a %s
4700    where the identifier should go.  */
4701
4702 static const char *
4703 redeclaration_error_message (newdecl, olddecl)
4704      tree newdecl, olddecl;
4705 {
4706   if (TREE_CODE (newdecl) == TYPE_DECL)
4707     {
4708       /* Because C++ can put things into name space for free,
4709          constructs like "typedef struct foo { ... } foo"
4710          would look like an erroneous redeclaration.  */
4711       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4712         return 0;
4713       else
4714         return "redefinition of `%#D'";
4715     }
4716   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4717     {
4718       /* If this is a pure function, its olddecl will actually be
4719          the original initialization to `0' (which we force to call
4720          abort()).  Don't complain about redefinition in this case.  */
4721       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4722         return 0;
4723
4724       /* If both functions come from different namespaces, this is not
4725          a redeclaration - this is a conflict with a used function. */
4726       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4727           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4728         return "`%D' conflicts with used function";
4729
4730       /* We'll complain about linkage mismatches in
4731          warn_extern_redeclared_static.  */
4732
4733       /* Defining the same name twice is no good.  */
4734       if (DECL_INITIAL (olddecl) != NULL_TREE
4735           && DECL_INITIAL (newdecl) != NULL_TREE)
4736         {
4737           if (DECL_NAME (olddecl) == NULL_TREE)
4738             return "`%#D' not declared in class";
4739           else
4740             return "redefinition of `%#D'";
4741         }
4742       return 0;
4743     }
4744   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4745     {
4746       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4747            && (DECL_TEMPLATE_RESULT (newdecl)
4748                != DECL_TEMPLATE_RESULT (olddecl))
4749            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4750            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4751           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4752               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4753               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4754         return "redefinition of `%#D'";
4755       return 0;
4756     }
4757   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4758     {
4759       /* Objects declared at top level:  */
4760       /* If at least one is a reference, it's ok.  */
4761       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4762         return 0;
4763       /* Reject two definitions.  */
4764       return "redefinition of `%#D'";
4765     }
4766   else
4767     {
4768       /* Objects declared with block scope:  */
4769       /* Reject two definitions, and reject a definition
4770          together with an external reference.  */
4771       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4772         return "redeclaration of `%#D'";
4773       return 0;
4774     }
4775 }
4776 \f
4777 /* Create a new label, named ID.  */
4778
4779 static tree
4780 make_label_decl (id, local_p)
4781      tree id;
4782      int local_p;
4783 {
4784   tree decl;
4785
4786   decl = build_decl (LABEL_DECL, id, void_type_node);
4787   if (expanding_p)
4788     /* Make sure every label has an rtx.  */
4789     label_rtx (decl);
4790
4791   DECL_CONTEXT (decl) = current_function_decl;
4792   DECL_MODE (decl) = VOIDmode;
4793   C_DECLARED_LABEL_FLAG (decl) = local_p;
4794
4795   /* Say where one reference is to the label, for the sake of the
4796      error if it is not defined.  */
4797   DECL_SOURCE_LINE (decl) = lineno;
4798   DECL_SOURCE_FILE (decl) = input_filename;
4799
4800   /* Record the fact that this identifier is bound to this label.  */
4801   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4802
4803   return decl;
4804 }
4805
4806 /* Record this label on the list of used labels so that we can check
4807    at the end of the function to see whether or not the label was
4808    actually defined, and so we can check when the label is defined whether
4809    this use is valid.  */
4810
4811 static void
4812 use_label (decl)
4813      tree decl;
4814 {
4815   if (named_label_uses == NULL
4816       || named_label_uses->names_in_scope != current_binding_level->names
4817       || named_label_uses->label_decl != decl)
4818     {
4819       struct named_label_use_list *new_ent;
4820       new_ent = ((struct named_label_use_list *)
4821                  ggc_alloc (sizeof (struct named_label_use_list)));
4822       new_ent->label_decl = decl;
4823       new_ent->names_in_scope = current_binding_level->names;
4824       new_ent->binding_level = current_binding_level;
4825       new_ent->lineno_o_goto = lineno;
4826       new_ent->filename_o_goto = input_filename;
4827       new_ent->next = named_label_uses;
4828       named_label_uses = new_ent;
4829     }
4830 }
4831
4832 /* Look for a label named ID in the current function.  If one cannot
4833    be found, create one.  (We keep track of used, but undefined,
4834    labels, and complain about them at the end of a function.)  */
4835
4836 tree
4837 lookup_label (id)
4838      tree id;
4839 {
4840   tree decl;
4841   struct named_label_list *ent;
4842
4843   /* You can't use labels at global scope.  */
4844   if (current_function_decl == NULL_TREE)
4845     {
4846       error ("label `%s' referenced outside of any function",
4847              IDENTIFIER_POINTER (id));
4848       return NULL_TREE;
4849     }
4850
4851   /* See if we've already got this label.  */
4852   decl = IDENTIFIER_LABEL_VALUE (id);
4853   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4854     return decl;
4855
4856   /* Record this label on the list of labels used in this function.
4857      We do this before calling make_label_decl so that we get the
4858      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4859   ent = ((struct named_label_list *)
4860          ggc_alloc_cleared (sizeof (struct named_label_list)));
4861   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4862   ent->next = named_labels;
4863   named_labels = ent;
4864
4865   /* We need a new label.  */
4866   decl = make_label_decl (id, /*local_p=*/0);
4867
4868   /* Now fill in the information we didn't have before.  */
4869   ent->label_decl = decl;
4870
4871   return decl;
4872 }
4873
4874 /* Declare a local label named ID.  */
4875
4876 tree
4877 declare_local_label (id)
4878      tree id;
4879 {
4880   tree decl;
4881
4882   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4883      this scope we can restore the old value of
4884      IDENTIFIER_TYPE_VALUE.  */
4885   current_binding_level->shadowed_labels
4886     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4887                  current_binding_level->shadowed_labels);
4888   /* Look for the label.  */
4889   decl = make_label_decl (id, /*local_p=*/1);
4890   /* Now fill in the information we didn't have before.  */
4891   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4892
4893   return decl;
4894 }
4895
4896 /* Returns nonzero if it is ill-formed to jump past the declaration of
4897    DECL.  Returns 2 if it's also a real problem.  */
4898
4899 static int
4900 decl_jump_unsafe (decl)
4901      tree decl;
4902 {
4903   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4904     return 0;
4905
4906   if (DECL_INITIAL (decl) == NULL_TREE
4907       && pod_type_p (TREE_TYPE (decl)))
4908     return 0;
4909
4910   /* This is really only important if we're crossing an initialization.
4911      The POD stuff is just pedantry; why should it matter if the class
4912      contains a field of pointer to member type?  */
4913   if (DECL_INITIAL (decl)
4914       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4915     return 2;
4916   return 1;
4917 }
4918
4919 /* Check that a single previously seen jump to a newly defined label
4920    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4921    the jump context; NAMES are the names in scope in LEVEL at the jump
4922    context; FILE and LINE are the source position of the jump or 0.  */
4923
4924 static void
4925 check_previous_goto_1 (decl, level, names, file, line)
4926      tree decl;
4927      struct binding_level *level;
4928      tree names;
4929      const char *file;
4930      int line;
4931 {
4932   int identified = 0;
4933   int saw_eh = 0;
4934   struct binding_level *b = current_binding_level;
4935   for (; b; b = b->level_chain)
4936     {
4937       tree new_decls = b->names;
4938       tree old_decls = (b == level ? names : NULL_TREE);
4939       for (; new_decls != old_decls;
4940            new_decls = TREE_CHAIN (new_decls))
4941         {
4942           int problem = decl_jump_unsafe (new_decls);
4943           if (! problem)
4944             continue;
4945
4946           if (! identified)
4947             {
4948               if (decl)
4949                 cp_pedwarn ("jump to label `%D'", decl);
4950               else
4951                 pedwarn ("jump to case label");
4952
4953               if (file)
4954                 pedwarn_with_file_and_line (file, line, "  from here");
4955               identified = 1;
4956             }
4957
4958           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4959             /* Can't skip init of __exception_info.  */
4960             cp_error_at ("  enters catch block", new_decls);
4961           else if (problem > 1)
4962             cp_error_at ("  crosses initialization of `%#D'",
4963                          new_decls);
4964           else
4965             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4966                            new_decls);
4967         }
4968
4969       if (b == level)
4970         break;
4971       if (b->eh_region && ! saw_eh)
4972         {
4973           if (! identified)
4974             {
4975               if (decl)
4976                 cp_pedwarn ("jump to label `%D'", decl);
4977               else
4978                 pedwarn ("jump to case label");
4979
4980               if (file)
4981                 pedwarn_with_file_and_line (file, line, "  from here");
4982               identified = 1;
4983             }
4984           error ("  enters try block");
4985           saw_eh = 1;
4986         }
4987     }
4988 }
4989
4990 static void
4991 check_previous_goto (use)
4992      struct named_label_use_list *use;
4993 {
4994   check_previous_goto_1 (use->label_decl, use->binding_level,
4995                          use->names_in_scope, use->filename_o_goto,
4996                          use->lineno_o_goto);
4997 }
4998
4999 static void
5000 check_switch_goto (level)
5001      struct binding_level *level;
5002 {
5003   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5004 }
5005
5006 /* Check that any previously seen jumps to a newly defined label DECL
5007    are OK.  Called by define_label.  */
5008
5009 static void
5010 check_previous_gotos (decl)
5011      tree decl;
5012 {
5013   struct named_label_use_list **usep;
5014
5015   if (! TREE_USED (decl))
5016     return;
5017
5018   for (usep = &named_label_uses; *usep; )
5019     {
5020       struct named_label_use_list *use = *usep;
5021       if (use->label_decl == decl)
5022         {
5023           check_previous_goto (use);
5024           *usep = use->next;
5025         }
5026       else
5027         usep = &(use->next);
5028     }
5029 }
5030
5031 /* Check that a new jump to a label DECL is OK.  Called by
5032    finish_goto_stmt.  */
5033
5034 void
5035 check_goto (decl)
5036      tree decl;
5037 {
5038   int identified = 0;
5039   tree bad;
5040   struct named_label_list *lab;
5041
5042   /* We can't know where a computed goto is jumping.  So we assume
5043      that it's OK.  */
5044   if (! DECL_P (decl))
5045     return;
5046
5047   /* If the label hasn't been defined yet, defer checking.  */
5048   if (! DECL_INITIAL (decl))
5049     {
5050       use_label (decl);
5051       return;
5052     }
5053
5054   for (lab = named_labels; lab; lab = lab->next)
5055     if (decl == lab->label_decl)
5056       break;
5057
5058   /* If the label is not on named_labels it's a gcc local label, so
5059      it must be in an outer scope, so jumping to it is always OK.  */
5060   if (lab == 0)
5061     return;
5062
5063   if ((lab->eh_region || lab->bad_decls) && !identified)
5064     {
5065       cp_pedwarn_at ("jump to label `%D'", decl);
5066       pedwarn ("  from here");
5067       identified = 1;
5068     }
5069
5070   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5071     {
5072       tree b = TREE_VALUE (bad);
5073       int u = decl_jump_unsafe (b);
5074
5075       if (u > 1 && DECL_ARTIFICIAL (b))
5076         /* Can't skip init of __exception_info.  */
5077         cp_error_at ("  enters catch block", b);
5078       else if (u > 1)
5079         cp_error_at ("  skips initialization of `%#D'", b);
5080       else
5081         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5082     }
5083
5084   if (lab->eh_region)
5085     error ("  enters try block");
5086 }
5087
5088 /* Define a label, specifying the location in the source file.
5089    Return the LABEL_DECL node for the label, if the definition is valid.
5090    Otherwise return 0.  */
5091
5092 tree
5093 define_label (filename, line, name)
5094      const char *filename;
5095      int line;
5096      tree name;
5097 {
5098   tree decl = lookup_label (name);
5099   struct named_label_list *ent;
5100
5101   for (ent = named_labels; ent; ent = ent->next)
5102     if (ent->label_decl == decl)
5103       break;
5104
5105   /* After labels, make any new cleanups go into their
5106      own new (temporary) binding contour.  */
5107   current_binding_level->more_cleanups_ok = 0;
5108
5109   if (name == get_identifier ("wchar_t"))
5110     cp_pedwarn ("label named wchar_t");
5111
5112   if (DECL_INITIAL (decl) != NULL_TREE)
5113     {
5114       cp_error ("duplicate label `%D'", decl);
5115       return 0;
5116     }
5117   else
5118     {
5119       /* Mark label as having been defined.  */
5120       DECL_INITIAL (decl) = error_mark_node;
5121       /* Say where in the source.  */
5122       DECL_SOURCE_FILE (decl) = filename;
5123       DECL_SOURCE_LINE (decl) = line;
5124       if (ent)
5125         {
5126           ent->names_in_scope = current_binding_level->names;
5127           ent->binding_level = current_binding_level;
5128         }
5129       check_previous_gotos (decl);
5130       current_function_return_value = NULL_TREE;
5131       return decl;
5132     }
5133 }
5134
5135 struct cp_switch
5136 {
5137   struct binding_level *level;
5138   struct cp_switch *next;
5139   /* The SWITCH_STMT being built.  */
5140   tree switch_stmt;
5141   /* A splay-tree mapping the low element of a case range to the high
5142      element, or NULL_TREE if there is no high element.  Used to
5143      determine whether or not a new case label duplicates an old case
5144      label.  We need a tree, rather than simply a hash table, because
5145      of the GNU case range extension.  */
5146   splay_tree cases;
5147 };
5148
5149 /* A stack of the currently active switch statements.  The innermost
5150    switch statement is on the top of the stack.  There is no need to
5151    mark the stack for garbage collection because it is only active
5152    during the processing of the body of a function, and we never
5153    collect at that point.  */
5154
5155 static struct cp_switch *switch_stack;
5156
5157 /* Called right after a switch-statement condition is parsed.
5158    SWITCH_STMT is the switch statement being parsed.  */
5159
5160 void
5161 push_switch (switch_stmt)
5162      tree switch_stmt;
5163 {
5164   struct cp_switch *p
5165     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5166   p->level = current_binding_level;
5167   p->next = switch_stack;
5168   p->switch_stmt = switch_stmt;
5169   p->cases = splay_tree_new (case_compare, NULL, NULL);
5170   switch_stack = p;
5171 }
5172
5173 void
5174 pop_switch ()
5175 {
5176   struct cp_switch *cs;
5177
5178   cs = switch_stack;
5179   splay_tree_delete (cs->cases);
5180   switch_stack = switch_stack->next;
5181   free (cs);
5182 }
5183
5184 /* Note that we've seen a definition of a case label, and complain if this
5185    is a bad place for one.  */
5186
5187 void
5188 finish_case_label (low_value, high_value)
5189      tree low_value;
5190      tree high_value;
5191 {
5192   tree cond;
5193
5194   if (! switch_stack)
5195     {
5196       if (high_value)
5197         error ("case label not within a switch statement");
5198       else if (low_value)
5199         cp_error ("case label `%E' not within a switch statement",
5200                   low_value);
5201       else
5202         error ("`default' label not within a switch statement");
5203       return;
5204     }
5205
5206   if (processing_template_decl)
5207     {
5208       tree label;
5209
5210       /* For templates, just add the case label; we'll do semantic
5211          analysis at instantiation-time.  */
5212       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5213       add_stmt (build_case_label (low_value, high_value, label));
5214       return;
5215     }
5216
5217   /* Find the condition on which this switch statement depends.  */
5218   cond = SWITCH_COND (switch_stack->switch_stmt);
5219   if (cond && TREE_CODE (cond) == TREE_LIST)
5220     cond = TREE_VALUE (cond);
5221
5222   c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5223
5224   check_switch_goto (switch_stack->level);
5225
5226   /* After labels, make any new cleanups go into their
5227      own new (temporary) binding contour.  */
5228   current_binding_level->more_cleanups_ok = 0;
5229   current_function_return_value = NULL_TREE;
5230 }
5231 \f
5232 /* Return the list of declarations of the current level.
5233    Note that this list is in reverse order unless/until
5234    you nreverse it; and when you do nreverse it, you must
5235    store the result back using `storedecls' or you will lose.  */
5236
5237 tree
5238 getdecls ()
5239 {
5240   return current_binding_level->names;
5241 }
5242
5243 /* Return the list of type-tags (for structs, etc) of the current level.  */
5244
5245 tree
5246 gettags ()
5247 {
5248   return current_binding_level->tags;
5249 }
5250
5251 /* Store the list of declarations of the current level.
5252    This is done for the parameter declarations of a function being defined,
5253    after they are modified in the light of any missing parameters.  */
5254
5255 static void
5256 storedecls (decls)
5257      tree decls;
5258 {
5259   current_binding_level->names = decls;
5260 }
5261
5262 /* Similarly, store the list of tags of the current level.  */
5263
5264 void
5265 storetags (tags)
5266      tree tags;
5267 {
5268   current_binding_level->tags = tags;
5269 }
5270 \f
5271 /* Given NAME, an IDENTIFIER_NODE,
5272    return the structure (or union or enum) definition for that name.
5273    Searches binding levels from BINDING_LEVEL up to the global level.
5274    If THISLEVEL_ONLY is nonzero, searches only the specified context
5275    (but skips any tag-transparent contexts to find one that is
5276    meaningful for tags).
5277    FORM says which kind of type the caller wants;
5278    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5279    If the wrong kind of type is found, and it's not a template, an error is
5280    reported.  */
5281
5282 static tree
5283 lookup_tag (form, name, binding_level, thislevel_only)
5284      enum tree_code form;
5285      tree name;
5286      struct binding_level *binding_level;
5287      int thislevel_only;
5288 {
5289   register struct binding_level *level;
5290   /* Non-zero if, we should look past a template parameter level, even
5291      if THISLEVEL_ONLY.  */
5292   int allow_template_parms_p = 1;
5293
5294   for (level = binding_level; level; level = level->level_chain)
5295     {
5296       register tree tail;
5297       if (ANON_AGGRNAME_P (name))
5298         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5299           {
5300             /* There's no need for error checking here, because
5301                anon names are unique throughout the compilation.  */
5302             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5303               return TREE_VALUE (tail);
5304           }
5305       else if (level->namespace_p)
5306         /* Do namespace lookup. */
5307         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5308           {
5309             tree old = binding_for_name (name, tail);
5310
5311             /* If we just skipped past a template parameter level,
5312                even though THISLEVEL_ONLY, and we find a template
5313                class declaration, then we use the _TYPE node for the
5314                template.  See the example below.  */
5315             if (thislevel_only && !allow_template_parms_p
5316                 && old && BINDING_VALUE (old)
5317                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5318               old = TREE_TYPE (BINDING_VALUE (old));
5319             else
5320               old = BINDING_TYPE (old);
5321
5322             /* If it has an original type, it is a typedef, and we
5323                should not return it.  */
5324             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5325               old = NULL_TREE;
5326             if (old && TREE_CODE (old) != form
5327                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5328               {
5329                 cp_error ("`%#D' redeclared as %C", old, form);
5330                 return NULL_TREE;
5331               }
5332             if (old)
5333               return old;
5334             if (thislevel_only || tail == global_namespace)
5335               return NULL_TREE;
5336           }
5337       else
5338         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5339           {
5340             if (TREE_PURPOSE (tail) == name)
5341               {
5342                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5343                 /* Should tighten this up; it'll probably permit
5344                    UNION_TYPE and a struct template, for example.  */
5345                 if (code != form
5346                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5347                   {
5348                     /* Definition isn't the kind we were looking for.  */
5349                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5350                               form);
5351                     return NULL_TREE;
5352                   }
5353                 return TREE_VALUE (tail);
5354               }
5355           }
5356       if (thislevel_only && ! level->tag_transparent)
5357         {
5358           if (level->template_parms_p && allow_template_parms_p)
5359             {
5360               /* We must deal with cases like this:
5361
5362                    template <class T> struct S;
5363                    template <class T> struct S {};
5364
5365                  When looking up `S', for the second declaration, we
5366                  would like to find the first declaration.  But, we
5367                  are in the pseudo-global level created for the
5368                  template parameters, rather than the (surrounding)
5369                  namespace level.  Thus, we keep going one more level,
5370                  even though THISLEVEL_ONLY is non-zero.  */
5371               allow_template_parms_p = 0;
5372               continue;
5373             }
5374           else
5375             return NULL_TREE;
5376         }
5377     }
5378   return NULL_TREE;
5379 }
5380
5381 #if 0
5382 void
5383 set_current_level_tags_transparency (tags_transparent)
5384      int tags_transparent;
5385 {
5386   current_binding_level->tag_transparent = tags_transparent;
5387 }
5388 #endif
5389
5390 /* Given a type, find the tag that was defined for it and return the tag name.
5391    Otherwise return 0.  However, the value can never be 0
5392    in the cases in which this is used.
5393
5394    C++: If NAME is non-zero, this is the new name to install.  This is
5395    done when replacing anonymous tags with real tag names.  */
5396
5397 static tree
5398 lookup_tag_reverse (type, name)
5399      tree type;
5400      tree name;
5401 {
5402   register struct binding_level *level;
5403
5404   for (level = current_binding_level; level; level = level->level_chain)
5405     {
5406       register tree tail;
5407       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5408         {
5409           if (TREE_VALUE (tail) == type)
5410             {
5411               if (name)
5412                 TREE_PURPOSE (tail) = name;
5413               return TREE_PURPOSE (tail);
5414             }
5415         }
5416     }
5417   return NULL_TREE;
5418 }
5419 \f
5420 /* Look up NAME in the NAMESPACE.  */
5421
5422 tree
5423 lookup_namespace_name (namespace, name)
5424      tree namespace, name;
5425 {
5426   tree val;
5427   tree template_id = NULL_TREE;
5428
5429   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5430
5431   if (TREE_CODE (name) == NAMESPACE_DECL)
5432     /* This happens for A::B<int> when B is a namespace. */
5433     return name;
5434   else if (TREE_CODE (name) == TEMPLATE_DECL)
5435     {
5436       /* This happens for A::B where B is a template, and there are no
5437          template arguments.  */
5438       cp_error ("invalid use of `%D'", name);
5439       return error_mark_node;
5440     }
5441
5442   namespace = ORIGINAL_NAMESPACE (namespace);
5443
5444   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5445     {
5446       template_id = name;
5447       name = TREE_OPERAND (name, 0);
5448       if (TREE_CODE (name) == OVERLOAD)
5449         name = DECL_NAME (OVL_CURRENT (name));
5450       else if (DECL_P (name))
5451         name = DECL_NAME (name);
5452     }
5453
5454   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5455
5456   val = make_node (CPLUS_BINDING);
5457   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5458     return error_mark_node;
5459
5460   if (BINDING_VALUE (val))
5461     {
5462       val = BINDING_VALUE (val);
5463
5464       if (template_id)
5465         {
5466           if (DECL_CLASS_TEMPLATE_P (val))
5467             val = lookup_template_class (val,
5468                                          TREE_OPERAND (template_id, 1),
5469                                          /*in_decl=*/NULL_TREE,
5470                                          /*context=*/NULL_TREE,
5471                                          /*entering_scope=*/0);
5472           else if (DECL_FUNCTION_TEMPLATE_P (val)
5473                    || TREE_CODE (val) == OVERLOAD)
5474             val = lookup_template_function (val,
5475                                             TREE_OPERAND (template_id, 1));
5476           else
5477             {
5478               cp_error ("`%D::%D' is not a template",
5479                         namespace, name);
5480               return error_mark_node;
5481             }
5482         }
5483
5484       /* If we have a single function from a using decl, pull it out.  */
5485       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5486         val = OVL_FUNCTION (val);
5487       return val;
5488     }
5489
5490   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5491   return error_mark_node;
5492 }
5493
5494 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5495
5496 static unsigned long
5497 typename_hash (k)
5498      hash_table_key k;
5499 {
5500   unsigned long hash;
5501   tree t;
5502
5503   t = (tree) k;
5504   hash = (((unsigned long) TYPE_CONTEXT (t))
5505           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5506
5507   return hash;
5508 }
5509
5510 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5511
5512 static boolean
5513 typename_compare (k1, k2)
5514      hash_table_key k1;
5515      hash_table_key k2;
5516 {
5517   tree t1;
5518   tree t2;
5519   tree d1;
5520   tree d2;
5521
5522   t1 = (tree) k1;
5523   t2 = (tree) k2;
5524   d1 = TYPE_NAME (t1);
5525   d2 = TYPE_NAME (t2);
5526
5527   return (DECL_NAME (d1) == DECL_NAME (d2)
5528           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5529           && ((TREE_TYPE (t1) != NULL_TREE)
5530               == (TREE_TYPE (t2) != NULL_TREE))
5531           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5532           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5533 }
5534
5535 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5536    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5537    is non-NULL, this type is being created by the implicit typename
5538    extension, and BASE_TYPE is a type named `t' in some base class of
5539    `T' which depends on template parameters.
5540
5541    Returns the new TYPENAME_TYPE.  */
5542
5543 tree
5544 build_typename_type (context, name, fullname, base_type)
5545      tree context;
5546      tree name;
5547      tree fullname;
5548      tree base_type;
5549 {
5550   tree t;
5551   tree d;
5552   struct hash_entry* e;
5553
5554   static struct hash_table ht;
5555
5556   if (!ht.table)
5557     {
5558       static struct hash_table *h = &ht;
5559       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5560                             &typename_compare))
5561         fatal ("virtual memory exhausted");
5562       ggc_add_tree_hash_table_root (&h, 1);
5563     }
5564
5565   /* Build the TYPENAME_TYPE.  */
5566   t = make_aggr_type (TYPENAME_TYPE);
5567   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5568   TYPENAME_TYPE_FULLNAME (t) = fullname;
5569   TREE_TYPE (t) = base_type;
5570
5571   /* Build the corresponding TYPE_DECL.  */
5572   d = build_decl (TYPE_DECL, name, t);
5573   TYPE_NAME (TREE_TYPE (d)) = d;
5574   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5575   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5576   DECL_ARTIFICIAL (d) = 1;
5577
5578   /* See if we already have this type.  */
5579   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5580   if (e)
5581     t = (tree) e->key;
5582   else
5583     /* Insert the type into the table.  */
5584     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5585
5586   return t;
5587 }
5588
5589 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5590    unless an error occurs, in which case error_mark_node is returned.
5591    If COMPLAIN zero, don't complain about any errors that occur.  */
5592
5593 tree
5594 make_typename_type (context, name, complain)
5595      tree context, name;
5596      int complain;
5597 {
5598   tree fullname;
5599
5600   if (TYPE_P (name))
5601     {
5602       if (!(TYPE_LANG_SPECIFIC (name)
5603             && (CLASSTYPE_IS_TEMPLATE (name)
5604                 || CLASSTYPE_USE_TEMPLATE (name))))
5605         name = TYPE_IDENTIFIER (name);
5606       else
5607         /* Create a TEMPLATE_ID_EXPR for the type.  */
5608         name = build_nt (TEMPLATE_ID_EXPR,
5609                          CLASSTYPE_TI_TEMPLATE (name),
5610                          CLASSTYPE_TI_ARGS (name));
5611     }
5612   else if (TREE_CODE (name) == TYPE_DECL)
5613     name = DECL_NAME (name);
5614
5615   fullname = name;
5616
5617   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5618     {
5619       name = TREE_OPERAND (name, 0);
5620       if (TREE_CODE (name) == TEMPLATE_DECL)
5621         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5622     }
5623   if (TREE_CODE (name) != IDENTIFIER_NODE)
5624     my_friendly_abort (2000);
5625
5626   if (TREE_CODE (context) == NAMESPACE_DECL)
5627     {
5628       /* We can get here from typename_sub0 in the explicit_template_type
5629          expansion.  Just fail.  */
5630       if (complain)
5631         cp_error ("no class template named `%#T' in `%#T'",
5632                   name, context);
5633       return error_mark_node;
5634     }
5635
5636   if (! uses_template_parms (context)
5637       || currently_open_class (context))
5638     {
5639       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5640         {
5641           tree tmpl = NULL_TREE;
5642           if (IS_AGGR_TYPE (context))
5643             tmpl = lookup_field (context, name, 0, 0);
5644           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5645             {
5646               if (complain)
5647                 cp_error ("no class template named `%#T' in `%#T'",
5648                           name, context);
5649               return error_mark_node;
5650             }
5651
5652           return lookup_template_class (tmpl,
5653                                         TREE_OPERAND (fullname, 1),
5654                                         NULL_TREE, context,
5655                                         /*entering_scope=*/0);
5656         }
5657       else
5658         {
5659           tree t;
5660
5661           if (!IS_AGGR_TYPE (context))
5662             {
5663               if (complain)
5664                 cp_error ("no type named `%#T' in `%#T'", name, context);
5665               return error_mark_node;
5666             }
5667
5668           t = lookup_field (context, name, 0, 1);
5669           if (t)
5670             return TREE_TYPE (t);
5671         }
5672     }
5673
5674   /* If the CONTEXT is not a template type, then either the field is
5675      there now or its never going to be.  */
5676   if (!uses_template_parms (context))
5677     {
5678       if (complain)
5679         cp_error ("no type named `%#T' in `%#T'", name, context);
5680       return error_mark_node;
5681     }
5682
5683
5684   return build_typename_type (context, name, fullname,  NULL_TREE);
5685 }
5686
5687 /* Select the right _DECL from multiple choices. */
5688
5689 static tree
5690 select_decl (binding, flags)
5691      tree binding;
5692      int flags;
5693 {
5694   tree val;
5695   val = BINDING_VALUE (binding);
5696
5697   /* When we implicitly declare some builtin entity, we mark it
5698      DECL_ANTICIPATED, so that we know to ignore it until it is
5699      really declared.  */
5700   if (val && DECL_P (val)
5701       && DECL_LANG_SPECIFIC (val)
5702       && DECL_ANTICIPATED (val))
5703     return NULL_TREE;
5704
5705   if (LOOKUP_NAMESPACES_ONLY (flags))
5706     {
5707       /* We are not interested in types. */
5708       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5709         return val;
5710       return NULL_TREE;
5711     }
5712
5713   /* If we could have a type and
5714      we have nothing or we need a type and have none.  */
5715   if (BINDING_TYPE (binding)
5716       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5717                    && TREE_CODE (val) != TYPE_DECL)))
5718     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5719   /* Don't return non-types if we really prefer types. */
5720   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5721            && (TREE_CODE (val) != TEMPLATE_DECL
5722                || !DECL_CLASS_TEMPLATE_P (val)))
5723     val = NULL_TREE;
5724
5725   return val;
5726 }
5727
5728 /* Unscoped lookup of a global: iterate over current namespaces,
5729    considering using-directives.  If SPACESP is non-NULL, store a list
5730    of the namespaces we've considered in it.  */
5731
5732 tree
5733 unqualified_namespace_lookup (name, flags, spacesp)
5734      tree name;
5735      int flags;
5736      tree *spacesp;
5737 {
5738   tree b = make_node (CPLUS_BINDING);
5739   tree initial = current_decl_namespace();
5740   tree scope = initial;
5741   tree siter;
5742   struct binding_level *level;
5743   tree val = NULL_TREE;
5744
5745   if (spacesp)
5746     *spacesp = NULL_TREE;
5747
5748   for (; !val; scope = CP_DECL_CONTEXT (scope))
5749     {
5750       if (spacesp)
5751         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5752       val = binding_for_name (name, scope);
5753
5754       /* Initialize binding for this context. */
5755       BINDING_VALUE (b) = BINDING_VALUE (val);
5756       BINDING_TYPE (b) = BINDING_TYPE (val);
5757
5758       /* Add all _DECLs seen through local using-directives. */
5759       for (level = current_binding_level;
5760            !level->namespace_p;
5761            level = level->level_chain)
5762         if (!lookup_using_namespace (name, b, level->using_directives,
5763                                      scope, flags, spacesp))
5764           /* Give up because of error. */
5765           return error_mark_node;
5766
5767       /* Add all _DECLs seen through global using-directives. */
5768       /* XXX local and global using lists should work equally. */
5769       siter = initial;
5770       while (1)
5771         {
5772           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5773                                        scope, flags, spacesp))
5774             /* Give up because of error. */
5775             return error_mark_node;
5776           if (siter == scope) break;
5777           siter = CP_DECL_CONTEXT (siter);
5778         }
5779
5780       val = select_decl (b, flags);
5781       if (scope == global_namespace)
5782         break;
5783     }
5784   return val;
5785 }
5786
5787 /* Combine prefer_type and namespaces_only into flags.  */
5788
5789 static int
5790 lookup_flags (prefer_type, namespaces_only)
5791   int prefer_type, namespaces_only;
5792 {
5793   if (namespaces_only)
5794     return LOOKUP_PREFER_NAMESPACES;
5795   if (prefer_type > 1)
5796     return LOOKUP_PREFER_TYPES;
5797   if (prefer_type > 0)
5798     return LOOKUP_PREFER_BOTH;
5799   return 0;
5800 }
5801
5802 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5803    ignore it or not.  Subroutine of lookup_name_real.  */
5804
5805 static tree
5806 qualify_lookup (val, flags)
5807      tree val;
5808      int flags;
5809 {
5810   if (val == NULL_TREE)
5811     return val;
5812   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5813     return val;
5814   if ((flags & LOOKUP_PREFER_TYPES)
5815       && (TREE_CODE (val) == TYPE_DECL
5816           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5817               && DECL_CLASS_TEMPLATE_P (val))))
5818     return val;
5819   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5820     return NULL_TREE;
5821   return val;
5822 }
5823
5824 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5825    that.  */
5826
5827 static void
5828 warn_about_implicit_typename_lookup (typename, binding)
5829      tree typename;
5830      tree binding;
5831 {
5832   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5833   tree name = DECL_NAME (typename);
5834
5835   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5836          && CLASSTYPE_TEMPLATE_INFO (subtype)
5837          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5838       && ! (TREE_CODE (binding) == TYPE_DECL
5839             && same_type_p (TREE_TYPE (binding), subtype)))
5840     {
5841       cp_warning ("lookup of `%D' finds `%#D'",
5842                   name, binding);
5843       cp_warning ("  instead of `%D' from dependent base class",
5844                   typename);
5845       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5846                   constructor_name (current_class_type), name);
5847     }
5848 }
5849
5850 /* Look up NAME in the current binding level and its superiors in the
5851    namespace of variables, functions and typedefs.  Return a ..._DECL
5852    node of some kind representing its definition if there is only one
5853    such declaration, or return a TREE_LIST with all the overloaded
5854    definitions if there are many, or return 0 if it is undefined.
5855
5856    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5857    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5858    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5859    Otherwise we prefer non-TYPE_DECLs.
5860
5861    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5862    using IDENTIFIER_CLASS_VALUE.  */
5863
5864 static tree
5865 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5866      tree name;
5867      int prefer_type, nonclass, namespaces_only;
5868 {
5869   tree t;
5870   tree val = NULL_TREE;
5871   int yylex = 0;
5872   tree from_obj = NULL_TREE;
5873   int flags;
5874   int val_is_implicit_typename = 0;
5875
5876   /* Hack: copy flag set by parser, if set. */
5877   if (only_namespace_names)
5878     namespaces_only = 1;
5879
5880   if (prefer_type == -2)
5881     {
5882       extern int looking_for_typename;
5883       tree type = NULL_TREE;
5884
5885       yylex = 1;
5886       prefer_type = looking_for_typename;
5887
5888       flags = lookup_flags (prefer_type, namespaces_only);
5889       /* If the next thing is '<', class templates are types. */
5890       if (looking_for_template)
5891         flags |= LOOKUP_TEMPLATES_EXPECTED;
5892
5893       /* std:: becomes :: for now.  */
5894       if (got_scope && got_scope == fake_std_node)
5895         got_scope = void_type_node;
5896
5897       if (got_scope)
5898         type = got_scope;
5899       else if (got_object != error_mark_node)
5900         type = got_object;
5901
5902       if (type)
5903         {
5904           if (type == error_mark_node)
5905             return error_mark_node;
5906           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5907             type = TREE_TYPE (type);
5908
5909           if (TYPE_P (type))
5910             type = complete_type (type);
5911
5912           if (TREE_CODE (type) == VOID_TYPE)
5913             type = global_namespace;
5914           if (TREE_CODE (type) == NAMESPACE_DECL)
5915             {
5916               val = make_node (CPLUS_BINDING);
5917               flags |= LOOKUP_COMPLAIN;
5918               if (!qualified_lookup_using_namespace (name, type, val, flags))
5919                 return NULL_TREE;
5920               val = select_decl (val, flags);
5921             }
5922           else if (! IS_AGGR_TYPE (type)
5923                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5924                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5925                    || TREE_CODE (type) == TYPENAME_TYPE)
5926             /* Someone else will give an error about this if needed.  */
5927             val = NULL_TREE;
5928           else if (type == current_class_type)
5929             val = IDENTIFIER_CLASS_VALUE (name);
5930           else
5931             {
5932               val = lookup_member (type, name, 0, prefer_type);
5933               type_access_control (type, val);
5934
5935               /* Restore the containing TYPENAME_TYPE if we looked
5936                  through it before.  */
5937               if (got_scope && got_scope != type
5938                   && val && TREE_CODE (val) == TYPE_DECL
5939                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5940                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5941             }
5942         }
5943       else
5944         val = NULL_TREE;
5945
5946       if (got_scope)
5947         goto done;
5948       else if (got_object && val)
5949         {
5950           from_obj = val;
5951           val = NULL_TREE;
5952         }
5953     }
5954   else
5955     {
5956       flags = lookup_flags (prefer_type, namespaces_only);
5957       /* If we're not parsing, we need to complain. */
5958       flags |= LOOKUP_COMPLAIN;
5959     }
5960
5961   /* First, look in non-namespace scopes.  */
5962
5963   if (current_class_type == NULL_TREE)
5964     nonclass = 1;
5965
5966   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5967     {
5968       tree binding;
5969
5970       if (!LOCAL_BINDING_P (t) && nonclass)
5971         /* We're not looking for class-scoped bindings, so keep going.  */
5972         continue;
5973
5974       /* If this is the kind of thing we're looking for, we're done.  */
5975       if (qualify_lookup (BINDING_VALUE (t), flags))
5976         binding = BINDING_VALUE (t);
5977       else if ((flags & LOOKUP_PREFER_TYPES)
5978                && qualify_lookup (BINDING_TYPE (t), flags))
5979         binding = BINDING_TYPE (t);
5980       else
5981         binding = NULL_TREE;
5982
5983       /* Handle access control on types from enclosing or base classes.  */
5984       if (binding && ! yylex
5985           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5986         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5987
5988       if (binding
5989           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5990         {
5991           if (val_is_implicit_typename && !yylex)
5992             warn_about_implicit_typename_lookup (val, binding);
5993           val = binding;
5994           val_is_implicit_typename
5995             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5996           if (!val_is_implicit_typename)
5997             break;
5998         }
5999     }
6000
6001   /* Now lookup in namespace scopes.  */
6002   if (!val || val_is_implicit_typename)
6003     {
6004       t = unqualified_namespace_lookup (name, flags, 0);
6005       if (t)
6006         {
6007           if (val_is_implicit_typename && !yylex)
6008             warn_about_implicit_typename_lookup (val, t);
6009           val = t;
6010         }
6011     }
6012
6013  done:
6014   if (val)
6015     {
6016       /* This should only warn about types used in qualified-ids.  */
6017       if (from_obj && from_obj != val)
6018         {
6019           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6020               && TREE_CODE (val) == TYPE_DECL
6021               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6022             cp_pedwarn ("\
6023 lookup of `%D' in the scope of `%#T' (`%#T') \
6024 does not match lookup in the current scope (`%#T')",
6025                         name, got_object, TREE_TYPE (from_obj),
6026                         TREE_TYPE (val));
6027
6028           /* We don't change val to from_obj if got_object depends on
6029              template parms because that breaks implicit typename for
6030              destructor calls.  */
6031           if (! uses_template_parms (got_object))
6032             val = from_obj;
6033         }
6034
6035       /* If we have a single function from a using decl, pull it out.  */
6036       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6037         val = OVL_FUNCTION (val);
6038     }
6039   else if (from_obj)
6040     val = from_obj;
6041
6042   return val;
6043 }
6044
6045 tree
6046 lookup_name_nonclass (name)
6047      tree name;
6048 {
6049   return lookup_name_real (name, 0, 1, 0);
6050 }
6051
6052 tree
6053 lookup_function_nonclass (name, args)
6054      tree name;
6055      tree args;
6056 {
6057   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6058 }
6059
6060 tree
6061 lookup_name_namespace_only (name)
6062      tree name;
6063 {
6064   /* type-or-namespace, nonclass, namespace_only */
6065   return lookup_name_real (name, 1, 1, 1);
6066 }
6067
6068 tree
6069 lookup_name (name, prefer_type)
6070      tree name;
6071      int prefer_type;
6072 {
6073   return lookup_name_real (name, prefer_type, 0, 0);
6074 }
6075
6076 /* Similar to `lookup_name' but look only in the innermost non-class
6077    binding level.  */
6078
6079 tree
6080 lookup_name_current_level (name)
6081      tree name;
6082 {
6083   struct binding_level *b;
6084   tree t = NULL_TREE;
6085
6086   b = current_binding_level;
6087   while (b->parm_flag == 2)
6088     b = b->level_chain;
6089
6090   if (b->namespace_p)
6091     {
6092       t = IDENTIFIER_NAMESPACE_VALUE (name);
6093
6094       /* extern "C" function() */
6095       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6096         t = TREE_VALUE (t);
6097     }
6098   else if (IDENTIFIER_BINDING (name)
6099            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6100     {
6101       while (1)
6102         {
6103           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6104             return IDENTIFIER_VALUE (name);
6105
6106           if (b->keep == 2)
6107             b = b->level_chain;
6108           else
6109             break;
6110         }
6111     }
6112
6113   return t;
6114 }
6115
6116 /* Like lookup_name_current_level, but for types.  */
6117
6118 tree
6119 lookup_type_current_level (name)
6120      tree name;
6121 {
6122   register tree t = NULL_TREE;
6123
6124   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6125
6126   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6127       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6128     {
6129       struct binding_level *b = current_binding_level;
6130       while (1)
6131         {
6132           if (purpose_member (name, b->type_shadowed))
6133             return REAL_IDENTIFIER_TYPE_VALUE (name);
6134           if (b->keep == 2)
6135             b = b->level_chain;
6136           else
6137             break;
6138         }
6139     }
6140
6141   return t;
6142 }
6143
6144 void
6145 begin_only_namespace_names ()
6146 {
6147   only_namespace_names = 1;
6148 }
6149
6150 void
6151 end_only_namespace_names ()
6152 {
6153   only_namespace_names = 0;
6154 }
6155 \f
6156 /* Push the declarations of builtin types into the namespace.
6157    RID_INDEX is the index of the builtin type
6158    in the array RID_POINTERS.  NAME is the name used when looking
6159    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6160
6161 static void
6162 record_builtin_type (rid_index, name, type)
6163      enum rid rid_index;
6164      const char *name;
6165      tree type;
6166 {
6167   tree rname = NULL_TREE, tname = NULL_TREE;
6168   tree tdecl = NULL_TREE;
6169
6170   if ((int) rid_index < (int) RID_MAX)
6171     rname = ridpointers[(int) rid_index];
6172   if (name)
6173     tname = get_identifier (name);
6174
6175   TYPE_BUILT_IN (type) = 1;
6176
6177   if (tname)
6178     {
6179       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6180       set_identifier_type_value (tname, NULL_TREE);
6181       if ((int) rid_index < (int) RID_MAX)
6182         /* Built-in types live in the global namespace. */
6183         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6184     }
6185   if (rname != NULL_TREE)
6186     {
6187       if (tname != NULL_TREE)
6188         {
6189           set_identifier_type_value (rname, NULL_TREE);
6190           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6191         }
6192       else
6193         {
6194           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6195           set_identifier_type_value (rname, NULL_TREE);
6196         }
6197     }
6198 }
6199
6200 /* Record one of the standard Java types.
6201  * Declare it as having the given NAME.
6202  * If SIZE > 0, it is the size of one of the integral types;
6203  * otherwise it is the negative of the size of one of the other types.  */
6204
6205 static tree
6206 record_builtin_java_type (name, size)
6207      const char *name;
6208      int size;
6209 {
6210   tree type, decl;
6211   if (size > 0)
6212     type = make_signed_type (size);
6213   else if (size > -32)
6214     { /* "__java_char" or ""__java_boolean". */
6215       type = make_unsigned_type (-size);
6216       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6217     }
6218   else
6219     { /* "__java_float" or ""__java_double". */
6220       type = make_node (REAL_TYPE);
6221       TYPE_PRECISION (type) = - size;
6222       layout_type (type);
6223     }
6224   record_builtin_type (RID_MAX, name, type);
6225   decl = TYPE_NAME (type);
6226
6227   /* Suppress generate debug symbol entries for these types,
6228      since for normal C++ they are just clutter.
6229      However, push_lang_context undoes this if extern "Java" is seen. */
6230   DECL_IGNORED_P (decl) = 1;
6231
6232   TYPE_FOR_JAVA (type) = 1;
6233   return type;
6234 }
6235
6236 /* Push a type into the namespace so that the back-ends ignore it. */
6237
6238 static void
6239 record_unknown_type (type, name)
6240      tree type;
6241      const char *name;
6242 {
6243   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6244   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6245   DECL_IGNORED_P (decl) = 1;
6246   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6247   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6248   TYPE_ALIGN (type) = 1;
6249   TYPE_USER_ALIGN (type) = 0;
6250   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6251 }
6252
6253 /* An string for which we should create an IDENTIFIER_NODE at
6254    startup.  */
6255
6256 typedef struct predefined_identifier
6257 {
6258   /* The name of the identifier.  */
6259   const char *name;
6260   /* The place where the IDENTIFIER_NODE should be stored.  */
6261   tree *node;
6262   /* Non-zero if this is the name of a constructor or destructor.  */
6263   int ctor_or_dtor_p;
6264 } predefined_identifier;
6265
6266 /* Create all the predefined identifiers.  */
6267
6268 static void
6269 initialize_predefined_identifiers ()
6270 {
6271   struct predefined_identifier *pid;
6272
6273   /* A table of identifiers to create at startup.  */
6274   static predefined_identifier predefined_identifiers[] = {
6275     { "C++", &lang_name_cplusplus, 0 },
6276     { "C", &lang_name_c, 0 },
6277     { "Java", &lang_name_java, 0 },
6278     { CTOR_NAME, &ctor_identifier, 1 },
6279     { "__base_ctor", &base_ctor_identifier, 1 },
6280     { "__comp_ctor", &complete_ctor_identifier, 1 },
6281     { DTOR_NAME, &dtor_identifier, 1 },
6282     { "__comp_dtor", &complete_dtor_identifier, 1 },
6283     { "__base_dtor", &base_dtor_identifier, 1 },
6284     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6285     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6286     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6287     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6288     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6289     { "nelts", &nelts_identifier, 0 },
6290     { THIS_NAME, &this_identifier, 0 },
6291     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6292     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6293     { "_vptr", &vptr_identifier, 0 },
6294     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6295     { "__vtt_parm", &vtt_parm_identifier, 0 },
6296     { "std", &std_identifier, 0 },
6297     { NULL, NULL, 0 }
6298   };
6299
6300   for (pid = predefined_identifiers; pid->name; ++pid)
6301     {
6302       *pid->node = get_identifier (pid->name);
6303       if (pid->ctor_or_dtor_p)
6304         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6305     }
6306 }
6307
6308 /* Create the predefined scalar types of C,
6309    and some nodes representing standard constants (0, 1, (void *)0).
6310    Initialize the global binding level.
6311    Make definitions for built-in primitive functions.  */
6312
6313 void
6314 init_decl_processing ()
6315 {
6316   tree fields[20];
6317   int wchar_type_size;
6318   tree array_domain_type;
6319
6320   /* Check to see that the user did not specify an invalid combination
6321      of command-line options.  */
6322   if (flag_new_abi && !flag_vtable_thunks)
6323     fatal ("the new ABI requires vtable thunks");
6324
6325   /* Create all the identifiers we need.  */
6326   initialize_predefined_identifiers ();
6327
6328   /* Fill in back-end hooks.  */
6329   init_lang_status = &push_cp_function_context;
6330   free_lang_status = &pop_cp_function_context;
6331   mark_lang_status = &mark_cp_function_context;
6332   lang_safe_from_p = &c_safe_from_p;
6333
6334   cp_parse_init ();
6335   init_decl2 ();
6336   init_pt ();
6337
6338   /* Create the global variables.  */
6339   push_to_top_level ();
6340
6341   /* Enter the global namespace. */
6342   my_friendly_assert (global_namespace == NULL_TREE, 375);
6343   push_namespace (get_identifier ("::"));
6344   global_namespace = current_namespace;
6345   current_lang_name = NULL_TREE;
6346
6347   /* Adjust various flags based on command-line settings.  */
6348   if (! flag_permissive && ! pedantic)
6349     flag_pedantic_errors = 1;
6350   if (!flag_no_inline)
6351     flag_inline_trees = 1;
6352
6353   /* Initially, C.  */
6354   current_lang_name = lang_name_c;
6355
6356   current_function_decl = NULL_TREE;
6357   current_binding_level = NULL_BINDING_LEVEL;
6358   free_binding_level = NULL_BINDING_LEVEL;
6359
6360   build_common_tree_nodes (flag_signed_char);
6361
6362   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6363   TREE_TYPE (error_mark_list) = error_mark_node;
6364
6365   /* Make the binding_level structure for global names.  */
6366   pushlevel (0);
6367   global_binding_level = current_binding_level;
6368   /* The global level is the namespace level of ::.  */
6369   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6370   declare_namespace_level ();
6371
6372   /* Create the `std' namespace.  */
6373   if (flag_honor_std)
6374     {
6375       push_namespace (std_identifier);
6376       std_node = current_namespace;
6377       pop_namespace ();
6378       fake_std_node = error_mark_node;
6379     }
6380   else
6381     {
6382       fake_std_node = build_decl (NAMESPACE_DECL,
6383                                   std_identifier,
6384                                   void_type_node);
6385       pushdecl (fake_std_node);
6386     }
6387
6388   /* Define `int' and `char' first so that dbx will output them first.  */
6389   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6390   record_builtin_type (RID_CHAR, "char", char_type_node);
6391
6392   /* `signed' is the same as `int' */
6393   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6394   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6395   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6396   record_builtin_type (RID_MAX, "long unsigned int",
6397                        long_unsigned_type_node);
6398   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6399   record_builtin_type (RID_MAX, "long long int",
6400                        long_long_integer_type_node);
6401   record_builtin_type (RID_MAX, "long long unsigned int",
6402                        long_long_unsigned_type_node);
6403   record_builtin_type (RID_MAX, "long long unsigned",
6404                        long_long_unsigned_type_node);
6405   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6406   record_builtin_type (RID_MAX, "short unsigned int",
6407                        short_unsigned_type_node);
6408   record_builtin_type (RID_MAX, "unsigned short",
6409                        short_unsigned_type_node);
6410
6411   ptrdiff_type_node
6412     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6413   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
6414
6415   /* Define both `signed char' and `unsigned char'.  */
6416   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6417   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6418
6419   /* `unsigned long' is the standard type for sizeof.
6420      Note that stddef.h uses `unsigned long',
6421      and this must agree, even if long and int are the same size.  */
6422   c_size_type_node =
6423     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
6424   signed_size_type_node = signed_type (c_size_type_node);
6425   set_sizetype (c_size_type_node);
6426
6427   /* Create the widest literal types. */
6428   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6429   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6430                         widest_integer_literal_type_node));
6431
6432   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6433   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6434                         widest_unsigned_literal_type_node));
6435
6436   /* These are types that type_for_size and type_for_mode use.  */
6437   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6438   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6439   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6440   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6441 #if HOST_BITS_PER_WIDE_INT >= 64
6442   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6443 #endif
6444   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6445   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6446   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6447   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6448 #if HOST_BITS_PER_WIDE_INT >= 64
6449   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6450 #endif
6451
6452   build_common_tree_nodes_2 (flag_short_double);
6453
6454   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6455   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6456   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6457   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6458   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6459   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6460   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6461   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6462
6463   integer_two_node = build_int_2 (2, 0);
6464   TREE_TYPE (integer_two_node) = integer_type_node;
6465   integer_three_node = build_int_2 (3, 0);
6466   TREE_TYPE (integer_three_node) = integer_type_node;
6467
6468   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6469   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6470   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6471   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6472   TYPE_PRECISION (boolean_type_node) = 1;
6473   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6474   boolean_false_node = build_int_2 (0, 0);
6475   TREE_TYPE (boolean_false_node) = boolean_type_node;
6476   boolean_true_node = build_int_2 (1, 0);
6477   TREE_TYPE (boolean_true_node) = boolean_type_node;
6478
6479   signed_size_zero_node = build_int_2 (0, 0);
6480   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6481   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6482   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6483
6484   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6485                         complex_integer_type_node));
6486   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6487                         complex_float_type_node));
6488   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6489                         complex_double_type_node));
6490   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6491                         complex_long_double_type_node));
6492
6493   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6494
6495   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6496   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6497   TREE_PARMLIST (void_list_node) = 1;
6498
6499   string_type_node = build_pointer_type (char_type_node);
6500   const_string_type_node
6501     = build_pointer_type (build_qualified_type (char_type_node,
6502                                                 TYPE_QUAL_CONST));
6503   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6504 #if 0
6505   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6506 #endif
6507
6508   /* Make a type to be the domain of a few array types
6509      whose domains don't really matter.
6510      200 is small enough that it always fits in size_t.  */
6511   array_domain_type = build_index_type (build_int_2 (200, 0));
6512
6513   /* Make a type for arrays of characters.
6514      With luck nothing will ever really depend on the length of this
6515      array type.  */
6516   char_array_type_node
6517     = build_array_type (char_type_node, array_domain_type);
6518
6519   /* Likewise for arrays of ints.  */
6520   int_array_type_node
6521     = build_array_type (integer_type_node, array_domain_type);
6522
6523   if (flag_new_abi)
6524     delta_type_node = ptrdiff_type_node;
6525   else if (flag_huge_objects)
6526     delta_type_node = long_integer_type_node;
6527   else
6528     delta_type_node = short_integer_type_node;
6529
6530   if (flag_new_abi)
6531     vtable_index_type = ptrdiff_type_node;
6532   else
6533     vtable_index_type = delta_type_node;
6534
6535   default_function_type
6536     = build_function_type (integer_type_node, NULL_TREE);
6537
6538   ptr_type_node = build_pointer_type (void_type_node);
6539   const_ptr_type_node
6540     = build_pointer_type (build_qualified_type (void_type_node,
6541                                                 TYPE_QUAL_CONST));
6542   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6543   c_common_nodes_and_builtins ();
6544   lang_type_promotes_to = convert_type_from_ellipsis;
6545
6546   void_ftype_ptr
6547     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6548
6549 #ifdef MD_INIT_BUILTINS
6550   MD_INIT_BUILTINS;
6551 #endif
6552
6553   /* C++ extensions */
6554
6555   unknown_type_node = make_node (UNKNOWN_TYPE);
6556   record_unknown_type (unknown_type_node, "unknown type");
6557
6558   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6559   TREE_TYPE (unknown_type_node) = unknown_type_node;
6560
6561   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6562
6563   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6564      result.  */
6565   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6566   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6567
6568   /* This is special for C++ so functions can be overloaded.  */
6569   wchar_type_node = get_identifier (flag_short_wchar
6570                                     ? "short unsigned int"
6571                                     : WCHAR_TYPE);
6572   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6573   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6574   if (TREE_UNSIGNED (wchar_type_node))
6575     wchar_type_node = make_signed_type (wchar_type_size);
6576   else
6577     wchar_type_node = make_unsigned_type (wchar_type_size);
6578   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6579
6580   /* Artificial declaration of wchar_t -- can be bashed */
6581   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6582                                 wchar_type_node);
6583   pushdecl (wchar_decl_node);
6584
6585   /* This is for wide string constants.  */
6586   wchar_array_type_node
6587     = build_array_type (wchar_type_node, array_domain_type);
6588
6589   wint_type_node =
6590     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WINT_TYPE)));
6591
6592   intmax_type_node =
6593     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE)));
6594   uintmax_type_node =
6595     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE)));
6596
6597   if (flag_vtable_thunks)
6598     {
6599       /* Make sure we get a unique function type, so we can give
6600          its pointer type a name.  (This wins for gdb.) */
6601       tree vfunc_type = make_node (FUNCTION_TYPE);
6602       TREE_TYPE (vfunc_type) = integer_type_node;
6603       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6604       layout_type (vfunc_type);
6605
6606       vtable_entry_type = build_pointer_type (vfunc_type);
6607     }
6608   else
6609     {
6610       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6611       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6612                               delta_type_node);
6613       fields[1] = build_decl (FIELD_DECL, index_identifier,
6614                               delta_type_node);
6615       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6616                               ptr_type_node);
6617       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6618                            double_type_node);
6619
6620       /* Make this part of an invisible union.  */
6621       fields[3] = copy_node (fields[2]);
6622       TREE_TYPE (fields[3]) = delta_type_node;
6623       DECL_NAME (fields[3]) = delta2_identifier;
6624       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6625       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6626       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6627       TREE_UNSIGNED (fields[3]) = 0;
6628       TREE_CHAIN (fields[2]) = fields[3];
6629       vtable_entry_type = build_qualified_type (vtable_entry_type,
6630                                                 TYPE_QUAL_CONST);
6631     }
6632   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6633
6634   vtbl_type_node
6635     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6636   layout_type (vtbl_type_node);
6637   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6638   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6639   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6640   layout_type (vtbl_ptr_type_node);
6641   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6642
6643   if (flag_new_abi)
6644     {
6645       push_namespace (get_identifier ("__cxxabiv1"));
6646       abi_node = current_namespace;
6647       pop_namespace ();
6648     }
6649
6650   global_type_node = make_node (LANG_TYPE);
6651   record_unknown_type (global_type_node, "global type");
6652
6653   /* Now, C++.  */
6654   current_lang_name = lang_name_cplusplus;
6655
6656   {
6657     tree bad_alloc_type_node, newtype, deltype;
6658     if (flag_honor_std)
6659       push_namespace (std_identifier);
6660     bad_alloc_type_node = xref_tag
6661       (class_type_node, get_identifier ("bad_alloc"), 1);
6662     if (flag_honor_std)
6663       pop_namespace ();
6664     newtype = build_exception_variant
6665       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6666     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6667     push_cp_library_fn (NEW_EXPR, newtype);
6668     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6669     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6670     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6671   }
6672
6673   abort_fndecl
6674     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6675
6676   /* Perform other language dependent initializations.  */
6677   init_class_processing ();
6678   init_init_processing ();
6679   init_search_processing ();
6680   init_rtti_processing ();
6681
6682   if (flag_exceptions)
6683     init_exception_processing ();
6684   if (flag_no_inline)
6685     {
6686       flag_inline_functions = 0;
6687     }
6688
6689   if (! supports_one_only ())
6690     flag_weak = 0;
6691
6692   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6693   function_id_node = get_identifier ("__FUNCTION__");
6694   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6695   func_id_node = get_identifier ("__func__");
6696
6697   make_fname_decl = cp_make_fname_decl;
6698   declare_function_name ();
6699
6700   /* Prepare to check format strings against argument lists.  */
6701   init_function_format_info ();
6702
6703   /* Show we use EH for cleanups.  */
6704   using_eh_for_cleanups ();
6705
6706   valid_lang_attribute = cp_valid_lang_attribute;
6707
6708   /* Maintain consistency.  Perhaps we should just complain if they
6709      say -fwritable-strings?  */
6710   if (flag_writable_strings)
6711     flag_const_strings = 0;
6712
6713   /* Add GC roots for all of our global variables.  */
6714   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6715   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6716   ggc_add_tree_root (&integer_three_node, 1);
6717   ggc_add_tree_root (&integer_two_node, 1);
6718   ggc_add_tree_root (&signed_size_zero_node, 1);
6719   ggc_add_tree_root (&size_one_node, 1);
6720   ggc_add_tree_root (&size_zero_node, 1);
6721   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6722                 mark_binding_level);
6723   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6724   ggc_add_tree_root (&static_ctors, 1);
6725   ggc_add_tree_root (&static_dtors, 1);
6726   ggc_add_tree_root (&lastiddecl, 1);
6727
6728   ggc_add_tree_root (&last_function_parm_tags, 1);
6729   ggc_add_tree_root (&current_function_return_value, 1);
6730   ggc_add_tree_root (&current_function_parm_tags, 1);
6731   ggc_add_tree_root (&last_function_parms, 1);
6732   ggc_add_tree_root (&error_mark_list, 1);
6733
6734   ggc_add_tree_root (&global_namespace, 1);
6735   ggc_add_tree_root (&global_type_node, 1);
6736   ggc_add_tree_root (&anonymous_namespace_name, 1);
6737
6738   ggc_add_tree_root (&got_object, 1);
6739   ggc_add_tree_root (&got_scope, 1);
6740
6741   ggc_add_tree_root (&current_lang_name, 1);
6742   ggc_add_tree_root (&static_aggregates, 1);
6743 }
6744
6745 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6746    decl, NAME is the initialization string and TYPE_DEP indicates whether
6747    NAME depended on the type of the function. We make use of that to detect
6748    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6749    the function before emitting any of it, we don't need to treat the
6750    VAR_DECL specially. We can decide whether to emit it later, if it was
6751    used.  */
6752
6753 static tree
6754 cp_make_fname_decl (id, name, type_dep)
6755      tree id;
6756      const char *name;
6757      int type_dep;
6758 {
6759   tree decl, type, init;
6760   size_t length = strlen (name);
6761   tree domain = NULL_TREE;
6762
6763   if (!processing_template_decl)
6764     type_dep = 0;
6765   if (!type_dep)
6766     domain = build_index_type (build_int_2 (length, 0));
6767
6768   type =  build_cplus_array_type
6769           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6770            domain);
6771
6772   decl = build_decl (VAR_DECL, id, type);
6773   TREE_STATIC (decl) = 1;
6774   TREE_READONLY (decl) = 1;
6775   DECL_SOURCE_LINE (decl) = 0;
6776   DECL_ARTIFICIAL (decl) = 1;
6777   DECL_IN_SYSTEM_HEADER (decl) = 1;
6778   pushdecl (decl);
6779   if (processing_template_decl)
6780     decl = push_template_decl (decl);
6781   if (type_dep)
6782     {
6783       init = build (FUNCTION_NAME, type);
6784       DECL_PRETTY_FUNCTION_P (decl) = 1;
6785     }
6786   else
6787     {
6788       init = build_string (length + 1, name);
6789       TREE_TYPE (init) = type;
6790     }
6791   DECL_INITIAL (decl) = init;
6792   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6793
6794   /* We will have to make sure we only emit this, if it is actually used. */
6795   return decl;
6796 }
6797
6798 /* Entry point for the benefit of c_common_nodes_and_builtins.
6799
6800    Make a definition for a builtin function named NAME and whose data type
6801    is TYPE.  TYPE should be a function type with argument types.
6802
6803    CLASS and CODE tell later passes how to compile calls to this function.
6804    See tree.h for possible values.
6805
6806    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6807    the name to be called if we can't opencode the function.  */
6808
6809 tree
6810 builtin_function (name, type, code, class, libname)
6811      const char *name;
6812      tree type;
6813      int code;
6814      enum built_in_class class;
6815      const char *libname;
6816 {
6817   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6818   DECL_BUILT_IN_CLASS (decl) = class;
6819   DECL_FUNCTION_CODE (decl) = code;
6820
6821   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6822
6823   /* All builtins that don't begin with an `_' should go in the `std'
6824      namespace.  */
6825   if (flag_honor_std && name[0] != '_')
6826     {
6827       push_namespace (std_identifier);
6828       DECL_CONTEXT (decl) = std_node;
6829     }
6830   pushdecl (decl);
6831   if (flag_honor_std && name[0] != '_')
6832     pop_namespace ();
6833
6834   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6835      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6836      function in the namespace.  */
6837   if (libname)
6838     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6839   make_function_rtl (decl);
6840
6841   /* Warn if a function in the namespace for users
6842      is used without an occasion to consider it declared.  */
6843   if (name[0] != '_' || name[1] != '_')
6844     DECL_ANTICIPATED (decl) = 1;
6845
6846   return decl;
6847 }
6848
6849 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6850    function.  Not called directly.  */
6851
6852 static tree
6853 build_library_fn_1 (name, operator_code, type)
6854      tree name;
6855      enum tree_code operator_code;
6856      tree type;
6857 {
6858   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6859   DECL_EXTERNAL (fn) = 1;
6860   TREE_PUBLIC (fn) = 1;
6861   DECL_ARTIFICIAL (fn) = 1;
6862   TREE_NOTHROW (fn) = 1;
6863   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6864   return fn;
6865 }
6866
6867 /* Returns the _DECL for a library function with C linkage.
6868    We assume that such functions never throw; if this is incorrect,
6869    callers should unset TREE_NOTHROW.  */
6870
6871 tree
6872 build_library_fn (name, type)
6873      tree name;
6874      tree type;
6875 {
6876   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6877   make_function_rtl (fn);
6878   return fn;
6879 }
6880
6881 /* Returns the _DECL for a library function with C++ linkage.  */
6882
6883 static tree
6884 build_cp_library_fn (name, operator_code, type)
6885      tree name;
6886      enum tree_code operator_code;
6887      tree type;
6888 {
6889   tree fn = build_library_fn_1 (name, operator_code, type);
6890   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6891   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6892   set_mangled_name_for_decl (fn);
6893   make_function_rtl (fn);
6894   return fn;
6895 }
6896
6897 /* Like build_library_fn, but takes a C string instead of an
6898    IDENTIFIER_NODE.  */
6899
6900 tree
6901 build_library_fn_ptr (name, type)
6902      const char *name;
6903      tree type;
6904 {
6905   return build_library_fn (get_identifier (name), type);
6906 }
6907
6908 /* Like build_cp_library_fn, but takes a C string instead of an
6909    IDENTIFIER_NODE.  */
6910
6911 tree
6912 build_cp_library_fn_ptr (name, type)
6913      const char *name;
6914      tree type;
6915 {
6916   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6917 }
6918
6919 /* Like build_library_fn, but also pushes the function so that we will
6920    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6921
6922 tree
6923 push_library_fn (name, type)
6924      tree name, type;
6925 {
6926   tree fn = build_library_fn (name, type);
6927   pushdecl_top_level (fn);
6928   return fn;
6929 }
6930
6931 /* Like build_cp_library_fn, but also pushes the function so that it
6932    will be found by normal lookup.  */
6933
6934 static tree
6935 push_cp_library_fn (operator_code, type)
6936      enum tree_code operator_code;
6937      tree type;
6938 {
6939   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6940                                  operator_code,
6941                                  type);
6942   pushdecl (fn);
6943   return fn;
6944 }
6945
6946 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6947    a FUNCTION_TYPE.  */
6948
6949 tree
6950 push_void_library_fn (name, parmtypes)
6951      tree name, parmtypes;
6952 {
6953   tree type = build_function_type (void_type_node, parmtypes);
6954   return push_library_fn (name, type);
6955 }
6956
6957 /* Like push_library_fn, but also note that this function throws
6958    and does not return.  Used for __throw_foo and the like.  */
6959
6960 tree
6961 push_throw_library_fn (name, type)
6962      tree name, type;
6963 {
6964   tree fn = push_library_fn (name, type);
6965   TREE_THIS_VOLATILE (fn) = 1;
6966   TREE_NOTHROW (fn) = 0;
6967   return fn;
6968 }
6969 \f
6970 /* When we call finish_struct for an anonymous union, we create
6971    default copy constructors and such.  But, an anonymous union
6972    shouldn't have such things; this function undoes the damage to the
6973    anonymous union type T.
6974
6975    (The reason that we create the synthesized methods is that we don't
6976    distinguish `union { int i; }' from `typedef union { int i; } U'.
6977    The first is an anonymous union; the second is just an ordinary
6978    union type.)  */
6979
6980 void
6981 fixup_anonymous_aggr (t)
6982      tree t;
6983 {
6984   tree *q;
6985
6986   /* Wipe out memory of synthesized methods */
6987   TYPE_HAS_CONSTRUCTOR (t) = 0;
6988   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6989   TYPE_HAS_INIT_REF (t) = 0;
6990   TYPE_HAS_CONST_INIT_REF (t) = 0;
6991   TYPE_HAS_ASSIGN_REF (t) = 0;
6992   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6993
6994   /* Splice the implicitly generated functions out of the TYPE_METHODS
6995      list.  */
6996   q = &TYPE_METHODS (t);
6997   while (*q)
6998     {
6999       if (DECL_ARTIFICIAL (*q))
7000         *q = TREE_CHAIN (*q);
7001       else
7002         q = &TREE_CHAIN (*q);
7003     }
7004
7005   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7006   if (TYPE_METHODS (t))
7007     error ("an anonymous union cannot have function members");
7008 }
7009
7010 /* Make sure that a declaration with no declarator is well-formed, i.e.
7011    just defines a tagged type or anonymous union.
7012
7013    Returns the type defined, if any.  */
7014
7015 tree
7016 check_tag_decl (declspecs)
7017      tree declspecs;
7018 {
7019   int found_type = 0;
7020   int saw_friend = 0;
7021   tree ob_modifier = NULL_TREE;
7022   register tree link;
7023   register tree t = NULL_TREE;
7024
7025   for (link = declspecs; link; link = TREE_CHAIN (link))
7026     {
7027       register tree value = TREE_VALUE (link);
7028
7029       if (TYPE_P (value)
7030           || (TREE_CODE (value) == IDENTIFIER_NODE
7031               && IDENTIFIER_GLOBAL_VALUE (value)
7032               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7033         {
7034           ++found_type;
7035
7036           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7037               || TREE_CODE (value) == ENUMERAL_TYPE)
7038             {
7039               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7040               t = value;
7041             }
7042         }
7043       else if (value == ridpointers[(int) RID_FRIEND])
7044         {
7045           if (current_class_type == NULL_TREE
7046               || current_scope () != current_class_type)
7047             ob_modifier = value;
7048           else
7049             saw_friend = 1;
7050         }
7051       else if (value == ridpointers[(int) RID_STATIC]
7052                || value == ridpointers[(int) RID_EXTERN]
7053                || value == ridpointers[(int) RID_AUTO]
7054                || value == ridpointers[(int) RID_REGISTER]
7055                || value == ridpointers[(int) RID_INLINE]
7056                || value == ridpointers[(int) RID_VIRTUAL]
7057                || value == ridpointers[(int) RID_CONST]
7058                || value == ridpointers[(int) RID_VOLATILE]
7059                || value == ridpointers[(int) RID_EXPLICIT])
7060         ob_modifier = value;
7061     }
7062
7063   if (found_type > 1)
7064     error ("multiple types in one declaration");
7065
7066   if (t == NULL_TREE && ! saw_friend)
7067     pedwarn ("declaration does not declare anything");
7068
7069   /* Check for an anonymous union.  We're careful
7070      accessing TYPE_IDENTIFIER because some built-in types, like
7071      pointer-to-member types, do not have TYPE_NAME.  */
7072   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7073            && TYPE_NAME (t)
7074            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7075     {
7076       /* Anonymous unions are objects, so they can have specifiers.  */;
7077       SET_ANON_AGGR_TYPE_P (t);
7078
7079       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7080         pedwarn ("ISO C++ prohibits anonymous structs");
7081     }
7082
7083   else if (ob_modifier)
7084     {
7085       if (ob_modifier == ridpointers[(int) RID_INLINE]
7086           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7087         cp_error ("`%D' can only be specified for functions", ob_modifier);
7088       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7089         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7090       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7091         cp_error ("`%D' can only be specified for constructors",
7092                   ob_modifier);
7093       else
7094         cp_error ("`%D' can only be specified for objects and functions",
7095                   ob_modifier);
7096     }
7097
7098   return t;
7099 }
7100
7101 /* Called when a declaration is seen that contains no names to declare.
7102    If its type is a reference to a structure, union or enum inherited
7103    from a containing scope, shadow that tag name for the current scope
7104    with a forward reference.
7105    If its type defines a new named structure or union
7106    or defines an enum, it is valid but we need not do anything here.
7107    Otherwise, it is an error.
7108
7109    C++: may have to grok the declspecs to learn about static,
7110    complain for anonymous unions.  */
7111
7112 void
7113 shadow_tag (declspecs)
7114      tree declspecs;
7115 {
7116   tree t = check_tag_decl (declspecs);
7117
7118   if (t)
7119     maybe_process_partial_specialization (t);
7120
7121   /* This is where the variables in an anonymous union are
7122      declared.  An anonymous union declaration looks like:
7123      union { ... } ;
7124      because there is no declarator after the union, the parser
7125      sends that declaration here.  */
7126   if (t && ANON_AGGR_TYPE_P (t))
7127     {
7128       fixup_anonymous_aggr (t);
7129
7130       if (TYPE_FIELDS (t))
7131         {
7132           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7133                                       NULL_TREE);
7134           finish_anon_union (decl);
7135         }
7136     }
7137 }
7138 \f
7139 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7140
7141 tree
7142 groktypename (typename)
7143      tree typename;
7144 {
7145   if (TREE_CODE (typename) != TREE_LIST)
7146     return typename;
7147   return grokdeclarator (TREE_VALUE (typename),
7148                          TREE_PURPOSE (typename),
7149                          TYPENAME, 0, NULL_TREE);
7150 }
7151
7152 /* Decode a declarator in an ordinary declaration or data definition.
7153    This is called as soon as the type information and variable name
7154    have been parsed, before parsing the initializer if any.
7155    Here we create the ..._DECL node, fill in its type,
7156    and put it on the list of decls for the current context.
7157    The ..._DECL node is returned as the value.
7158
7159    Exception: for arrays where the length is not specified,
7160    the type is left null, to be filled in by `cp_finish_decl'.
7161
7162    Function definitions do not come here; they go to start_function
7163    instead.  However, external and forward declarations of functions
7164    do go through here.  Structure field declarations are done by
7165    grokfield and not through here.  */
7166
7167 tree
7168 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7169      tree declarator, declspecs;
7170      int initialized;
7171      tree attributes, prefix_attributes;
7172 {
7173   register tree decl;
7174   register tree type, tem;
7175   tree context;
7176   extern int have_extern_spec;
7177   extern int used_extern_spec;
7178   tree attrlist;
7179
7180 #if 0
7181   /* See code below that used this.  */
7182   int init_written = initialized;
7183 #endif
7184
7185   /* This should only be done once on the top most decl.  */
7186   if (have_extern_spec && !used_extern_spec)
7187     {
7188       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7189                              declspecs);
7190       used_extern_spec = 1;
7191     }
7192
7193   if (attributes || prefix_attributes)
7194     attrlist = build_tree_list (attributes, prefix_attributes);
7195   else
7196     attrlist = NULL_TREE;
7197
7198   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7199                          attrlist);
7200
7201   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7202     return NULL_TREE;
7203
7204   type = TREE_TYPE (decl);
7205
7206   if (type == error_mark_node)
7207     return NULL_TREE;
7208
7209   context = DECL_CONTEXT (decl);
7210
7211   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7212       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7213     {
7214       /* When parsing the initializer, lookup should use the object's
7215          namespace. */
7216       push_decl_namespace (context);
7217     }
7218
7219   /* We are only interested in class contexts, later. */
7220   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7221     context = NULL_TREE;
7222
7223   if (initialized)
7224     /* Is it valid for this decl to have an initializer at all?
7225        If not, set INITIALIZED to zero, which will indirectly
7226        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7227     switch (TREE_CODE (decl))
7228       {
7229       case TYPE_DECL:
7230         /* typedef foo = bar  means give foo the same type as bar.
7231            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7232            Any other case of an initialization in a TYPE_DECL is an error.  */
7233         if (pedantic || list_length (declspecs) > 1)
7234           {
7235             cp_error ("typedef `%D' is initialized", decl);
7236             initialized = 0;
7237           }
7238         break;
7239
7240       case FUNCTION_DECL:
7241         cp_error ("function `%#D' is initialized like a variable", decl);
7242         initialized = 0;
7243         break;
7244
7245       default:
7246         break;
7247       }
7248
7249   if (initialized)
7250     {
7251       if (! toplevel_bindings_p ()
7252           && DECL_EXTERNAL (decl))
7253         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7254                     decl);
7255       DECL_EXTERNAL (decl) = 0;
7256       if (toplevel_bindings_p ())
7257         TREE_STATIC (decl) = 1;
7258
7259       /* Tell `pushdecl' this is an initialized decl
7260          even though we don't yet have the initializer expression.
7261          Also tell `cp_finish_decl' it may store the real initializer.  */
7262       DECL_INITIAL (decl) = error_mark_node;
7263     }
7264
7265 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7266   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7267 #endif
7268
7269   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7270   cplus_decl_attributes (decl, attributes, prefix_attributes);
7271
7272   if (context && COMPLETE_TYPE_P (complete_type (context)))
7273     {
7274       push_nested_class (context, 2);
7275
7276       if (TREE_CODE (decl) == VAR_DECL)
7277         {
7278           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7279           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7280             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7281           else
7282             {
7283               if (DECL_CONTEXT (field) != context)
7284                 {
7285                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7286                               DECL_CONTEXT (field), DECL_NAME (decl),
7287                               context, DECL_NAME (decl));
7288                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7289                 }
7290               /* Static data member are tricky; an in-class initialization
7291                  still doesn't provide a definition, so the in-class
7292                  declaration will have DECL_EXTERNAL set, but will have an
7293                  initialization.  Thus, duplicate_decls won't warn
7294                  about this situation, and so we check here.  */
7295               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7296                 cp_error ("duplicate initialization of %D", decl);
7297               if (duplicate_decls (decl, field))
7298                 decl = field;
7299             }
7300         }
7301       else
7302         {
7303           tree field = check_classfn (context, decl);
7304           if (field && duplicate_decls (decl, field))
7305             decl = field;
7306         }
7307
7308       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7309       DECL_IN_AGGR_P (decl) = 0;
7310       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7311           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7312         {
7313           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7314           /* [temp.expl.spec] An explicit specialization of a static data
7315              member of a template is a definition if the declaration
7316              includes an initializer; otherwise, it is a declaration.
7317
7318              We check for processing_specialization so this only applies
7319              to the new specialization syntax.  */
7320           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7321             DECL_EXTERNAL (decl) = 1;
7322         }
7323
7324       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7325         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7326                     decl);
7327     }
7328
7329   /* Enter this declaration into the symbol table.  */
7330   tem = maybe_push_decl (decl);
7331
7332   if (processing_template_decl)
7333     tem = push_template_decl (tem);
7334
7335 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7336   /* Tell the back-end to use or not use .common as appropriate.  If we say
7337      -fconserve-space, we want this to save .data space, at the expense of
7338      wrong semantics.  If we say -fno-conserve-space, we want this to
7339      produce errors about redefs; to do this we force variables into the
7340      data segment.  */
7341   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7342 #endif
7343
7344   if (! processing_template_decl)
7345     start_decl_1 (tem);
7346
7347   return tem;
7348 }
7349
7350 void
7351 start_decl_1 (decl)
7352      tree decl;
7353 {
7354   tree type = TREE_TYPE (decl);
7355   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7356
7357   if (type == error_mark_node)
7358     return;
7359
7360   /* If this type of object needs a cleanup, but we're not allowed to
7361      add any more objects with cleanups to the current scope, create a
7362      new binding level.  */
7363   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7364       && current_binding_level->more_cleanups_ok == 0)
7365     {
7366       keep_next_level (2);
7367       pushlevel (1);
7368       clear_last_expr ();
7369       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7370     }
7371
7372   if (initialized)
7373     /* Is it valid for this decl to have an initializer at all?
7374        If not, set INITIALIZED to zero, which will indirectly
7375        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7376     {
7377       /* Don't allow initializations for incomplete types except for
7378          arrays which might be completed by the initialization.  */
7379       if (COMPLETE_TYPE_P (complete_type (type)))
7380         ;                       /* A complete type is ok.  */
7381       else if (TREE_CODE (type) != ARRAY_TYPE)
7382         {
7383           cp_error ("variable `%#D' has initializer but incomplete type",
7384                     decl);
7385           initialized = 0;
7386           type = TREE_TYPE (decl) = error_mark_node;
7387         }
7388       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7389         {
7390           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7391             cp_error ("elements of array `%#D' have incomplete type", decl);
7392           /* else we already gave an error in start_decl.  */
7393           initialized = 0;
7394         }
7395     }
7396
7397   if (!initialized
7398       && TREE_CODE (decl) != TYPE_DECL
7399       && TREE_CODE (decl) != TEMPLATE_DECL
7400       && type != error_mark_node
7401       && IS_AGGR_TYPE (type)
7402       && ! DECL_EXTERNAL (decl))
7403     {
7404       if ((! processing_template_decl || ! uses_template_parms (type))
7405           && !COMPLETE_TYPE_P (complete_type (type)))
7406         {
7407           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7408                  decl);
7409           /* Change the type so that assemble_variable will give
7410              DECL an rtl we can live with: (mem (const_int 0)).  */
7411           type = TREE_TYPE (decl) = error_mark_node;
7412         }
7413       else
7414         {
7415           /* If any base type in the hierarchy of TYPE needs a constructor,
7416              then we set initialized to 1.  This way any nodes which are
7417              created for the purposes of initializing this aggregate
7418              will live as long as it does.  This is necessary for global
7419              aggregates which do not have their initializers processed until
7420              the end of the file.  */
7421           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7422         }
7423     }
7424
7425   if (! initialized)
7426     DECL_INITIAL (decl) = NULL_TREE;
7427 }
7428
7429 /* Handle initialization of references.
7430    These three arguments are from `cp_finish_decl', and have the
7431    same meaning here that they do there.
7432
7433    Quotes on semantics can be found in ARM 8.4.3.  */
7434
7435 static void
7436 grok_reference_init (decl, type, init)
7437      tree decl, type, init;
7438 {
7439   tree tmp;
7440
7441   if (init == NULL_TREE)
7442     {
7443       if ((DECL_LANG_SPECIFIC (decl) == 0
7444            || DECL_IN_AGGR_P (decl) == 0)
7445           && ! DECL_THIS_EXTERN (decl))
7446         cp_error ("`%D' declared as reference but not initialized", decl);
7447       return;
7448     }
7449
7450   if (init == error_mark_node)
7451     return;
7452
7453   if (TREE_CODE (init) == CONSTRUCTOR)
7454     {
7455       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7456       return;
7457     }
7458
7459   if (TREE_CODE (init) == TREE_LIST)
7460     init = build_compound_expr (init);
7461
7462   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7463     init = convert_from_reference (init);
7464
7465   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7466       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7467     {
7468       /* Note: default conversion is only called in very special cases.  */
7469       init = default_conversion (init);
7470     }
7471
7472   /* Convert INIT to the reference type TYPE.  This may involve the
7473      creation of a temporary, whose lifetime must be the same as that
7474      of the reference.  If so, a DECL_STMT for the temporary will be
7475      added just after the DECL_STMT for DECL.  That's why we don't set
7476      DECL_INITIAL for local references (instead assigning to them
7477      explicitly); we need to allow the temporary to be initialized
7478      first.  */
7479   tmp = convert_to_reference
7480     (type, init, CONV_IMPLICIT,
7481      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7482      decl);
7483
7484   if (tmp == error_mark_node)
7485     return;
7486   else if (tmp != NULL_TREE)
7487     {
7488       init = tmp;
7489       tmp = save_expr (tmp);
7490       if (building_stmt_tree ())
7491         {
7492           /* Initialize the declaration.  */
7493           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7494           finish_expr_stmt (tmp);
7495         }
7496       else
7497         DECL_INITIAL (decl) = tmp;
7498     }
7499   else
7500     {
7501       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7502       return;
7503     }
7504
7505   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7506     {
7507       expand_static_init (decl, DECL_INITIAL (decl));
7508       DECL_INITIAL (decl) = NULL_TREE;
7509     }
7510   return;
7511 }
7512
7513 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7514    mucking with forces it does not comprehend (i.e. initialization with a
7515    constructor).  If we are at global scope and won't go into COMMON, fill
7516    it in with a dummy CONSTRUCTOR to force the variable into .data;
7517    otherwise we can use error_mark_node.  */
7518
7519 static tree
7520 obscure_complex_init (decl, init)
7521      tree decl, init;
7522 {
7523   if (! flag_no_inline && TREE_STATIC (decl))
7524     {
7525       if (extract_init (decl, init))
7526         return NULL_TREE;
7527     }
7528
7529 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7530   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7531     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7532                                  NULL_TREE);
7533   else
7534 #endif
7535     DECL_INITIAL (decl) = error_mark_node;
7536
7537   return init;
7538 }
7539
7540 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7541    array until we finish parsing the initializer.  If that's the
7542    situation we're in, update DECL accordingly.  */
7543
7544 static void
7545 maybe_deduce_size_from_array_init (decl, init)
7546      tree decl;
7547      tree init;
7548 {
7549   tree type = TREE_TYPE (decl);
7550
7551   if (TREE_CODE (type) == ARRAY_TYPE
7552       && TYPE_DOMAIN (type) == NULL_TREE
7553       && TREE_CODE (decl) != TYPE_DECL)
7554     {
7555       /* do_default is really a C-ism to deal with tentative definitions.
7556          But let's leave it here to ease the eventual merge.  */
7557       int do_default = !DECL_EXTERNAL (decl);
7558       tree initializer = init ? init : DECL_INITIAL (decl);
7559       int failure = complete_array_type (type, initializer, do_default);
7560
7561       if (failure == 1)
7562         cp_error ("initializer fails to determine size of `%D'", decl);
7563
7564       if (failure == 2)
7565         {
7566           if (do_default)
7567             cp_error ("array size missing in `%D'", decl);
7568           /* If a `static' var's size isn't known, make it extern as
7569              well as static, so it does not get allocated.  If it's not
7570              `static', then don't mark it extern; finish_incomplete_decl
7571              will give it a default size and it will get allocated.  */
7572           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7573             DECL_EXTERNAL (decl) = 1;
7574         }
7575
7576       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7577           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7578                               integer_zero_node))
7579         cp_error ("zero-size array `%D'", decl);
7580
7581       layout_decl (decl, 0);
7582     }
7583 }
7584
7585 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7586    any appropriate error messages regarding the layout.  */
7587
7588 static void
7589 layout_var_decl (decl)
7590      tree decl;
7591 {
7592   tree type = TREE_TYPE (decl);
7593 #if 0
7594   tree ttype = target_type (type);
7595 #endif
7596
7597   /* If we haven't already layed out this declaration, do so now.
7598      Note that we must not call complete type for an external object
7599      because it's type might involve templates that we are not
7600      supposed to isntantiate yet.  (And it's perfectly legal to say
7601      `extern X x' for some incomplete type `X'.)  */
7602   if (!DECL_EXTERNAL (decl))
7603     complete_type (type);
7604   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7605     layout_decl (decl, 0);
7606
7607   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7608     {
7609       /* An automatic variable with an incomplete type: that is an error.
7610          Don't talk about array types here, since we took care of that
7611          message in grokdeclarator.  */
7612       cp_error ("storage size of `%D' isn't known", decl);
7613       TREE_TYPE (decl) = error_mark_node;
7614     }
7615 #if 0
7616   /* Keep this code around in case we later want to control debug info
7617      based on whether a type is "used".  (jason 1999-11-11) */
7618
7619   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7620     /* Let debugger know it should output info for this type.  */
7621     note_debug_info_needed (ttype);
7622
7623   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7624     note_debug_info_needed (DECL_CONTEXT (decl));
7625 #endif
7626
7627   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7628       && DECL_SIZE (decl) != NULL_TREE
7629       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7630     {
7631       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7632         constant_expression_warning (DECL_SIZE (decl));
7633       else
7634         cp_error ("storage size of `%D' isn't constant", decl);
7635     }
7636 }
7637
7638 /* If a local static variable is declared in an inline function, or if
7639    we have a weak definition, we must endeavor to create only one
7640    instance of the variable at link-time.  */
7641
7642 static void
7643 maybe_commonize_var (decl)
7644      tree decl;
7645 {
7646   /* Static data in a function with comdat linkage also has comdat
7647      linkage.  */
7648   if (TREE_STATIC (decl)
7649       /* Don't mess with __FUNCTION__.  */
7650       && ! DECL_ARTIFICIAL (decl)
7651       && current_function_decl
7652       && DECL_CONTEXT (decl) == current_function_decl
7653       && (DECL_THIS_INLINE (current_function_decl)
7654           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7655       && TREE_PUBLIC (current_function_decl))
7656     {
7657       /* Rather than try to get this right with inlining, we suppress
7658          inlining of such functions.  */
7659       current_function_cannot_inline
7660         = "function with static variable cannot be inline";
7661
7662       /* If flag_weak, we don't need to mess with this, as we can just
7663          make the function weak, and let it refer to its unique local
7664          copy.  This works because we don't allow the function to be
7665          inlined.  */
7666       if (! flag_weak)
7667         {
7668           if (DECL_INTERFACE_KNOWN (current_function_decl))
7669             {
7670               TREE_PUBLIC (decl) = 1;
7671               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7672             }
7673           else if (DECL_INITIAL (decl) == NULL_TREE
7674                    || DECL_INITIAL (decl) == error_mark_node)
7675             {
7676               TREE_PUBLIC (decl) = 1;
7677               DECL_COMMON (decl) = 1;
7678             }
7679           /* else we lose. We can only do this if we can use common,
7680              which we can't if it has been initialized.  */
7681
7682           if (TREE_PUBLIC (decl))
7683             DECL_ASSEMBLER_NAME (decl)
7684               = build_static_name (current_function_decl, DECL_NAME (decl));
7685           else
7686             {
7687               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7688               cp_warning_at ("  you can work around this by removing the initializer", decl);
7689             }
7690         }
7691     }
7692   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7693     /* Set it up again; we might have set DECL_INITIAL since the last
7694        time.  */
7695     comdat_linkage (decl);
7696 }
7697
7698 /* Issue an error message if DECL is an uninitialized const variable.  */
7699
7700 static void
7701 check_for_uninitialized_const_var (decl)
7702      tree decl;
7703 {
7704   tree type = TREE_TYPE (decl);
7705
7706   /* ``Unless explicitly declared extern, a const object does not have
7707      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7708      7.1.6 */
7709   if (TREE_CODE (decl) == VAR_DECL
7710       && TREE_CODE (type) != REFERENCE_TYPE
7711       && CP_TYPE_CONST_P (type)
7712       && !TYPE_NEEDS_CONSTRUCTING (type)
7713       && !DECL_INITIAL (decl))
7714     cp_error ("uninitialized const `%D'", decl);
7715 }
7716
7717 /* Verify INIT (the initializer for DECL), and record the
7718    initialization in DECL_INITIAL, if appropriate.  Returns a new
7719    value for INIT.  */
7720
7721 static tree
7722 check_initializer (decl, init)
7723      tree decl;
7724      tree init;
7725 {
7726   tree type;
7727
7728   if (TREE_CODE (decl) == FIELD_DECL)
7729     return init;
7730
7731   type = TREE_TYPE (decl);
7732
7733   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7734   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7735     init = NULL_TREE;
7736
7737   /* Check the initializer.  */
7738   if (init)
7739     {
7740       /* Things that are going to be initialized need to have complete
7741          type.  */
7742       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7743
7744       if (type == error_mark_node)
7745         /* We will have already complained.  */
7746         init = NULL_TREE;
7747       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7748         {
7749           cp_error ("variable-sized object `%D' may not be initialized", decl);
7750           init = NULL_TREE;
7751         }
7752       else if (TREE_CODE (type) == ARRAY_TYPE
7753                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7754         {
7755           cp_error ("elements of array `%#D' have incomplete type", decl);
7756           init = NULL_TREE;
7757         }
7758       else if (!COMPLETE_TYPE_P (type))
7759         {
7760           cp_error ("`%D' has incomplete type", decl);
7761           TREE_TYPE (decl) = error_mark_node;
7762           init = NULL_TREE;
7763         }
7764     }
7765
7766   if (TREE_CODE (decl) == CONST_DECL)
7767     {
7768       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7769
7770       DECL_INITIAL (decl) = init;
7771
7772       /* This will keep us from needing to worry about our obstacks.  */
7773       my_friendly_assert (init != NULL_TREE, 149);
7774       init = NULL_TREE;
7775     }
7776   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7777     {
7778       if (TREE_STATIC (decl))
7779         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7780       grok_reference_init (decl, type, init);
7781       init = NULL_TREE;
7782     }
7783   else if (init)
7784     {
7785       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7786         {
7787           if (TREE_CODE (type) == ARRAY_TYPE)
7788             init = digest_init (type, init, (tree *) 0);
7789           else if (TREE_CODE (init) == CONSTRUCTOR
7790                    && TREE_HAS_CONSTRUCTOR (init))
7791             {
7792               if (TYPE_NON_AGGREGATE_CLASS (type))
7793                 {
7794                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7795                             decl);
7796                   init = error_mark_node;
7797                 }
7798               else
7799                 goto dont_use_constructor;
7800             }
7801         }
7802       else
7803         {
7804         dont_use_constructor:
7805           if (TREE_CODE (init) != TREE_VEC)
7806             init = store_init_value (decl, init);
7807         }
7808
7809       if (init)
7810         /* We must hide the initializer so that expand_decl
7811            won't try to do something it does not understand.  */
7812         init = obscure_complex_init (decl, init);
7813     }
7814   else if (DECL_EXTERNAL (decl))
7815     ;
7816   else if (TYPE_P (type)
7817            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7818     {
7819       tree core_type = strip_array_types (type);
7820
7821       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7822         {
7823           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7824             cp_error ("structure `%D' with uninitialized const members", decl);
7825           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7826             cp_error ("structure `%D' with uninitialized reference members",
7827                       decl);
7828         }
7829
7830       check_for_uninitialized_const_var (decl);
7831
7832       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7833         init = obscure_complex_init (decl, NULL_TREE);
7834
7835     }
7836   else
7837     check_for_uninitialized_const_var (decl);
7838
7839   return init;
7840 }
7841
7842 /* If DECL is not a local variable, give it RTL.  */
7843
7844 static void
7845 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7846      tree decl;
7847      tree init;
7848      const char *asmspec;
7849 {
7850   int toplev = toplevel_bindings_p ();
7851   int defer_p;
7852
7853   /* Handle non-variables up front.  */
7854   if (TREE_CODE (decl) != VAR_DECL)
7855     {
7856       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7857       return;
7858     }
7859
7860   /* If we see a class member here, it should be a static data
7861      member.  */
7862   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7863     {
7864       my_friendly_assert (TREE_STATIC (decl), 19990828);
7865       /* An in-class declaration of a static data member should be
7866          external; it is only a declaration, and not a definition.  */
7867       if (init == NULL_TREE)
7868         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7869     }
7870
7871   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7872   if (asmspec)
7873     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7874
7875   /* We don't create any RTL for local variables.  */
7876   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7877     return;
7878
7879   /* We defer emission of local statics until the corresponding
7880      DECL_STMT is expanded.  */
7881   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7882
7883   /* We try to defer namespace-scope static constants so that they are
7884      not emitted into the object file unncessarily.  */
7885   if (!DECL_VIRTUAL_P (decl)
7886       && TREE_READONLY (decl)
7887       && DECL_INITIAL (decl) != NULL_TREE
7888       && DECL_INITIAL (decl) != error_mark_node
7889       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7890       && toplev
7891       && !TREE_PUBLIC (decl))
7892     {
7893       /* Fool with the linkage according to #pragma interface.  */
7894       if (!interface_unknown)
7895         {
7896           TREE_PUBLIC (decl) = 1;
7897           DECL_EXTERNAL (decl) = interface_only;
7898         }
7899
7900       defer_p = 1;
7901     }
7902
7903   /* If we're deferring the variable, just make RTL.  Do not actually
7904      emit the variable.  */
7905   if (defer_p)
7906     make_decl_rtl (decl, asmspec, toplev);
7907   /* If we're not deferring, go ahead and assemble the variable.  */
7908   else
7909     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7910 }
7911
7912 /* The old ARM scoping rules injected variables declared in the
7913    initialization statement of a for-statement into the surrounding
7914    scope.  We support this usage, in order to be backward-compatible.
7915    DECL is a just-declared VAR_DECL; if necessary inject its
7916    declaration into the surrounding scope.  */
7917
7918 void
7919 maybe_inject_for_scope_var (decl)
7920      tree decl;
7921 {
7922   if (!DECL_NAME (decl))
7923     return;
7924
7925   if (current_binding_level->is_for_scope)
7926     {
7927       struct binding_level *outer
7928         = current_binding_level->level_chain;
7929
7930       /* Check to see if the same name is already bound at the outer
7931          level, either because it was directly declared, or because a
7932          dead for-decl got preserved.  In either case, the code would
7933          not have been valid under the ARM scope rules, so clear
7934          is_for_scope for the current_binding_level.
7935
7936          Otherwise, we need to preserve the temp slot for decl to last
7937          into the outer binding level.  */
7938
7939       tree outer_binding
7940         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7941
7942       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7943           && (TREE_CODE (BINDING_VALUE (outer_binding))
7944               == VAR_DECL)
7945           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7946         {
7947           BINDING_VALUE (outer_binding)
7948             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7949           current_binding_level->is_for_scope = 0;
7950         }
7951       else if (DECL_IN_MEMORY_P (decl))
7952         preserve_temp_slots (DECL_RTL (decl));
7953     }
7954 }
7955
7956 /* Generate code to initialize DECL (a local variable).  */
7957
7958 void
7959 initialize_local_var (decl, init, flags)
7960      tree decl;
7961      tree init;
7962      int flags;
7963 {
7964   tree type = TREE_TYPE (decl);
7965
7966   /* If the type is bogus, don't bother initializing the variable.  */
7967   if (type == error_mark_node)
7968     return;
7969
7970   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7971     {
7972       /* If we used it already as memory, it must stay in memory.  */
7973       DECL_INITIAL (decl) = NULL_TREE;
7974       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7975     }
7976
7977   /* Local statics are handled differently from ordinary automatic
7978      variables.  */
7979   if (TREE_STATIC (decl))
7980     {
7981       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7982           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7983         expand_static_init (decl, init);
7984       return;
7985     }
7986
7987   if (DECL_SIZE (decl) && type != error_mark_node)
7988     {
7989       int already_used;
7990
7991       /* Compute and store the initial value.  */
7992       already_used = TREE_USED (decl) || TREE_USED (type);
7993
7994       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7995         {
7996           int saved_stmts_are_full_exprs_p;
7997
7998           my_friendly_assert (building_stmt_tree (), 20000906);
7999           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8000           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8001           finish_expr_stmt (build_aggr_init (decl, init, flags));
8002           current_stmt_tree ()->stmts_are_full_exprs_p =
8003             saved_stmts_are_full_exprs_p;
8004         }
8005
8006       /* Set this to 0 so we can tell whether an aggregate which was
8007          initialized was ever used.  Don't do this if it has a
8008          destructor, so we don't complain about the 'resource
8009          allocation is initialization' idiom.  Now set
8010          attribute((unused)) on types so decls of that type will be
8011          marked used. (see TREE_USED, above.)  */
8012       if (TYPE_NEEDS_CONSTRUCTING (type)
8013           && ! already_used
8014           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8015           && DECL_NAME (decl))
8016         TREE_USED (decl) = 0;
8017       else if (already_used)
8018         TREE_USED (decl) = 1;
8019     }
8020 }
8021
8022 /* Generate code to destroy DECL (a local variable).  */
8023
8024 static void
8025 destroy_local_var (decl)
8026      tree decl;
8027 {
8028   tree type = TREE_TYPE (decl);
8029   tree cleanup;
8030
8031   /* Only variables get cleaned up.  */
8032   if (TREE_CODE (decl) != VAR_DECL)
8033     return;
8034
8035   /* And only things with destructors need cleaning up.  */
8036   if (type == error_mark_node
8037       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8038     return;
8039
8040   if (TREE_CODE (decl) == VAR_DECL &&
8041       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8042     /* We don't clean up things that aren't defined in this
8043        translation unit, or that need a static cleanup.  The latter
8044        are handled by finish_file.  */
8045     return;
8046
8047   /* Compute the cleanup.  */
8048   cleanup = maybe_build_cleanup (decl);
8049
8050   /* Record the cleanup required for this declaration.  */
8051   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8052       && cleanup)
8053     finish_decl_cleanup (decl, cleanup);
8054 }
8055
8056 /* Finish processing of a declaration;
8057    install its line number and initial value.
8058    If the length of an array type is not known before,
8059    it must be determined now, from the initial value, or it is an error.
8060
8061    INIT holds the value of an initializer that should be allowed to escape
8062    the normal rules.
8063
8064    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8065    if the (init) syntax was used.  */
8066
8067 void
8068 cp_finish_decl (decl, init, asmspec_tree, flags)
8069      tree decl, init;
8070      tree asmspec_tree;
8071      int flags;
8072 {
8073   register tree type;
8074   tree ttype = NULL_TREE;
8075   const char *asmspec = NULL;
8076   int was_readonly = 0;
8077
8078   if (! decl)
8079     {
8080       if (init)
8081         error ("assignment (not initialization) in declaration");
8082       return;
8083     }
8084
8085   /* If a name was specified, get the string.  */
8086   if (asmspec_tree)
8087       asmspec = TREE_STRING_POINTER (asmspec_tree);
8088
8089   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8090     {
8091       cp_error ("cannot initialize `%D' to namespace `%D'",
8092                 decl, init);
8093       init = NULL_TREE;
8094     }
8095
8096   if (current_class_type
8097       && CP_DECL_CONTEXT (decl) == current_class_type
8098       && TYPE_BEING_DEFINED (current_class_type)
8099       && (DECL_INITIAL (decl) || init))
8100     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8101
8102   if (TREE_CODE (decl) == VAR_DECL
8103       && DECL_CONTEXT (decl)
8104       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8105       && DECL_CONTEXT (decl) != current_namespace
8106       && init)
8107     {
8108       /* Leave the namespace of the object. */
8109       pop_decl_namespace ();
8110     }
8111
8112   type = TREE_TYPE (decl);
8113
8114   if (type == error_mark_node)
8115     return;
8116
8117   /* Add this declaration to the statement-tree.  */
8118   if (building_stmt_tree ()
8119       && at_function_scope_p ()
8120       && TREE_CODE (decl) != RESULT_DECL)
8121     add_decl_stmt (decl);
8122
8123   if (TYPE_HAS_MUTABLE_P (type))
8124     TREE_READONLY (decl) = 0;
8125
8126   if (processing_template_decl)
8127     {
8128       if (init && DECL_INITIAL (decl))
8129         DECL_INITIAL (decl) = init;
8130       goto finish_end0;
8131     }
8132
8133   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8134   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8135
8136   /* Take care of TYPE_DECLs up front.  */
8137   if (TREE_CODE (decl) == TYPE_DECL)
8138     {
8139       if (init && DECL_INITIAL (decl))
8140         {
8141           /* typedef foo = bar; store the type of bar as the type of foo.  */
8142           TREE_TYPE (decl) = type = TREE_TYPE (init);
8143           DECL_INITIAL (decl) = init = NULL_TREE;
8144         }
8145       if (type != error_mark_node
8146           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8147         {
8148           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8149             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8150           set_identifier_type_value (DECL_NAME (decl), type);
8151           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8152         }
8153       GNU_xref_decl (current_function_decl, decl);
8154
8155       /* If we have installed this as the canonical typedef for this
8156          type, and that type has not been defined yet, delay emitting
8157          the debug information for it, as we will emit it later.  */
8158       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8159           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8160         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8161
8162       rest_of_decl_compilation (decl, NULL_PTR,
8163                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8164       goto finish_end;
8165     }
8166
8167   if (TREE_CODE (decl) != FUNCTION_DECL)
8168     ttype = target_type (type);
8169
8170   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8171       && TYPE_NEEDS_CONSTRUCTING (type))
8172     {
8173       /* Currently, GNU C++ puts constants in text space, making them
8174          impossible to initialize.  In the future, one would hope for
8175          an operating system which understood the difference between
8176          initialization and the running of a program.  */
8177       was_readonly = 1;
8178       TREE_READONLY (decl) = 0;
8179     }
8180
8181   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8182     {
8183       /* This must override the asm specifier which was placed by
8184          grokclassfn.  Lay this out fresh.  */
8185       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8186       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8187       make_decl_rtl (decl, asmspec, 0);
8188     }
8189
8190   /* Deduce size of array from initialization, if not already known.  */
8191   maybe_deduce_size_from_array_init (decl, init);
8192   init = check_initializer (decl, init);
8193
8194   GNU_xref_decl (current_function_decl, decl);
8195
8196   if (TREE_CODE (decl) == VAR_DECL)
8197     layout_var_decl (decl);
8198
8199   /* Output the assembler code and/or RTL code for variables and functions,
8200      unless the type is an undefined structure or union.
8201      If not, it will get done when the type is completed.  */
8202   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8203       || TREE_CODE (decl) == RESULT_DECL)
8204     {
8205       if (TREE_CODE (decl) == VAR_DECL)
8206         maybe_commonize_var (decl);
8207
8208       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8209
8210       if (TREE_CODE (type) == FUNCTION_TYPE
8211           || TREE_CODE (type) == METHOD_TYPE)
8212         abstract_virtuals_error (decl,
8213                                  strip_array_types (TREE_TYPE (type)));
8214       else
8215         abstract_virtuals_error (decl, strip_array_types (type));
8216
8217       if (TREE_CODE (decl) == FUNCTION_DECL)
8218         ;
8219       else if (DECL_EXTERNAL (decl)
8220                && ! (DECL_LANG_SPECIFIC (decl)
8221                      && DECL_NOT_REALLY_EXTERN (decl)))
8222         {
8223           if (init)
8224             DECL_INITIAL (decl) = init;
8225         }
8226       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8227         {
8228           /* This is a local declaration.  */
8229           if (doing_semantic_analysis_p ())
8230             maybe_inject_for_scope_var (decl);
8231           /* Initialize the local variable.  But, if we're building a
8232              statement-tree, we'll do the initialization when we
8233              expand the tree.  */
8234           if (processing_template_decl)
8235             {
8236               if (init || DECL_INITIAL (decl) == error_mark_node)
8237                 DECL_INITIAL (decl) = init;
8238             }
8239           else
8240             {
8241               /* If we're not building RTL, then we need to do so
8242                  now.  */
8243               my_friendly_assert (building_stmt_tree (), 20000906);
8244               /* Initialize the variable.  */
8245               initialize_local_var (decl, init, flags);
8246               /* Clean up the variable.  */
8247               destroy_local_var (decl);
8248             }
8249         }
8250       else if (TREE_STATIC (decl) && type != error_mark_node)
8251         {
8252           /* Cleanups for static variables are handled by `finish_file'.  */
8253           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8254               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8255             expand_static_init (decl, init);
8256         }
8257     finish_end0:
8258
8259       /* Undo call to `pushclass' that was done in `start_decl'
8260          due to initialization of qualified member variable.
8261          I.e., Foo::x = 10;  */
8262       {
8263         tree context = CP_DECL_CONTEXT (decl);
8264         if (context
8265             && TYPE_P (context)
8266             && (TREE_CODE (decl) == VAR_DECL
8267                 /* We also have a pushclass done that we need to undo here
8268                    if we're at top level and declare a method.  */
8269                 || TREE_CODE (decl) == FUNCTION_DECL)
8270             /* If size hasn't been set, we're still defining it,
8271                and therefore inside the class body; don't pop
8272                the binding level..  */
8273             && COMPLETE_TYPE_P (context)
8274             && context == current_class_type)
8275           pop_nested_class ();
8276       }
8277     }
8278
8279  finish_end:
8280
8281   if (was_readonly)
8282     TREE_READONLY (decl) = 1;
8283 }
8284
8285 /* This is here for a midend callback from c-common.c */
8286
8287 void
8288 finish_decl (decl, init, asmspec_tree)
8289      tree decl, init;
8290      tree asmspec_tree;
8291 {
8292   cp_finish_decl (decl, init, asmspec_tree, 0);
8293 }
8294
8295 /* Returns a declaration for a VAR_DECL as if:
8296
8297      extern "C" TYPE NAME;
8298
8299    had been seen.  Used to create compiler-generated global
8300    variables.  */
8301
8302 tree
8303 declare_global_var (name, type)
8304      tree name;
8305      tree type;
8306 {
8307   tree decl;
8308
8309   push_to_top_level ();
8310   decl = build_decl (VAR_DECL, name, type);
8311   TREE_PUBLIC (decl) = 1;
8312   DECL_EXTERNAL (decl) = 1;
8313   DECL_ARTIFICIAL (decl) = 1;
8314   pushdecl (decl);
8315   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8316   pop_from_top_level ();
8317
8318   return decl;
8319 }
8320
8321 /* Returns a pointer to the `atexit' function.  Note that if
8322    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8323    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8324
8325 static tree
8326 get_atexit_node ()
8327 {
8328   tree atexit_fndecl;
8329   tree arg_types;
8330   tree fn_type;
8331   tree fn_ptr_type;
8332   const char *name;
8333
8334   if (atexit_node)
8335     return atexit_node;
8336
8337   if (flag_use_cxa_atexit)
8338     {
8339       /* The declaration for `__cxa_atexit' is:
8340
8341            int __cxa_atexit (void (*)(void *), void *, void *)
8342
8343          We build up the argument types and then then function type
8344          itself.  */
8345
8346       /* First, build the pointer-to-function type for the first
8347          argument.  */
8348       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8349       fn_type = build_function_type (void_type_node, arg_types);
8350       fn_ptr_type = build_pointer_type (fn_type);
8351       /* Then, build the rest of the argument types.  */
8352       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8353       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8354       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8355       /* And the final __cxa_atexit type.  */
8356       fn_type = build_function_type (integer_type_node, arg_types);
8357       fn_ptr_type = build_pointer_type (fn_type);
8358       name = "__cxa_atexit";
8359     }
8360   else
8361     {
8362       /* The declaration for `atexit' is:
8363
8364            int atexit (void (*)());
8365
8366          We build up the argument types and then then function type
8367          itself.  */
8368       fn_type = build_function_type (void_type_node, void_list_node);
8369       fn_ptr_type = build_pointer_type (fn_type);
8370       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8371       /* Build the final atexit type.  */
8372       fn_type = build_function_type (integer_type_node, arg_types);
8373       name = "atexit";
8374     }
8375
8376   /* Now, build the function declaration.  */
8377   push_lang_context (lang_name_c);
8378   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8379   mark_used (atexit_fndecl);
8380   pop_lang_context ();
8381   atexit_node = default_conversion (atexit_fndecl);
8382
8383   return atexit_node;
8384 }
8385
8386 /* Returns the __dso_handle VAR_DECL.  */
8387
8388 static tree
8389 get_dso_handle_node ()
8390 {
8391   if (dso_handle_node)
8392     return dso_handle_node;
8393
8394   /* Declare the variable.  */
8395   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8396                                         ptr_type_node);
8397
8398   return dso_handle_node;
8399 }
8400
8401 /* Begin a new function with internal linkage whose job will be simply
8402    to destroy some particular variable.  */
8403
8404 static tree
8405 start_cleanup_fn ()
8406 {
8407   static int counter = 0;
8408   int old_interface_unknown = interface_unknown;
8409   char name[32];
8410   tree parmtypes;
8411   tree fntype;
8412   tree fndecl;
8413
8414   push_to_top_level ();
8415
8416   /* No need to mangle this.  */
8417   push_lang_context (lang_name_c);
8418
8419   interface_unknown = 1;
8420
8421   /* Build the parameter-types.  */
8422   parmtypes = void_list_node;
8423   /* Functions passed to __cxa_atexit take an additional parameter.
8424      We'll just ignore it.  After we implement the new calling
8425      convention for destructors, we can eliminate the use of
8426      additional cleanup functions entirely in the -fnew-abi case.  */
8427   if (flag_use_cxa_atexit)
8428     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8429   /* Build the function type itself.  */
8430   fntype = build_function_type (void_type_node, parmtypes);
8431   /* Build the name of the function.  */
8432   sprintf (name, "__tcf_%d", counter++);
8433   /* Build the function declaration.  */
8434   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8435   /* It's a function with internal linkage, generated by the
8436      compiler.  */
8437   TREE_PUBLIC (fndecl) = 0;
8438   DECL_ARTIFICIAL (fndecl) = 1;
8439   /* Make the function `inline' so that it is only emitted if it is
8440      actually needed.  It is unlikely that it will be inlined, since
8441      it is only called via a function pointer, but we avoid unncessary
8442      emissions this way.  */
8443   DECL_INLINE (fndecl) = 1;
8444   /* Build the parameter.  */
8445   if (flag_use_cxa_atexit)
8446     {
8447       tree parmdecl;
8448
8449       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8450       DECL_CONTEXT (parmdecl) = fndecl;
8451       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8452       TREE_USED (parmdecl) = 1;
8453       DECL_ARGUMENTS (fndecl) = parmdecl;
8454     }
8455
8456   pushdecl (fndecl);
8457   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8458   do_pushlevel ();
8459
8460   interface_unknown = old_interface_unknown;
8461
8462   pop_lang_context ();
8463
8464   return current_function_decl;
8465 }
8466
8467 /* Finish the cleanup function begun by start_cleanup_fn.  */
8468
8469 static void
8470 end_cleanup_fn ()
8471 {
8472   do_poplevel ();
8473
8474   expand_body (finish_function (0));
8475
8476   pop_from_top_level ();
8477 }
8478
8479 /* Generate code to handle the destruction of DECL, an object with
8480    static storage duration.  */
8481
8482 void
8483 register_dtor_fn (decl)
8484      tree decl;
8485 {
8486   tree cleanup;
8487   tree compound_stmt;
8488   tree args;
8489   tree fcall;
8490
8491   int saved_flag_access_control;
8492
8493   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8494     return;
8495
8496   /* Call build_cleanup before we enter the anonymous function so that
8497      any access checks will be done relative to the current scope,
8498      rather than the scope of the anonymous function.  */
8499   build_cleanup (decl);
8500
8501   /* Now start the function.  */
8502   cleanup = start_cleanup_fn ();
8503
8504   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8505      to the original function, rather than the anonymous one.  That
8506      will make the back-end think that nested functions are in use,
8507      which causes confusion.  */
8508   saved_flag_access_control = flag_access_control;
8509   flag_access_control = 0;
8510   fcall = build_cleanup (decl);
8511   flag_access_control = saved_flag_access_control;
8512
8513   /* Create the body of the anonymous function.  */
8514   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8515   finish_expr_stmt (fcall);
8516   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8517   end_cleanup_fn ();
8518
8519   /* Call atexit with the cleanup function.  */
8520   mark_addressable (cleanup);
8521   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8522   if (flag_use_cxa_atexit)
8523     {
8524       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8525       args = tree_cons (NULL_TREE, null_pointer_node, args);
8526       args = tree_cons (NULL_TREE, cleanup, args);
8527     }
8528   else
8529     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8530   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8531 }
8532
8533 void
8534 expand_static_init (decl, init)
8535      tree decl;
8536      tree init;
8537 {
8538   tree oldstatic = value_member (decl, static_aggregates);
8539
8540   if (oldstatic)
8541     {
8542       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8543         cp_error ("multiple initializations given for `%D'", decl);
8544     }
8545   else if (! toplevel_bindings_p ())
8546     {
8547       /* Emit code to perform this initialization but once.  */
8548       tree if_stmt;
8549       tree then_clause;
8550       tree assignment;
8551       tree guard;
8552       tree guard_init;
8553
8554       /* Emit code to perform this initialization but once.  This code
8555          looks like:
8556
8557            static int guard = 0;
8558            if (!guard) {
8559              // Do initialization.
8560              guard = 1;
8561              // Register variable for destruction at end of program.
8562            }
8563
8564          Note that the `temp' variable is only set to 1 *after* the
8565          initialization is complete.  This ensures that an exception,
8566          thrown during the construction, will cause the variable to
8567          reinitialized when we pass through this code again, as per:
8568
8569            [stmt.dcl]
8570
8571            If the initialization exits by throwing an exception, the
8572            initialization is not complete, so it will be tried again
8573            the next time control enters the declaration.
8574
8575          In theory, this process should be thread-safe, too; multiple
8576          threads should not be able to initialize the variable more
8577          than once.  We don't yet attempt to ensure thread-safety.  */
8578
8579       /* Create the guard variable.  */
8580       guard = get_guard (decl);
8581
8582       /* Begin the conditional initialization.  */
8583       if_stmt = begin_if_stmt ();
8584       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8585       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8586
8587       /* Do the initialization itself.  */
8588       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8589           || (init && TREE_CODE (init) == TREE_LIST))
8590         assignment = build_aggr_init (decl, init, 0);
8591       else if (init)
8592         /* The initialization we're doing here is just a bitwise
8593            copy.  */
8594         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8595       else
8596         assignment = NULL_TREE;
8597
8598       /* Once the assignment is complete, set TEMP to 1.  Since the
8599          construction of the static object is complete at this point,
8600          we want to make sure TEMP is set to 1 even if a temporary
8601          constructed during the initialization throws an exception
8602          when it is destroyed.  So, we combine the initialization and
8603          the assignment to TEMP into a single expression, ensuring
8604          that when we call finish_expr_stmt the cleanups will not be
8605          run until after TEMP is set to 1.  */
8606       guard_init = set_guard (guard);
8607       if (assignment)
8608         {
8609           assignment = tree_cons (NULL_TREE, assignment,
8610                                   build_tree_list (NULL_TREE,
8611                                                    guard_init));
8612           assignment = build_compound_expr (assignment);
8613         }
8614       else
8615         assignment = guard_init;
8616       finish_expr_stmt (assignment);
8617
8618       /* Use atexit to register a function for destroying this static
8619          variable.  */
8620       register_dtor_fn (decl);
8621
8622       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8623       finish_then_clause (if_stmt);
8624       finish_if_stmt ();
8625     }
8626   else
8627     static_aggregates = tree_cons (init, decl, static_aggregates);
8628 }
8629
8630 /* Finish the declaration of a catch-parameter.  */
8631
8632 tree
8633 start_handler_parms (declspecs, declarator)
8634      tree declspecs;
8635      tree declarator;
8636 {
8637   tree decl;
8638   if (declspecs)
8639     {
8640       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8641                              1, NULL_TREE);
8642       if (decl == NULL_TREE)
8643         error ("invalid catch parameter");
8644     }
8645   else
8646     decl = NULL_TREE;
8647
8648   return decl;
8649 }
8650
8651 \f
8652 /* Make TYPE a complete type based on INITIAL_VALUE.
8653    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8654    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8655
8656 int
8657 complete_array_type (type, initial_value, do_default)
8658      tree type, initial_value;
8659      int do_default;
8660 {
8661   register tree maxindex = NULL_TREE;
8662   int value = 0;
8663
8664   if (initial_value)
8665     {
8666       /* An array of character type can be initialized from a
8667          brace-enclosed string constant.  */
8668       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8669           && TREE_CODE (initial_value) == CONSTRUCTOR
8670           && CONSTRUCTOR_ELTS (initial_value)
8671           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8672               == STRING_CST)
8673           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8674         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8675
8676       /* Note MAXINDEX is really the maximum index, one less than the
8677          size.  */
8678       if (TREE_CODE (initial_value) == STRING_CST)
8679         {
8680           int eltsize
8681             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8682           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8683                                    / eltsize) - 1, 0);
8684         }
8685       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8686         {
8687           tree elts = CONSTRUCTOR_ELTS (initial_value);
8688
8689           maxindex = ssize_int (-1);
8690           for (; elts; elts = TREE_CHAIN (elts))
8691             {
8692               if (TREE_PURPOSE (elts))
8693                 maxindex = TREE_PURPOSE (elts);
8694               else
8695                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8696             }
8697           maxindex = copy_node (maxindex);
8698         }
8699       else
8700         {
8701           /* Make an error message unless that happened already.  */
8702           if (initial_value != error_mark_node)
8703             value = 1;
8704           else
8705             initial_value = NULL_TREE;
8706
8707           /* Prevent further error messages.  */
8708           maxindex = build_int_2 (0, 0);
8709         }
8710     }
8711
8712   if (!maxindex)
8713     {
8714       if (do_default)
8715         maxindex = build_int_2 (0, 0);
8716       value = 2;
8717     }
8718
8719   if (maxindex)
8720     {
8721       tree itype;
8722       tree domain;
8723
8724       domain = build_index_type (maxindex);
8725       TYPE_DOMAIN (type) = domain;
8726
8727       if (! TREE_TYPE (maxindex))
8728         TREE_TYPE (maxindex) = domain;
8729       if (initial_value)
8730         itype = TREE_TYPE (initial_value);
8731       else
8732         itype = NULL;
8733       if (itype && !TYPE_DOMAIN (itype))
8734         TYPE_DOMAIN (itype) = domain;
8735       /* The type of the main variant should never be used for arrays
8736          of different sizes.  It should only ever be completed with the
8737          size of the array.  */
8738       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8739         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8740     }
8741
8742   /* Lay out the type now that we can get the real answer.  */
8743
8744   layout_type (type);
8745
8746   return value;
8747 }
8748 \f
8749 /* Return zero if something is declared to be a member of type
8750    CTYPE when in the context of CUR_TYPE.  STRING is the error
8751    message to print in that case.  Otherwise, quietly return 1.  */
8752
8753 static int
8754 member_function_or_else (ctype, cur_type, flags)
8755      tree ctype, cur_type;
8756      enum overload_flags flags;
8757 {
8758   if (ctype && ctype != cur_type)
8759     {
8760       if (flags == DTOR_FLAG)
8761         cp_error ("destructor for alien class `%T' cannot be a member",
8762                   ctype);
8763       else
8764         cp_error ("constructor for alien class `%T' cannot be a member",
8765                   ctype);
8766       return 0;
8767     }
8768   return 1;
8769 }
8770 \f
8771 /* Subroutine of `grokdeclarator'.  */
8772
8773 /* Generate errors possibly applicable for a given set of specifiers.
8774    This is for ARM $7.1.2.  */
8775
8776 static void
8777 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8778      tree object;
8779      const char *type;
8780      int virtualp, quals, friendp, raises, inlinep;
8781 {
8782   if (virtualp)
8783     cp_error ("`%D' declared as a `virtual' %s", object, type);
8784   if (inlinep)
8785     cp_error ("`%D' declared as an `inline' %s", object, type);
8786   if (quals)
8787     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8788               object, type);
8789   if (friendp)
8790     cp_error_at ("`%D' declared as a friend", object);
8791   if (raises)
8792     cp_error_at ("`%D' declared with an exception specification", object);
8793 }
8794
8795 /* CTYPE is class type, or null if non-class.
8796    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8797    or METHOD_TYPE.
8798    DECLARATOR is the function's name.
8799    VIRTUALP is truthvalue of whether the function is virtual or not.
8800    FLAGS are to be passed through to `grokclassfn'.
8801    QUALS are qualifiers indicating whether the function is `const'
8802    or `volatile'.
8803    RAISES is a list of exceptions that this function can raise.
8804    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8805    not look, and -1 if we should not call `grokclassfn' at all.
8806
8807    Returns `NULL_TREE' if something goes wrong, after issuing
8808    applicable error messages.  */
8809
8810 static tree
8811 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8812             raises, check, friendp, publicp, inlinep, funcdef_flag,
8813             template_count, in_namespace)
8814      tree ctype, type;
8815      tree declarator;
8816      tree orig_declarator;
8817      int virtualp;
8818      enum overload_flags flags;
8819      tree quals, raises;
8820      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8821      tree in_namespace;
8822 {
8823   tree cname, decl;
8824   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8825   int has_default_arg = 0;
8826   tree t;
8827
8828   if (ctype)
8829     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8830       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8831   else
8832     cname = NULL_TREE;
8833
8834   if (raises)
8835     {
8836       type = build_exception_variant (type, raises);
8837     }
8838
8839   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8840   /* Propagate volatile out from type to decl. */
8841   if (TYPE_VOLATILE (type))
8842     TREE_THIS_VOLATILE (decl) = 1;
8843
8844   /* If this decl has namespace scope, set that up.  */
8845   if (in_namespace)
8846     set_decl_namespace (decl, in_namespace, friendp);
8847   else if (!ctype)
8848     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8849
8850   /* `main' and builtins have implicit 'C' linkage.  */
8851   if ((MAIN_NAME_P (declarator)
8852        || (IDENTIFIER_LENGTH (declarator) > 10
8853            && IDENTIFIER_POINTER (declarator)[0] == '_'
8854            && IDENTIFIER_POINTER (declarator)[1] == '_'
8855            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8856       && current_lang_name == lang_name_cplusplus
8857       && ctype == NULL_TREE
8858       /* NULL_TREE means global namespace.  */
8859       && DECL_CONTEXT (decl) == NULL_TREE)
8860     DECL_LANGUAGE (decl) = lang_c;
8861
8862   /* Should probably propagate const out from type to decl I bet (mrs).  */
8863   if (staticp)
8864     {
8865       DECL_STATIC_FUNCTION_P (decl) = 1;
8866       DECL_CONTEXT (decl) = ctype;
8867     }
8868
8869   if (ctype)
8870     DECL_CONTEXT (decl) = ctype;
8871
8872   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8873     {
8874       if (processing_template_decl)
8875         error ("cannot declare `::main' to be a template");
8876       if (inlinep)
8877         error ("cannot declare `::main' to be inline");
8878       if (!publicp)
8879         error ("cannot declare `::main' to be static");
8880       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8881                         integer_type_node))
8882         error ("`main' must return `int'");
8883       inlinep = 0;
8884       publicp = 1;
8885     }
8886
8887   /* Members of anonymous types and local classes have no linkage; make
8888      them internal.  */
8889   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8890                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8891     publicp = 0;
8892
8893   if (publicp)
8894     {
8895       /* [basic.link]: A name with no linkage (notably, the name of a class
8896          or enumeration declared in a local scope) shall not be used to
8897          declare an entity with linkage.
8898
8899          Only check this for public decls for now.  */
8900       t = no_linkage_check (TREE_TYPE (decl));
8901       if (t)
8902         {
8903           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8904             {
8905               if (DECL_EXTERN_C_P (decl))
8906                 /* Allow this; it's pretty common in C.  */;
8907               else
8908                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8909                             decl);
8910             }
8911           else
8912             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8913                         decl, t);
8914         }
8915     }
8916
8917   TREE_PUBLIC (decl) = publicp;
8918   if (! publicp)
8919     {
8920       DECL_INTERFACE_KNOWN (decl) = 1;
8921       DECL_NOT_REALLY_EXTERN (decl) = 1;
8922     }
8923
8924   if (inlinep)
8925     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8926
8927   DECL_EXTERNAL (decl) = 1;
8928   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8929     {
8930       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8931                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8932       quals = NULL_TREE;
8933     }
8934
8935   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8936     grok_op_properties (decl, virtualp, check < 0);
8937
8938   if (ctype && decl_function_context (decl))
8939     DECL_NO_STATIC_CHAIN (decl) = 1;
8940
8941   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8942     if (TREE_PURPOSE (t)
8943         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8944       {
8945         has_default_arg = 1;
8946         break;
8947       }
8948
8949   if (friendp
8950       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8951     {
8952       if (funcdef_flag)
8953         cp_error
8954           ("defining explicit specialization `%D' in friend declaration",
8955            orig_declarator);
8956       else
8957         {
8958           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8959             {
8960               /* Something like `template <class T> friend void f<T>()'.  */
8961               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8962                         orig_declarator);
8963               return NULL_TREE;
8964             }
8965
8966
8967           /* A friend declaration of the form friend void f<>().  Record
8968              the information in the TEMPLATE_ID_EXPR.  */
8969           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8970           DECL_TEMPLATE_INFO (decl)
8971             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8972                          TREE_OPERAND (orig_declarator, 1),
8973                          NULL_TREE);
8974
8975           if (has_default_arg)
8976             {
8977               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8978                         decl);
8979               return NULL_TREE;
8980             }
8981
8982           if (inlinep)
8983             {
8984               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8985                         decl);
8986               return NULL_TREE;
8987             }
8988         }
8989     }
8990
8991   if (has_default_arg)
8992     add_defarg_fn (decl);
8993
8994   /* Plain overloading: will not be grok'd by grokclassfn.  */
8995   if (! ctype && ! processing_template_decl
8996       && !DECL_EXTERN_C_P (decl)
8997       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8998     set_mangled_name_for_decl (decl);
8999
9000   if (funcdef_flag)
9001     /* Make the init_value nonzero so pushdecl knows this is not
9002        tentative.  error_mark_node is replaced later with the BLOCK.  */
9003     DECL_INITIAL (decl) = error_mark_node;
9004
9005   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9006     TREE_NOTHROW (decl) = 1;
9007
9008   /* Caller will do the rest of this.  */
9009   if (check < 0)
9010     return decl;
9011
9012   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9013     DECL_CONSTRUCTOR_P (decl) = 1;
9014
9015   /* Function gets the ugly name, field gets the nice one.  This call
9016      may change the type of the function (because of default
9017      parameters)!  */
9018   if (ctype != NULL_TREE)
9019     grokclassfn (ctype, decl, flags, quals);
9020
9021   decl = check_explicit_specialization (orig_declarator, decl,
9022                                         template_count,
9023                                         2 * (funcdef_flag != 0) +
9024                                         4 * (friendp != 0));
9025   if (decl == error_mark_node)
9026     return NULL_TREE;
9027
9028   if (ctype != NULL_TREE
9029       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9030       && check)
9031     {
9032       tree old_decl;
9033
9034       old_decl = check_classfn (ctype, decl);
9035
9036       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9037         /* Because grokfndecl is always supposed to return a
9038            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9039            here.  We depend on our callers to figure out that its
9040            really a template that's being returned.  */
9041         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9042
9043       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9044           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9045         {
9046           /* Remove the `this' parm added by grokclassfn.
9047              XXX Isn't this done in start_function, too?  */
9048           revert_static_member_fn (decl);
9049           last_function_parms = TREE_CHAIN (last_function_parms);
9050         }
9051       if (old_decl && DECL_ARTIFICIAL (old_decl))
9052         cp_error ("definition of implicitly-declared `%D'", old_decl);
9053
9054       if (old_decl)
9055         {
9056           /* Since we've smashed OLD_DECL to its
9057              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9058           if (TREE_CODE (decl) == TEMPLATE_DECL)
9059             decl = DECL_TEMPLATE_RESULT (decl);
9060
9061           /* Attempt to merge the declarations.  This can fail, in
9062              the case of some illegal specialization declarations.  */
9063           if (!duplicate_decls (decl, old_decl))
9064             cp_error ("no `%#D' member function declared in class `%T'",
9065                       decl, ctype);
9066           return old_decl;
9067         }
9068     }
9069
9070   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9071     return NULL_TREE;
9072
9073   if (ctype == NULL_TREE || check)
9074     return decl;
9075
9076   if (virtualp)
9077     {
9078       DECL_VIRTUAL_P (decl) = 1;
9079       if (DECL_VINDEX (decl) == NULL_TREE)
9080         DECL_VINDEX (decl) = error_mark_node;
9081       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9082     }
9083
9084   return decl;
9085 }
9086
9087 static tree
9088 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9089      tree type;
9090      tree declarator;
9091      RID_BIT_TYPE *specbits_in;
9092      int initialized;
9093      int constp;
9094      tree in_namespace;
9095 {
9096   tree decl;
9097   RID_BIT_TYPE specbits;
9098
9099   specbits = *specbits_in;
9100
9101   if (TREE_CODE (type) == OFFSET_TYPE)
9102     {
9103       /* If you declare a static member so that it
9104          can be initialized, the code will reach here.  */
9105       tree basetype = TYPE_OFFSET_BASETYPE (type);
9106       type = TREE_TYPE (type);
9107       decl = build_lang_decl (VAR_DECL, declarator, type);
9108       DECL_CONTEXT (decl) = basetype;
9109       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9110          templates.  */
9111       if (!uses_template_parms (decl))
9112         {
9113           if (flag_new_abi)
9114             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9115           else
9116             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9117                                                             declarator);
9118         }
9119     }
9120   else
9121     {
9122       tree context;
9123
9124       if (in_namespace)
9125         context = in_namespace;
9126       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9127         context = current_namespace;
9128       else
9129         context = NULL_TREE;
9130
9131       if (processing_template_decl && context)
9132         /* For global variables, declared in a template, we need the
9133            full lang_decl.  */
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         {
9144           if (flag_new_abi)
9145             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9146           else
9147             DECL_ASSEMBLER_NAME (decl)
9148               = build_static_name (context, declarator);
9149         }
9150     }
9151
9152   if (in_namespace)
9153     set_decl_namespace (decl, in_namespace, 0);
9154
9155   if (RIDBIT_SETP (RID_EXTERN, specbits))
9156     {
9157       DECL_THIS_EXTERN (decl) = 1;
9158       DECL_EXTERNAL (decl) = !initialized;
9159     }
9160
9161   /* In class context, static means one per class,
9162      public access, and static storage.  */
9163   if (DECL_CLASS_SCOPE_P (decl))
9164     {
9165       TREE_PUBLIC (decl) = 1;
9166       TREE_STATIC (decl) = 1;
9167       DECL_EXTERNAL (decl) = 0;
9168     }
9169   /* At top level, either `static' or no s.c. makes a definition
9170      (perhaps tentative), and absence of `static' makes it public.  */
9171   else if (toplevel_bindings_p ())
9172     {
9173       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9174                             && (DECL_THIS_EXTERN (decl) || ! constp));
9175       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9176     }
9177   /* Not at top level, only `static' makes a static definition.  */
9178   else
9179     {
9180       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9181       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9182     }
9183
9184   if (TREE_PUBLIC (decl))
9185     {
9186       /* [basic.link]: A name with no linkage (notably, the name of a class
9187          or enumeration declared in a local scope) shall not be used to
9188          declare an entity with linkage.
9189
9190          Only check this for public decls for now.  */
9191       tree t = no_linkage_check (TREE_TYPE (decl));
9192       if (t)
9193         {
9194           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9195             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9196           else
9197             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9198                         decl, t);
9199         }
9200     }
9201
9202   return decl;
9203 }
9204
9205 /* Create and return a canonical pointer to member function type, for
9206    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9207
9208 tree
9209 build_ptrmemfunc_type (type)
9210      tree type;
9211 {
9212   tree fields[4];
9213   tree t;
9214   tree u;
9215   tree unqualified_variant = NULL_TREE;
9216
9217   /* If a canonical type already exists for this type, use it.  We use
9218      this method instead of type_hash_canon, because it only does a
9219      simple equality check on the list of field members.  */
9220
9221   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9222     return t;
9223
9224   /* Make sure that we always have the unqualified pointer-to-member
9225      type first.  */
9226   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9227     unqualified_variant
9228       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9229
9230   t = make_aggr_type (RECORD_TYPE);
9231   /* Let the front-end know this is a pointer to member function...  */
9232   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9233   /* ... and not really an aggregate.  */
9234   SET_IS_AGGR_TYPE (t, 0);
9235
9236   if (!flag_new_abi)
9237     {
9238       u = make_aggr_type (UNION_TYPE);
9239       SET_IS_AGGR_TYPE (u, 0);
9240       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9241       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9242                               delta_type_node);
9243       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9244       TYPE_NAME (u) = NULL_TREE;
9245
9246       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9247                               delta_type_node);
9248       fields[1] = build_decl (FIELD_DECL, index_identifier,
9249                               delta_type_node);
9250       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9251       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9252     }
9253   else
9254     {
9255       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9256       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9257                               delta_type_node);
9258       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9259     }
9260
9261   /* Zap out the name so that the back-end will give us the debugging
9262      information for this anonymous RECORD_TYPE.  */
9263   TYPE_NAME (t) = NULL_TREE;
9264
9265   /* If this is not the unqualified form of this pointer-to-member
9266      type, set the TYPE_MAIN_VARIANT for this type to be the
9267      unqualified type.  Since they are actually RECORD_TYPEs that are
9268      not variants of each other, we must do this manually.  */
9269   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9270     {
9271       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9272       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9273       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9274       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9275     }
9276
9277   /* Cache this pointer-to-member type so that we can find it again
9278      later.  */
9279   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9280
9281   /* Seems to be wanted.  */
9282   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9283
9284   return t;
9285 }
9286
9287 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9288    Check to see that the definition is valid.  Issue appropriate error
9289    messages.  Return 1 if the definition is particularly bad, or 0
9290    otherwise.  */
9291
9292 int
9293 check_static_variable_definition (decl, type)
9294      tree decl;
9295      tree type;
9296 {
9297   /* Motion 10 at San Diego: If a static const integral data member is
9298      initialized with an integral constant expression, the initializer
9299      may appear either in the declaration (within the class), or in
9300      the definition, but not both.  If it appears in the class, the
9301      member is a member constant.  The file-scope definition is always
9302      required.  */
9303   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9304     {
9305       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9306                 type);
9307       /* If we just return the declaration, crashes will sometimes
9308          occur.  We therefore return void_type_node, as if this was a
9309          friend declaration, to cause callers to completely ignore
9310          this declaration.  */
9311       return 1;
9312     }
9313   else if (!CP_TYPE_CONST_P (type))
9314     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9315               decl);
9316   else if (pedantic && !INTEGRAL_TYPE_P (type))
9317     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9318
9319   return 0;
9320 }
9321
9322 /* Given the SIZE (i.e., number of elements) in an array, compute an
9323    appropriate index type for the array.  If non-NULL, NAME is the
9324    name of the thing being declared.  */
9325
9326 tree
9327 compute_array_index_type (name, size)
9328      tree name;
9329      tree size;
9330 {
9331   tree itype;
9332
9333   /* The size might be the result of a cast. */
9334   STRIP_TYPE_NOPS (size);
9335
9336   /* It might be a const variable or enumeration constant.  */
9337   size = decl_constant_value (size);
9338
9339   /* If this involves a template parameter, it will be a constant at
9340      instantiation time, but we don't know what the value is yet.
9341      Even if no template parameters are involved, we may an expression
9342      that is not a constant; we don't even simplify `1 + 2' when
9343      processing a template.  */
9344   if (processing_template_decl)
9345     {
9346       /* Resolve a qualified reference to an enumerator or static
9347          const data member of ours.  */
9348       if (TREE_CODE (size) == SCOPE_REF
9349           && TREE_OPERAND (size, 0) == current_class_type)
9350         {
9351           tree t = lookup_field (current_class_type,
9352                                  TREE_OPERAND (size, 1), 0, 0);
9353           if (t)
9354             size = t;
9355         }
9356
9357       return build_index_type (build_min (MINUS_EXPR, sizetype,
9358                                           size, integer_one_node));
9359     }
9360
9361   /* The array bound must be an integer type.  */
9362   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9363       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9364       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9365     {
9366       if (name)
9367         cp_error ("size of array `%D' has non-integer type", name);
9368       else
9369         cp_error ("size of array has non-integer type");
9370       size = integer_one_node;
9371     }
9372
9373   /* Normally, the array-bound will be a constant.  */
9374   if (TREE_CODE (size) == INTEGER_CST)
9375     {
9376       /* Check to see if the array bound overflowed.  Make that an
9377          error, no matter how generous we're being.  */
9378       int old_flag_pedantic_errors = flag_pedantic_errors;
9379       int old_pedantic = pedantic;
9380       pedantic = flag_pedantic_errors = 1;
9381       constant_expression_warning (size);
9382       pedantic = old_pedantic;
9383       flag_pedantic_errors = old_flag_pedantic_errors;
9384
9385       /* An array must have a positive number of elements.  */
9386       if (INT_CST_LT (size, integer_zero_node))
9387         {
9388           if (name)
9389             cp_error ("size of array `%D' is negative", name);
9390           else
9391             cp_error ("size of array is negative");
9392           size = integer_one_node;
9393         }
9394       /* Except that an extension we allow zero-sized arrays.  We
9395          always allow them in system headers because glibc uses
9396          them.  */
9397       else if (integer_zerop (size) && pedantic && !in_system_header)
9398         {
9399           if (name)
9400             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9401           else
9402             cp_pedwarn ("ISO C++ forbids zero-size array");
9403         }
9404     }
9405   else if (TREE_CONSTANT (size))
9406     {
9407       /* `(int) &fn' is not a valid array bound.  */
9408       if (name)
9409         cp_error ("size of array `%D' is not an integral constant-expression",
9410                   name);
9411       else
9412         cp_error ("size of array is not an integral constant-expression");
9413     }
9414
9415   /* Compute the index of the largest element in the array.  It is
9416      one less than the number of elements in the array.  */
9417   itype
9418     = fold (cp_build_binary_op (MINUS_EXPR,
9419                                 cp_convert (ssizetype, size),
9420                                 cp_convert (ssizetype,
9421                                             integer_one_node)));
9422
9423   /* Check for variable-sized arrays.  We allow such things as an
9424      extension, even though they are not allowed in ANSI/ISO C++.  */
9425   if (!TREE_CONSTANT (itype))
9426     {
9427       if (pedantic)
9428         {
9429           if (name)
9430             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9431                         name);
9432           else
9433             cp_pedwarn ("ISO C++ forbids variable-size array");
9434         }
9435
9436       /* Create a variable-sized array index type.  */
9437       itype = variable_size (itype);
9438     }
9439   /* Make sure that there was no overflow when creating to a signed
9440      index type.  (For example, on a 32-bit machine, an array with
9441      size 2^32 - 1 is too big.)  */
9442   else if (TREE_OVERFLOW (itype))
9443     {
9444       error ("overflow in array dimension");
9445       TREE_OVERFLOW (itype) = 0;
9446     }
9447
9448   /* Create and return the appropriate index type.  */
9449   return build_index_type (itype);
9450 }
9451
9452 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9453    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9454    with this type.  */
9455
9456 static tree
9457 create_array_type_for_decl (name, type, size)
9458      tree name;
9459      tree type;
9460      tree size;
9461 {
9462   tree itype = NULL_TREE;
9463   const char* error_msg;
9464
9465   /* If things have already gone awry, bail now.  */
9466   if (type == error_mark_node || size == error_mark_node)
9467     return error_mark_node;
9468
9469   /* Assume that everything will go OK.  */
9470   error_msg = NULL;
9471
9472   /* There are some types which cannot be array elements.  */
9473   switch (TREE_CODE (type))
9474     {
9475     case VOID_TYPE:
9476       error_msg = "array of void";
9477       break;
9478
9479     case FUNCTION_TYPE:
9480       error_msg = "array of functions";
9481       break;
9482
9483     case REFERENCE_TYPE:
9484       error_msg = "array of references";
9485       break;
9486
9487     case OFFSET_TYPE:
9488       error_msg = "array of data members";
9489       break;
9490
9491     case METHOD_TYPE:
9492       error_msg = "array of function members";
9493       break;
9494
9495     default:
9496       break;
9497     }
9498
9499   /* If something went wrong, issue an error-message and return.  */
9500   if (error_msg)
9501     {
9502       if (name)
9503         cp_error ("declaration of `%D' as %s", name, error_msg);
9504       else
9505         cp_error ("creating %s", error_msg);
9506
9507       return error_mark_node;
9508     }
9509
9510   /* [dcl.array]
9511
9512      The constant expressions that specify the bounds of the arrays
9513      can be omitted only for the first member of the sequence.  */
9514   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9515     {
9516       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9517                 name);
9518
9519       return error_mark_node;
9520     }
9521
9522   /* Figure out the index type for the array.  */
9523   if (size)
9524     itype = compute_array_index_type (name, size);
9525
9526   return build_cplus_array_type (type, itype);
9527 }
9528
9529 /* Check that it's OK to declare a function with the indicated TYPE.
9530    SFK indicates the kind of special function (if any) that this
9531    function is.  CTYPE is the class of which this function is a
9532    member.  OPTYPE is the type given in a conversion operator
9533    declaration.  Returns the actual return type of the function; that
9534    may be different than TYPE if an error occurs, or for certain
9535    special functions.  */
9536
9537 static tree
9538 check_special_function_return_type (sfk, type, ctype, optype)
9539      special_function_kind sfk;
9540      tree type;
9541      tree ctype;
9542      tree optype;
9543 {
9544   switch (sfk)
9545     {
9546     case sfk_constructor:
9547       if (type)
9548         cp_error ("return type specification for constructor invalid");
9549
9550       /* In the old ABI, we return `this'; in the new ABI we don't
9551          bother.  */
9552       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9553       break;
9554
9555     case sfk_destructor:
9556       if (type)
9557         cp_error ("return type specification for destructor invalid");
9558       type = void_type_node;
9559       break;
9560
9561     case sfk_conversion:
9562       if (type && !same_type_p (type, optype))
9563         cp_error ("operator `%T' declared to return `%T'", optype, type);
9564       else if (type)
9565         cp_pedwarn ("return type specified for `operator %T'",  optype);
9566       type = optype;
9567       break;
9568
9569     default:
9570       my_friendly_abort (20000408);
9571       break;
9572     }
9573
9574   return type;
9575 }
9576
9577 /* Given declspecs and a declarator,
9578    determine the name and type of the object declared
9579    and construct a ..._DECL node for it.
9580    (In one case we can return a ..._TYPE node instead.
9581     For invalid input we sometimes return 0.)
9582
9583    DECLSPECS is a chain of tree_list nodes whose value fields
9584     are the storage classes and type specifiers.
9585
9586    DECL_CONTEXT says which syntactic context this declaration is in:
9587      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9588      FUNCDEF for a function definition.  Like NORMAL but a few different
9589       error messages in each case.  Return value may be zero meaning
9590       this definition is too screwy to try to parse.
9591      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9592       handle member functions (which have FIELD context).
9593       Return value may be zero meaning this definition is too screwy to
9594       try to parse.
9595      PARM for a parameter declaration (either within a function prototype
9596       or before a function body).  Make a PARM_DECL, or return void_type_node.
9597      CATCHPARM for a parameter declaration before a catch clause.
9598      TYPENAME if for a typename (in a cast or sizeof).
9599       Don't make a DECL node; just return the ..._TYPE node.
9600      FIELD for a struct or union field; make a FIELD_DECL.
9601      BITFIELD for a field with specified width.
9602    INITIALIZED is 1 if the decl has an initializer.
9603
9604    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9605    normal attributes in TREE_PURPOSE, or NULL_TREE.
9606
9607    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9608    It may also be so in the PARM case, for a prototype where the
9609    argument type is specified but not the name.
9610
9611    This function is where the complicated C meanings of `static'
9612    and `extern' are interpreted.
9613
9614    For C++, if there is any monkey business to do, the function which
9615    calls this one must do it, i.e., prepending instance variables,
9616    renaming overloaded function names, etc.
9617
9618    Note that for this C++, it is an error to define a method within a class
9619    which does not belong to that class.
9620
9621    Except in the case where SCOPE_REFs are implicitly known (such as
9622    methods within a class being redundantly qualified),
9623    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9624    (class_name::decl_name).  The caller must also deal with this.
9625
9626    If a constructor or destructor is seen, and the context is FIELD,
9627    then the type gains the attribute TREE_HAS_x.  If such a declaration
9628    is erroneous, NULL_TREE is returned.
9629
9630    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9631    function, these are the qualifiers to give to the `this' pointer. We
9632    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9633
9634    May return void_type_node if the declarator turned out to be a friend.
9635    See grokfield for details.  */
9636
9637 tree
9638 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9639      tree declspecs;
9640      tree declarator;
9641      enum decl_context decl_context;
9642      int initialized;
9643      tree attrlist;
9644 {
9645   RID_BIT_TYPE specbits;
9646   int nclasses = 0;
9647   tree spec;
9648   tree type = NULL_TREE;
9649   int longlong = 0;
9650   int constp;
9651   int restrictp;
9652   int volatilep;
9653   int type_quals;
9654   int virtualp, explicitp, friendp, inlinep, staticp;
9655   int explicit_int = 0;
9656   int explicit_char = 0;
9657   int defaulted_int = 0;
9658   tree typedef_decl = NULL_TREE;
9659   const char *name;
9660   tree typedef_type = NULL_TREE;
9661   int funcdef_flag = 0;
9662   enum tree_code innermost_code = ERROR_MARK;
9663   int bitfield = 0;
9664 #if 0
9665   /* See the code below that used this.  */
9666   tree decl_machine_attr = NULL_TREE;
9667 #endif
9668   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9669      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9670   tree init = NULL_TREE;
9671
9672   /* Keep track of what sort of function is being processed
9673      so that we can warn about default return values, or explicit
9674      return values which do not match prescribed defaults.  */
9675   special_function_kind sfk = sfk_none;
9676
9677   tree dname = NULL_TREE;
9678   tree ctype = current_class_type;
9679   tree ctor_return_type = NULL_TREE;
9680   enum overload_flags flags = NO_SPECIAL;
9681   tree quals = NULL_TREE;
9682   tree raises = NULL_TREE;
9683   int template_count = 0;
9684   tree in_namespace = NULL_TREE;
9685   tree inner_attrs;
9686   int ignore_attrs;
9687
9688   RIDBIT_RESET_ALL (specbits);
9689   if (decl_context == FUNCDEF)
9690     funcdef_flag = 1, decl_context = NORMAL;
9691   else if (decl_context == MEMFUNCDEF)
9692     funcdef_flag = -1, decl_context = FIELD;
9693   else if (decl_context == BITFIELD)
9694     bitfield = 1, decl_context = FIELD;
9695
9696   /* Look inside a declarator for the name being declared
9697      and get it as a string, for an error message.  */
9698   {
9699     tree *next = &declarator;
9700     register tree decl;
9701     name = NULL;
9702
9703     while (next && *next)
9704       {
9705         decl = *next;
9706         switch (TREE_CODE (decl))
9707           {
9708           case TREE_LIST:
9709             /* For attributes.  */
9710             next = &TREE_VALUE (decl);
9711             break;
9712
9713           case COND_EXPR:
9714             ctype = NULL_TREE;
9715             next = &TREE_OPERAND (decl, 0);
9716             break;
9717
9718           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9719             {
9720               tree name = TREE_OPERAND (decl, 0);
9721               tree rename = NULL_TREE;
9722
9723               my_friendly_assert (flags == NO_SPECIAL, 152);
9724               flags = DTOR_FLAG;
9725               sfk = sfk_destructor;
9726               if (TREE_CODE (name) == TYPE_DECL)
9727                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9728               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9729               if (ctype == NULL_TREE)
9730                 {
9731                   if (current_class_type == NULL_TREE)
9732                     {
9733                       error ("destructors must be member functions");
9734                       flags = NO_SPECIAL;
9735                     }
9736                   else
9737                     {
9738                       tree t = constructor_name (current_class_name);
9739                       if (t != name)
9740                         rename = t;
9741                     }
9742                 }
9743               else
9744                 {
9745                   tree t = constructor_name (ctype);
9746                   if (t != name)
9747                     rename = t;
9748                 }
9749
9750               if (rename)
9751                 {
9752                   cp_error ("destructor `%T' must match class name `%T'",
9753                             name, rename);
9754                   TREE_OPERAND (decl, 0) = rename;
9755                 }
9756               next = &name;
9757             }
9758             break;
9759
9760           case ADDR_EXPR:       /* C++ reference declaration */
9761             /* Fall through. */
9762           case ARRAY_REF:
9763           case INDIRECT_REF:
9764             ctype = NULL_TREE;
9765             innermost_code = TREE_CODE (decl);
9766             next = &TREE_OPERAND (decl, 0);
9767             break;
9768
9769           case CALL_EXPR:
9770             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9771               {
9772                 /* This is actually a variable declaration using
9773                    constructor syntax.  We need to call start_decl and
9774                    cp_finish_decl so we can get the variable
9775                    initialized...  */
9776
9777                 tree attributes, prefix_attributes;
9778
9779                 *next = TREE_OPERAND (decl, 0);
9780                 init = CALL_DECLARATOR_PARMS (decl);
9781
9782                 if (attrlist)
9783                   {
9784                     attributes = TREE_PURPOSE (attrlist);
9785                     prefix_attributes = TREE_VALUE (attrlist);
9786                   }
9787                 else
9788                   {
9789                     attributes = NULL_TREE;
9790                     prefix_attributes = NULL_TREE;
9791                   }
9792
9793                 decl = start_decl (declarator, declspecs, 1,
9794                                    attributes, prefix_attributes);
9795                 decl_type_access_control (decl);
9796                 if (decl)
9797                   {
9798                     /* Look for __unused__ attribute */
9799                     if (TREE_USED (TREE_TYPE (decl)))
9800                       TREE_USED (decl) = 1;
9801                     finish_decl (decl, init, NULL_TREE);
9802                   }
9803                 else
9804                   cp_error ("invalid declarator");
9805                 return 0;
9806               }
9807             innermost_code = TREE_CODE (decl);
9808             if (decl_context == FIELD && ctype == NULL_TREE)
9809               ctype = current_class_type;
9810             if (ctype
9811                 && TREE_OPERAND (decl, 0)
9812                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9813                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9814                          == constructor_name_full (ctype))
9815                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9816                             == constructor_name (ctype)))))
9817               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9818             next = &TREE_OPERAND (decl, 0);
9819             decl = *next;
9820             if (ctype != NULL_TREE
9821                 && decl != NULL_TREE && flags != DTOR_FLAG
9822                 && decl == constructor_name (ctype))
9823               {
9824                 sfk = sfk_constructor;
9825                 ctor_return_type = ctype;
9826               }
9827             ctype = NULL_TREE;
9828             break;
9829
9830           case TEMPLATE_ID_EXPR:
9831               {
9832                 tree fns = TREE_OPERAND (decl, 0);
9833
9834                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9835                   fns = TREE_OPERAND (fns, 0);
9836
9837                 dname = fns;
9838                 if (TREE_CODE (dname) == COMPONENT_REF)
9839                   dname = TREE_OPERAND (dname, 1);
9840                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9841                   {
9842                     my_friendly_assert (is_overloaded_fn (dname),
9843                                         19990331);
9844                     dname = DECL_NAME (get_first_fn (dname));
9845                   }
9846               }
9847           /* Fall through. */
9848
9849           case IDENTIFIER_NODE:
9850             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9851               dname = decl;
9852
9853             next = 0;
9854
9855             if (C_IS_RESERVED_WORD (dname))
9856               {
9857                 cp_error ("declarator-id missing; using reserved word `%D'",
9858                           dname);
9859                 name = IDENTIFIER_POINTER (dname);
9860               }
9861             else if (!IDENTIFIER_TYPENAME_P (dname))
9862               name = IDENTIFIER_POINTER (dname);
9863             else
9864               {
9865                 my_friendly_assert (flags == NO_SPECIAL, 154);
9866                 flags = TYPENAME_FLAG;
9867                 ctor_return_type = TREE_TYPE (dname);
9868                 sfk = sfk_conversion;
9869                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9870                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9871                         == TYPE_DECL))
9872                   name = IDENTIFIER_POINTER (dname);
9873                 else
9874                   name = "<invalid operator>";
9875               }
9876             break;
9877
9878             /* C++ extension */
9879           case SCOPE_REF:
9880             {
9881               /* Perform error checking, and decide on a ctype.  */
9882               tree cname = TREE_OPERAND (decl, 0);
9883               if (cname == NULL_TREE)
9884                 ctype = NULL_TREE;
9885               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9886                 {
9887                   ctype = NULL_TREE;
9888                   in_namespace = TREE_OPERAND (decl, 0);
9889                   TREE_OPERAND (decl, 0) = NULL_TREE;
9890                 }
9891               else if (! is_aggr_type (cname, 1))
9892                 TREE_OPERAND (decl, 0) = NULL_TREE;
9893               /* Must test TREE_OPERAND (decl, 1), in case user gives
9894                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9895               else if (TREE_OPERAND (decl, 1)
9896                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9897                 ctype = cname;
9898               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9899                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9900                 {
9901                   cp_error ("`%T::%D' is not a valid declarator", cname,
9902                             TREE_OPERAND (decl, 1));
9903                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9904                             cname, TREE_OPERAND (decl, 1));
9905                   return void_type_node;
9906                 }
9907               else if (ctype == NULL_TREE)
9908                 ctype = cname;
9909               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9910                 TREE_OPERAND (decl, 0) = ctype;
9911               else
9912                 {
9913                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9914                     {
9915                       cp_error ("type `%T' is not derived from type `%T'",
9916                                 cname, ctype);
9917                       TREE_OPERAND (decl, 0) = NULL_TREE;
9918                     }
9919                   else
9920                     ctype = cname;
9921                 }
9922
9923               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9924                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9925                        == constructor_name_full (ctype))
9926                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9927                           == constructor_name (ctype))))
9928                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9929               next = &TREE_OPERAND (decl, 1);
9930               decl = *next;
9931               if (ctype)
9932                 {
9933                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9934                       && constructor_name (ctype) == decl)
9935                     {
9936                       sfk = sfk_constructor;
9937                       ctor_return_type = ctype;
9938                     }
9939                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9940                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9941                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9942                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9943                     {
9944                       sfk = sfk_destructor;
9945                       ctor_return_type = ctype;
9946                       flags = DTOR_FLAG;
9947                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9948                       next = &TREE_OPERAND (decl, 0);
9949                     }
9950                 }
9951             }
9952             break;
9953
9954           case ERROR_MARK:
9955             next = 0;
9956             break;
9957
9958           case TYPE_DECL:
9959             /* Parse error puts this typespec where
9960                a declarator should go.  */
9961             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9962             if (TREE_TYPE (decl) == current_class_type)
9963               cp_error ("  perhaps you want `%T' for a constructor",
9964                         current_class_name);
9965             dname = DECL_NAME (decl);
9966             name = IDENTIFIER_POINTER (dname);
9967
9968             /* Avoid giving two errors for this.  */
9969             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9970
9971             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9972             *next = dname;
9973             next = 0;
9974             break;
9975
9976           default:
9977             cp_compiler_error ("`%D' as declarator", decl);
9978             return 0; /* We used to do a 155 abort here.  */
9979           }
9980       }
9981   }
9982
9983   /* A function definition's declarator must have the form of
9984      a function declarator.  */
9985
9986   if (funcdef_flag && innermost_code != CALL_EXPR)
9987     return 0;
9988
9989   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9990       && innermost_code != CALL_EXPR
9991       && ! (ctype && declspecs == NULL_TREE))
9992     {
9993       cp_error ("declaration of `%D' as non-function", dname);
9994       return void_type_node;
9995     }
9996
9997   /* Anything declared one level down from the top level
9998      must be one of the parameters of a function
9999      (because the body is at least two levels down).  */
10000
10001   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10002      by not allowing C++ class definitions to specify their parameters
10003      with xdecls (must be spec.d in the parmlist).
10004
10005      Since we now wait to push a class scope until we are sure that
10006      we are in a legitimate method context, we must set oldcname
10007      explicitly (since current_class_name is not yet alive).
10008
10009      We also want to avoid calling this a PARM if it is in a namespace.  */
10010
10011   if (decl_context == NORMAL && !toplevel_bindings_p ())
10012     {
10013       struct binding_level *b = current_binding_level;
10014       current_binding_level = b->level_chain;
10015       if (current_binding_level != 0 && toplevel_bindings_p ())
10016         decl_context = PARM;
10017       current_binding_level = b;
10018     }
10019
10020   if (name == NULL)
10021     name = decl_context == PARM ? "parameter" : "type name";
10022
10023   /* Look through the decl specs and record which ones appear.
10024      Some typespecs are defined as built-in typenames.
10025      Others, the ones that are modifiers of other types,
10026      are represented by bits in SPECBITS: set the bits for
10027      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10028
10029      If there is a typedef name or a type, store the type in TYPE.
10030      This includes builtin typedefs such as `int'.
10031
10032      Set EXPLICIT_INT if the type is `int' or `char' and did not
10033      come from a user typedef.
10034
10035      Set LONGLONG if `long' is mentioned twice.
10036
10037      For C++, constructors and destructors have their own fast treatment.  */
10038
10039   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10040     {
10041       register int i;
10042       register tree id;
10043
10044       /* Certain parse errors slip through.  For example,
10045          `int class;' is not caught by the parser. Try
10046          weakly to recover here.  */
10047       if (TREE_CODE (spec) != TREE_LIST)
10048         return 0;
10049
10050       id = TREE_VALUE (spec);
10051
10052       if (TREE_CODE (id) == IDENTIFIER_NODE)
10053         {
10054           if (id == ridpointers[(int) RID_INT]
10055               || id == ridpointers[(int) RID_CHAR]
10056               || id == ridpointers[(int) RID_BOOL]
10057               || id == ridpointers[(int) RID_WCHAR])
10058             {
10059               if (type)
10060                 {
10061                   if (id == ridpointers[(int) RID_BOOL])
10062                     error ("`bool' is now a keyword");
10063                   else
10064                     cp_error ("extraneous `%T' ignored", id);
10065                 }
10066               else
10067                 {
10068                   if (id == ridpointers[(int) RID_INT])
10069                     explicit_int = 1;
10070                   else if (id == ridpointers[(int) RID_CHAR])
10071                     explicit_char = 1;
10072                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10073                 }
10074               goto found;
10075             }
10076           /* C++ aggregate types.  */
10077           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10078             {
10079               if (type)
10080                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10081               else
10082                 type = IDENTIFIER_TYPE_VALUE (id);
10083               goto found;
10084             }
10085
10086           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10087             {
10088               if (ridpointers[i] == id)
10089                 {
10090                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10091                     {
10092                       if (pedantic && ! in_system_header && warn_long_long)
10093                         pedwarn ("ISO C++ does not support `long long'");
10094                       if (longlong)
10095                         error ("`long long long' is too long for GCC");
10096                       else
10097                         longlong = 1;
10098                     }
10099                   else if (RIDBIT_SETP (i, specbits))
10100                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10101                   RIDBIT_SET (i, specbits);
10102                   goto found;
10103                 }
10104             }
10105         }
10106       /* C++ aggregate types.  */
10107       else if (TREE_CODE (id) == TYPE_DECL)
10108         {
10109           if (type)
10110             cp_error ("multiple declarations `%T' and `%T'", type,
10111                       TREE_TYPE (id));
10112           else
10113             {
10114               type = TREE_TYPE (id);
10115               TREE_VALUE (spec) = type;
10116             }
10117           goto found;
10118         }
10119       if (type)
10120         error ("two or more data types in declaration of `%s'", name);
10121       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10122         {
10123           register tree t = lookup_name (id, 1);
10124           if (!t || TREE_CODE (t) != TYPE_DECL)
10125             error ("`%s' fails to be a typedef or built in type",
10126                    IDENTIFIER_POINTER (id));
10127           else
10128             {
10129               type = TREE_TYPE (t);
10130 #if 0
10131               /* See the code below that used this.  */
10132               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10133 #endif
10134               typedef_decl = t;
10135             }
10136         }
10137       else if (id != error_mark_node)
10138         /* Can't change CLASS nodes into RECORD nodes here!  */
10139         type = id;
10140
10141     found: ;
10142     }
10143
10144   typedef_type = type;
10145
10146   /* No type at all: default to `int', and set DEFAULTED_INT
10147      because it was not a user-defined typedef.  */
10148
10149   if (type == NULL_TREE
10150       && (RIDBIT_SETP (RID_SIGNED, specbits)
10151           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10152           || RIDBIT_SETP (RID_LONG, specbits)
10153           || RIDBIT_SETP (RID_SHORT, specbits)))
10154     {
10155       /* These imply 'int'.  */
10156       type = integer_type_node;
10157       defaulted_int = 1;
10158     }
10159
10160   if (sfk != sfk_none)
10161     type = check_special_function_return_type (sfk, type,
10162                                                ctor_return_type,
10163                                                ctor_return_type);
10164   else if (type == NULL_TREE)
10165     {
10166       int is_main;
10167
10168       explicit_int = -1;
10169
10170           /* We handle `main' specially here, because 'main () { }' is so
10171              common.  With no options, it is allowed.  With -Wreturn-type,
10172              it is a warning.  It is only an error with -pedantic-errors.  */
10173       is_main = (funcdef_flag
10174                  && MAIN_NAME_P (dname)
10175                  && ctype == NULL_TREE
10176                  && in_namespace == NULL_TREE
10177                  && current_namespace == global_namespace);
10178
10179       if (in_system_header || flag_ms_extensions)
10180         /* Allow it, sigh.  */;
10181       else if (pedantic || ! is_main)
10182         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10183                     name);
10184       else if (warn_return_type)
10185         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10186                     name);
10187
10188       type = integer_type_node;
10189     }
10190
10191   ctype = NULL_TREE;
10192
10193   /* Now process the modifiers that were specified
10194      and check for invalid combinations.  */
10195
10196   /* Long double is a special combination.  */
10197
10198   if (RIDBIT_SETP (RID_LONG, specbits)
10199       && TYPE_MAIN_VARIANT (type) == double_type_node)
10200     {
10201       RIDBIT_RESET (RID_LONG, specbits);
10202       type = build_qualified_type (long_double_type_node,
10203                                    CP_TYPE_QUALS (type));
10204     }
10205
10206   /* Check all other uses of type modifiers.  */
10207
10208   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10209       || RIDBIT_SETP (RID_SIGNED, specbits)
10210       || RIDBIT_SETP (RID_LONG, specbits)
10211       || RIDBIT_SETP (RID_SHORT, specbits))
10212     {
10213       int ok = 0;
10214
10215       if (TREE_CODE (type) == REAL_TYPE)
10216         error ("short, signed or unsigned invalid for `%s'", name);
10217       else if (TREE_CODE (type) != INTEGER_TYPE)
10218         error ("long, short, signed or unsigned invalid for `%s'", name);
10219       else if (RIDBIT_SETP (RID_LONG, specbits)
10220                && RIDBIT_SETP (RID_SHORT, specbits))
10221         error ("long and short specified together for `%s'", name);
10222       else if ((RIDBIT_SETP (RID_LONG, specbits)
10223                 || RIDBIT_SETP (RID_SHORT, specbits))
10224                && explicit_char)
10225         error ("long or short specified with char for `%s'", name);
10226       else if ((RIDBIT_SETP (RID_LONG, specbits)
10227                 || RIDBIT_SETP (RID_SHORT, specbits))
10228                && TREE_CODE (type) == REAL_TYPE)
10229         error ("long or short specified with floating type for `%s'", name);
10230       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10231                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10232         error ("signed and unsigned given together for `%s'", name);
10233       else
10234         {
10235           ok = 1;
10236           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10237             {
10238               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10239                        name);
10240               if (flag_pedantic_errors)
10241                 ok = 0;
10242             }
10243         }
10244
10245       /* Discard the type modifiers if they are invalid.  */
10246       if (! ok)
10247         {
10248           RIDBIT_RESET (RID_UNSIGNED, specbits);
10249           RIDBIT_RESET (RID_SIGNED, specbits);
10250           RIDBIT_RESET (RID_LONG, specbits);
10251           RIDBIT_RESET (RID_SHORT, specbits);
10252           longlong = 0;
10253         }
10254     }
10255
10256   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10257       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10258     {
10259       error ("complex invalid for `%s'", name);
10260       RIDBIT_RESET (RID_COMPLEX, specbits);
10261     }
10262
10263   /* Decide whether an integer type is signed or not.
10264      Optionally treat bitfields as signed by default.  */
10265   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10266       /* [class.bit]
10267
10268          It is implementation-defined whether a plain (neither
10269          explicitly signed or unsigned) char, short, int, or long
10270          bit-field is signed or unsigned.
10271
10272          Naturally, we extend this to long long as well.  Note that
10273          this does not include wchar_t.  */
10274       || (bitfield && !flag_signed_bitfields
10275           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10276           /* A typedef for plain `int' without `signed' can be
10277              controlled just like plain `int', but a typedef for
10278              `signed int' cannot be so controlled.  */
10279           && !(typedef_decl
10280                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10281           && (TREE_CODE (type) == INTEGER_TYPE
10282               || TREE_CODE (type) == CHAR_TYPE)
10283           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10284     {
10285       if (longlong)
10286         type = long_long_unsigned_type_node;
10287       else if (RIDBIT_SETP (RID_LONG, specbits))
10288         type = long_unsigned_type_node;
10289       else if (RIDBIT_SETP (RID_SHORT, specbits))
10290         type = short_unsigned_type_node;
10291       else if (type == char_type_node)
10292         type = unsigned_char_type_node;
10293       else if (typedef_decl)
10294         type = unsigned_type (type);
10295       else
10296         type = unsigned_type_node;
10297     }
10298   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10299            && type == char_type_node)
10300     type = signed_char_type_node;
10301   else if (longlong)
10302     type = long_long_integer_type_node;
10303   else if (RIDBIT_SETP (RID_LONG, specbits))
10304     type = long_integer_type_node;
10305   else if (RIDBIT_SETP (RID_SHORT, specbits))
10306     type = short_integer_type_node;
10307
10308   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10309     {
10310       /* If we just have "complex", it is equivalent to
10311          "complex double", but if any modifiers at all are specified it is
10312          the complex form of TYPE.  E.g, "complex short" is
10313          "complex short int".  */
10314
10315       if (defaulted_int && ! longlong
10316           && ! (RIDBIT_SETP (RID_LONG, specbits)
10317                 || RIDBIT_SETP (RID_SHORT, specbits)
10318                 || RIDBIT_SETP (RID_SIGNED, specbits)
10319                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10320         type = complex_double_type_node;
10321       else if (type == integer_type_node)
10322         type = complex_integer_type_node;
10323       else if (type == float_type_node)
10324         type = complex_float_type_node;
10325       else if (type == double_type_node)
10326         type = complex_double_type_node;
10327       else if (type == long_double_type_node)
10328         type = complex_long_double_type_node;
10329       else
10330         type = build_complex_type (type);
10331     }
10332
10333   if (sfk == sfk_conversion
10334       && (RIDBIT_SETP (RID_CONST, specbits)
10335           || RIDBIT_SETP (RID_VOLATILE, specbits)
10336           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10337     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10338               ctor_return_type);
10339
10340   /* Set CONSTP if this declaration is `const', whether by
10341      explicit specification or via a typedef.
10342      Likewise for VOLATILEP.  */
10343
10344   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10345   restrictp =
10346     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10347   volatilep =
10348     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10349   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10350                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10351                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10352   type = cp_build_qualified_type (type, type_quals);
10353   staticp = 0;
10354   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10355   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10356   RIDBIT_RESET (RID_VIRTUAL, specbits);
10357   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10358   RIDBIT_RESET (RID_EXPLICIT, specbits);
10359
10360   if (RIDBIT_SETP (RID_STATIC, specbits))
10361     staticp = 1 + (decl_context == FIELD);
10362
10363   if (virtualp && staticp == 2)
10364     {
10365       cp_error ("member `%D' cannot be declared both virtual and static",
10366                 dname);
10367       staticp = 0;
10368     }
10369   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10370   RIDBIT_RESET (RID_FRIEND, specbits);
10371
10372   /* Warn if two storage classes are given. Default to `auto'.  */
10373
10374   if (RIDBIT_ANY_SET (specbits))
10375     {
10376       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10377       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10378       if (decl_context == PARM && nclasses > 0)
10379         error ("storage class specifiers invalid in parameter declarations");
10380       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10381         {
10382           if (decl_context == PARM)
10383             error ("typedef declaration invalid in parameter declaration");
10384           nclasses++;
10385         }
10386       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10387       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10388     }
10389
10390   /* Give error if `virtual' is used outside of class declaration.  */
10391   if (virtualp
10392       && (current_class_name == NULL_TREE || decl_context != FIELD))
10393     {
10394       error ("virtual outside class declaration");
10395       virtualp = 0;
10396     }
10397
10398   /* Static anonymous unions are dealt with here.  */
10399   if (staticp && decl_context == TYPENAME
10400       && TREE_CODE (declspecs) == TREE_LIST
10401       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10402     decl_context = FIELD;
10403
10404   /* Warn about storage classes that are invalid for certain
10405      kinds of declarations (parameters, typenames, etc.).  */
10406
10407   if (nclasses > 1)
10408     error ("multiple storage classes in declaration of `%s'", name);
10409   else if (decl_context != NORMAL && nclasses > 0)
10410     {
10411       if ((decl_context == PARM || decl_context == CATCHPARM)
10412           && (RIDBIT_SETP (RID_REGISTER, specbits)
10413               || RIDBIT_SETP (RID_AUTO, specbits)))
10414         ;
10415       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10416         ;
10417       else if (decl_context == FIELD
10418                /* C++ allows static class elements  */
10419                && RIDBIT_SETP (RID_STATIC, specbits))
10420         /* C++ also allows inlines and signed and unsigned elements,
10421            but in those cases we don't come in here.  */
10422         ;
10423       else
10424         {
10425           if (decl_context == FIELD)
10426             {
10427               tree tmp = NULL_TREE;
10428               register int op = 0;
10429
10430               if (declarator)
10431                 {
10432                   /* Avoid trying to get an operand off an identifier node.  */
10433                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10434                     tmp = declarator;
10435                   else
10436                     tmp = TREE_OPERAND (declarator, 0);
10437                   op = IDENTIFIER_OPNAME_P (tmp);
10438                   if (IDENTIFIER_TYPENAME_P (tmp))
10439                     {
10440                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10441                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10442                               == TYPE_DECL))
10443                         name = IDENTIFIER_POINTER (tmp);
10444                       else
10445                         name = "<invalid operator>";
10446                     }
10447                 }
10448               error ("storage class specified for %s `%s'",
10449                      op ? "member operator" : "field",
10450                      name);
10451             }
10452           else
10453             {
10454               if (decl_context == PARM || decl_context == CATCHPARM)
10455                 error ("storage class specified for parameter `%s'", name);
10456               else
10457                 error ("storage class specified for typename");
10458             }
10459           RIDBIT_RESET (RID_REGISTER, specbits);
10460           RIDBIT_RESET (RID_AUTO, specbits);
10461           RIDBIT_RESET (RID_EXTERN, specbits);
10462         }
10463     }
10464   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10465     {
10466       if (toplevel_bindings_p ())
10467         {
10468           /* It's common practice (and completely valid) to have a const
10469              be initialized and declared extern.  */
10470           if (!(type_quals & TYPE_QUAL_CONST))
10471             warning ("`%s' initialized and declared `extern'", name);
10472         }
10473       else
10474         error ("`%s' has both `extern' and initializer", name);
10475     }
10476   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10477            && ! toplevel_bindings_p ())
10478     error ("nested function `%s' declared `extern'", name);
10479   else if (toplevel_bindings_p ())
10480     {
10481       if (RIDBIT_SETP (RID_AUTO, specbits))
10482         error ("top-level declaration of `%s' specifies `auto'", name);
10483     }
10484
10485   if (nclasses > 0 && friendp)
10486     error ("storage class specifiers invalid in friend function declarations");
10487
10488   /* Now figure out the structure of the declarator proper.
10489      Descend through it, creating more complex types, until we reach
10490      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10491
10492   inner_attrs = NULL_TREE;
10493   ignore_attrs = 0;
10494
10495   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10496          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10497     {
10498       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10499          an INDIRECT_REF (for *...),
10500          a CALL_EXPR (for ...(...)),
10501          an identifier (for the name being declared)
10502          or a null pointer (for the place in an absolute declarator
10503          where the name was omitted).
10504          For the last two cases, we have just exited the loop.
10505
10506          For C++ it could also be
10507          a SCOPE_REF (for class :: ...).  In this case, we have converted
10508          sensible names to types, and those are the values we use to
10509          qualify the member name.
10510          an ADDR_EXPR (for &...),
10511          a BIT_NOT_EXPR (for destructors)
10512
10513          At this point, TYPE is the type of elements of an array,
10514          or for a function to return, or for a pointer to point to.
10515          After this sequence of ifs, TYPE is the type of the
10516          array or function or pointer, and DECLARATOR has had its
10517          outermost layer removed.  */
10518
10519       if (type == error_mark_node)
10520         {
10521           if (TREE_CODE (declarator) == SCOPE_REF)
10522             declarator = TREE_OPERAND (declarator, 1);
10523           else
10524             declarator = TREE_OPERAND (declarator, 0);
10525           continue;
10526         }
10527       if (quals != NULL_TREE
10528           && (declarator == NULL_TREE
10529               || TREE_CODE (declarator) != SCOPE_REF))
10530         {
10531           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10532             ctype = TYPE_METHOD_BASETYPE (type);
10533           if (ctype != NULL_TREE)
10534             {
10535               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10536               grok_method_quals (ctype, dummy, quals);
10537               type = TREE_TYPE (dummy);
10538               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10539               quals = NULL_TREE;
10540             }
10541         }
10542
10543       /* See the comment for the TREE_LIST case, below.  */
10544       if (ignore_attrs)
10545         ignore_attrs = 0;
10546       else if (inner_attrs)
10547         {
10548           decl_attributes (type, inner_attrs, NULL_TREE);
10549           inner_attrs = NULL_TREE;
10550         }
10551
10552       switch (TREE_CODE (declarator))
10553         {
10554         case TREE_LIST:
10555           {
10556             /* We encode a declarator with embedded attributes using
10557                a TREE_LIST.  The attributes apply to the declarator
10558                directly inside them, so we have to skip an iteration
10559                before applying them to the type.  If the declarator just
10560                inside is the declarator-id, we apply the attrs to the
10561                decl itself.  */
10562             inner_attrs = TREE_PURPOSE (declarator);
10563             ignore_attrs = 1;
10564             declarator = TREE_VALUE (declarator);
10565           }
10566           break;
10567
10568         case ARRAY_REF:
10569           {
10570             register tree size;
10571
10572             size = TREE_OPERAND (declarator, 1);
10573
10574             /* VC++ spells a zero-sized array with [].  */
10575             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10576                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10577               size = integer_zero_node;
10578
10579             declarator = TREE_OPERAND (declarator, 0);
10580
10581             type = create_array_type_for_decl (dname, type, size);
10582
10583             /* VLAs never work as fields. */
10584             if (decl_context == FIELD && !processing_template_decl
10585                 && TREE_CODE (type) == ARRAY_TYPE
10586                 && TYPE_DOMAIN (type) != NULL_TREE
10587                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10588               {
10589                 cp_error ("size of member `%D' is not constant", dname);
10590                 /* Proceed with arbitrary constant size, so that offset
10591                    computations don't get confused. */
10592                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10593                                                    integer_one_node);
10594               }
10595
10596             ctype = NULL_TREE;
10597           }
10598           break;
10599
10600         case CALL_EXPR:
10601           {
10602             tree arg_types;
10603             int funcdecl_p;
10604             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10605             tree inner_decl = TREE_OPERAND (declarator, 0);
10606
10607             /* Declaring a function type.
10608                Make sure we have a valid type for the function to return.  */
10609
10610             /* We now know that the TYPE_QUALS don't apply to the
10611                decl, but to its return type.  */
10612             type_quals = TYPE_UNQUALIFIED;
10613
10614             /* Warn about some types functions can't return.  */
10615
10616             if (TREE_CODE (type) == FUNCTION_TYPE)
10617               {
10618                 error ("`%s' declared as function returning a function", name);
10619                 type = integer_type_node;
10620               }
10621             if (TREE_CODE (type) == ARRAY_TYPE)
10622               {
10623                 error ("`%s' declared as function returning an array", name);
10624                 type = integer_type_node;
10625               }
10626
10627             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10628               inner_decl = TREE_OPERAND (inner_decl, 1);
10629
10630             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10631               inner_decl = dname;
10632
10633             /* Pick up type qualifiers which should be applied to `this'.  */
10634             quals = CALL_DECLARATOR_QUALS (declarator);
10635
10636             /* Pick up the exception specifications.  */
10637             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10638
10639             /* Say it's a definition only for the CALL_EXPR
10640                closest to the identifier.  */
10641             funcdecl_p
10642               = inner_decl
10643               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10644                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10645                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10646
10647             if (ctype == NULL_TREE
10648                 && decl_context == FIELD
10649                 && funcdecl_p
10650                 && (friendp == 0 || dname == current_class_name))
10651               ctype = current_class_type;
10652
10653             if (ctype && sfk == sfk_conversion)
10654               TYPE_HAS_CONVERSION (ctype) = 1;
10655             if (ctype && constructor_name (ctype) == dname)
10656               {
10657                 /* We are within a class's scope. If our declarator name
10658                    is the same as the class name, and we are defining
10659                    a function, then it is a constructor/destructor, and
10660                    therefore returns a void type.  */
10661
10662                 if (flags == DTOR_FLAG)
10663                   {
10664                     /* ISO C++ 12.4/2.  A destructor may not be
10665                        declared const or volatile.  A destructor may
10666                        not be static.  */
10667                     if (staticp == 2)
10668                       error ("destructor cannot be static member function");
10669                     if (quals)
10670                       {
10671                         cp_error ("destructors may not be `%s'",
10672                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10673                         quals = NULL_TREE;
10674                       }
10675                     if (decl_context == FIELD)
10676                       {
10677                         if (! member_function_or_else (ctype,
10678                                                        current_class_type,
10679                                                        flags))
10680                           return void_type_node;
10681                       }
10682                   }
10683                 else            /* It's a constructor.  */
10684                   {
10685                     if (explicitp == 1)
10686                       explicitp = 2;
10687                     /* ISO C++ 12.1.  A constructor may not be
10688                        declared const or volatile.  A constructor may
10689                        not be virtual.  A constructor may not be
10690                        static.  */
10691                     if (staticp == 2)
10692                       error ("constructor cannot be static member function");
10693                     if (virtualp)
10694                       {
10695                         pedwarn ("constructors cannot be declared virtual");
10696                         virtualp = 0;
10697                       }
10698                     if (quals)
10699                       {
10700                         cp_error ("constructors may not be `%s'",
10701                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10702                         quals = NULL_TREE;
10703                       }
10704                     {
10705                       RID_BIT_TYPE tmp_bits;
10706                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10707                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10708                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10709                       if (RIDBIT_ANY_SET (tmp_bits))
10710                         error ("return value type specifier for constructor ignored");
10711                     }
10712                     if (decl_context == FIELD)
10713                       {
10714                         if (! member_function_or_else (ctype,
10715                                                        current_class_type,
10716                                                        flags))
10717                           return void_type_node;
10718                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10719                         if (sfk != sfk_constructor)
10720                           return NULL_TREE;
10721                       }
10722                   }
10723                 if (decl_context == FIELD)
10724                   staticp = 0;
10725               }
10726             else if (friendp)
10727               {
10728                 if (initialized)
10729                   error ("can't initialize friend function `%s'", name);
10730                 if (virtualp)
10731                   {
10732                     /* Cannot be both friend and virtual.  */
10733                     error ("virtual functions cannot be friends");
10734                     RIDBIT_RESET (RID_FRIEND, specbits);
10735                     friendp = 0;
10736                   }
10737                 if (decl_context == NORMAL)
10738                   error ("friend declaration not in class definition");
10739                 if (current_function_decl && funcdef_flag)
10740                   cp_error ("can't define friend function `%s' in a local class definition",
10741                             name);
10742               }
10743
10744             /* Construct the function type and go to the next
10745                inner layer of declarator.  */
10746
10747             declarator = TREE_OPERAND (declarator, 0);
10748
10749             /* FIXME: This is where default args should be fully
10750                processed.  */
10751
10752             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10753
10754             if (declarator && flags == DTOR_FLAG)
10755               {
10756                 /* A destructor declared in the body of a class will
10757                    be represented as a BIT_NOT_EXPR.  But, we just
10758                    want the underlying IDENTIFIER.  */
10759                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10760                   declarator = TREE_OPERAND (declarator, 0);
10761
10762                 if (arg_types != void_list_node)
10763                   {
10764                     cp_error ("destructors may not have parameters");
10765                     arg_types = void_list_node;
10766                     last_function_parms = NULL_TREE;
10767                   }
10768               }
10769
10770             /* ANSI says that `const int foo ();'
10771                does not make the function foo const.  */
10772             type = build_function_type (type, arg_types);
10773
10774             {
10775               tree t;
10776               for (t = arg_types; t; t = TREE_CHAIN (t))
10777                 if (TREE_PURPOSE (t)
10778                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10779                   {
10780                     add_defarg_fn (type);
10781                     break;
10782                   }
10783             }
10784           }
10785           break;
10786
10787         case ADDR_EXPR:
10788         case INDIRECT_REF:
10789           /* Filter out pointers-to-references and references-to-references.
10790              We can get these if a TYPE_DECL is used.  */
10791
10792           if (TREE_CODE (type) == REFERENCE_TYPE)
10793             {
10794               error ("cannot declare %s to references",
10795                      TREE_CODE (declarator) == ADDR_EXPR
10796                      ? "references" : "pointers");
10797               declarator = TREE_OPERAND (declarator, 0);
10798               continue;
10799             }
10800
10801           if (TREE_CODE (type) == OFFSET_TYPE
10802               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10803                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10804             {
10805               cp_error ("cannot declare pointer to `%#T' member",
10806                         TREE_TYPE (type));
10807               type = TREE_TYPE (type);
10808             }
10809
10810           /* Merge any constancy or volatility into the target type
10811              for the pointer.  */
10812
10813           /* We now know that the TYPE_QUALS don't apply to the decl,
10814              but to the target of the pointer.  */
10815           type_quals = TYPE_UNQUALIFIED;
10816
10817           if (TREE_CODE (declarator) == ADDR_EXPR)
10818             {
10819               if (TREE_CODE (type) == VOID_TYPE)
10820                 error ("invalid type: `void &'");
10821               else
10822                 type = build_reference_type (type);
10823             }
10824           else if (TREE_CODE (type) == METHOD_TYPE)
10825             type = build_ptrmemfunc_type (build_pointer_type (type));
10826           else
10827             type = build_pointer_type (type);
10828
10829           /* Process a list of type modifier keywords (such as
10830              const or volatile) that were given inside the `*' or `&'.  */
10831
10832           if (TREE_TYPE (declarator))
10833             {
10834               register tree typemodlist;
10835               int erred = 0;
10836
10837               constp = 0;
10838               volatilep = 0;
10839               restrictp = 0;
10840               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10841                    typemodlist = TREE_CHAIN (typemodlist))
10842                 {
10843                   tree qualifier = TREE_VALUE (typemodlist);
10844
10845                   if (qualifier == ridpointers[(int) RID_CONST])
10846                     constp++;
10847                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10848                     volatilep++;
10849                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10850                     restrictp++;
10851                   else if (!erred)
10852                     {
10853                       erred = 1;
10854                       error ("invalid type modifier within pointer declarator");
10855                     }
10856                 }
10857               if (constp > 1)
10858                 pedwarn ("duplicate `const'");
10859               if (volatilep > 1)
10860                 pedwarn ("duplicate `volatile'");
10861               if (restrictp > 1)
10862                 pedwarn ("duplicate `restrict'");
10863
10864               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10865                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10866                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10867               if (TREE_CODE (declarator) == ADDR_EXPR
10868                   && (constp || volatilep))
10869                 {
10870                   if (constp)
10871                     pedwarn ("discarding `const' applied to a reference");
10872                   if (volatilep)
10873                     pedwarn ("discarding `volatile' applied to a reference");
10874                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10875                 }
10876               type = cp_build_qualified_type (type, type_quals);
10877             }
10878           declarator = TREE_OPERAND (declarator, 0);
10879           ctype = NULL_TREE;
10880           break;
10881
10882         case SCOPE_REF:
10883           {
10884             /* We have converted type names to NULL_TREE if the
10885                name was bogus, or to a _TYPE node, if not.
10886
10887                The variable CTYPE holds the type we will ultimately
10888                resolve to.  The code here just needs to build
10889                up appropriate member types.  */
10890             tree sname = TREE_OPERAND (declarator, 1);
10891             tree t;
10892
10893             /* Destructors can have their visibilities changed as well.  */
10894             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10895               sname = TREE_OPERAND (sname, 0);
10896
10897             if (TREE_COMPLEXITY (declarator) == 0)
10898               /* This needs to be here, in case we are called
10899                  multiple times.  */ ;
10900             else if (TREE_COMPLEXITY (declarator) == -1)
10901               /* Namespace member. */
10902               pop_decl_namespace ();
10903             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10904               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10905             else if (! IS_AGGR_TYPE_CODE
10906                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10907               ;
10908             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10909               {
10910                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10911                    that refer to ctype.  They couldn't be resolved earlier
10912                    because we hadn't pushed into the class yet.
10913                    Example: resolve 'B<T>::type' in
10914                    'B<typename B<T>::type> B<T>::f () { }'.  */
10915                 if (current_template_parms
10916                     && uses_template_parms (type)
10917                     && uses_template_parms (current_class_type))
10918                   {
10919                     tree args = current_template_args ();
10920                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10921                   }
10922
10923                 /* This pop_nested_class corresponds to the
10924                    push_nested_class used to push into class scope for
10925                    parsing the argument list of a function decl, in
10926                    qualified_id.  */
10927                 pop_nested_class ();
10928                 TREE_COMPLEXITY (declarator) = current_class_depth;
10929               }
10930             else
10931               my_friendly_abort (16);
10932
10933             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10934               {
10935                 /* We had a reference to a global decl, or
10936                    perhaps we were given a non-aggregate typedef,
10937                    in which case we cleared this out, and should just
10938                    keep going as though it wasn't there.  */
10939                 declarator = sname;
10940                 continue;
10941               }
10942             ctype = TREE_OPERAND (declarator, 0);
10943
10944             t = ctype;
10945             while (t != NULL_TREE && CLASS_TYPE_P (t))
10946               {
10947                 /* You're supposed to have one `template <...>'
10948                    for every template class, but you don't need one
10949                    for a full specialization.  For example:
10950
10951                      template <class T> struct S{};
10952                      template <> struct S<int> { void f(); };
10953                      void S<int>::f () {}
10954
10955                    is correct; there shouldn't be a `template <>' for
10956                    the definition of `S<int>::f'.  */
10957                 if (CLASSTYPE_TEMPLATE_INFO (t)
10958                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10959                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10960                   template_count += 1;
10961
10962                 t = TYPE_MAIN_DECL (t);
10963                 if (DECL_LANG_SPECIFIC (t))
10964                   t = DECL_CONTEXT (t);
10965                 else
10966                   t = NULL_TREE;
10967               }
10968
10969             if (sname == NULL_TREE)
10970               goto done_scoping;
10971
10972             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10973               {
10974                 /* This is the `standard' use of the scoping operator:
10975                    basetype :: member .  */
10976
10977                 if (ctype == current_class_type)
10978                   {
10979                     /* class A {
10980                          void A::f ();
10981                        };
10982
10983                        Is this ill-formed?  */
10984
10985                     if (pedantic)
10986                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10987                                   ctype, name);
10988                   }
10989                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10990                   {
10991                     if (current_class_type == NULL_TREE
10992                         || friendp)
10993                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10994                                                       TYPE_ARG_TYPES (type));
10995                     else
10996                       {
10997                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10998                                   ctype, name, current_class_type);
10999                         return void_type_node;
11000                       }
11001                   }
11002                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11003                          || COMPLETE_TYPE_P (complete_type (ctype)))
11004                   {
11005                     /* Have to move this code elsewhere in this function.
11006                        this code is used for i.e., typedef int A::M; M *pm;
11007
11008                        It is?  How? jason 10/2/94 */
11009
11010                     if (current_class_type)
11011                       {
11012                         cp_error ("cannot declare member `%T::%s' within `%T'",
11013                                   ctype, name, current_class_type);
11014                         return void_type_node;
11015                       }
11016                     type = build_offset_type (ctype, type);
11017                   }
11018                 else if (uses_template_parms (ctype))
11019                   {
11020                     if (TREE_CODE (type) == FUNCTION_TYPE)
11021                       type
11022                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11023                                                    TYPE_ARG_TYPES (type));
11024                   }
11025                 else
11026                   {
11027                     cp_error ("structure `%T' not yet defined", ctype);
11028                     return error_mark_node;
11029                   }
11030
11031                 declarator = sname;
11032               }
11033             else if (TREE_CODE (sname) == SCOPE_REF)
11034               my_friendly_abort (17);
11035             else
11036               {
11037               done_scoping:
11038                 declarator = TREE_OPERAND (declarator, 1);
11039                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11040                   /* In this case, we will deal with it later.  */
11041                   ;
11042                 else
11043                   {
11044                     if (TREE_CODE (type) == FUNCTION_TYPE)
11045                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11046                                                       TYPE_ARG_TYPES (type));
11047                     else
11048                       type = build_offset_type (ctype, type);
11049                   }
11050               }
11051           }
11052           break;
11053
11054         case BIT_NOT_EXPR:
11055           declarator = TREE_OPERAND (declarator, 0);
11056           break;
11057
11058         case RECORD_TYPE:
11059         case UNION_TYPE:
11060         case ENUMERAL_TYPE:
11061           declarator = NULL_TREE;
11062           break;
11063
11064         case ERROR_MARK:
11065           declarator = NULL_TREE;
11066           break;
11067
11068         default:
11069           my_friendly_abort (158);
11070         }
11071     }
11072
11073   /* See the comment for the TREE_LIST case, above.  */
11074   if (inner_attrs)
11075     {
11076       if (! ignore_attrs)
11077         decl_attributes (type, inner_attrs, NULL_TREE);
11078       else if (attrlist)
11079         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11080       else
11081         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11082     }
11083
11084   /* Now TYPE has the actual type.  */
11085
11086   if (explicitp == 1 || (explicitp && friendp))
11087     {
11088       /* [dcl.fct.spec] The explicit specifier shall only be used in
11089          declarations of constructors within a class definition.  */
11090       error ("only declarations of constructors can be `explicit'");
11091       explicitp = 0;
11092     }
11093
11094   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11095     {
11096       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11097         {
11098           error ("non-member `%s' cannot be declared `mutable'", name);
11099           RIDBIT_RESET (RID_MUTABLE, specbits);
11100         }
11101       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11102         {
11103           error ("non-object member `%s' cannot be declared `mutable'", name);
11104           RIDBIT_RESET (RID_MUTABLE, specbits);
11105         }
11106       else if (TREE_CODE (type) == FUNCTION_TYPE
11107                || TREE_CODE (type) == METHOD_TYPE)
11108         {
11109           error ("function `%s' cannot be declared `mutable'", name);
11110           RIDBIT_RESET (RID_MUTABLE, specbits);
11111         }
11112       else if (staticp)
11113         {
11114           error ("static `%s' cannot be declared `mutable'", name);
11115           RIDBIT_RESET (RID_MUTABLE, specbits);
11116         }
11117       else if (type_quals & TYPE_QUAL_CONST)
11118         {
11119           error ("const `%s' cannot be declared `mutable'", name);
11120           RIDBIT_RESET (RID_MUTABLE, specbits);
11121         }
11122     }
11123
11124   if (declarator == NULL_TREE
11125       || TREE_CODE (declarator) == IDENTIFIER_NODE
11126       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11127           && (TREE_CODE (type) == FUNCTION_TYPE
11128               || TREE_CODE (type) == METHOD_TYPE)))
11129     /* OK */;
11130   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11131     {
11132       cp_error ("template-id `%D' used as a declarator", declarator);
11133       declarator = dname;
11134     }
11135   else
11136     /* Unexpected declarator format.  */
11137     my_friendly_abort (990210);
11138
11139   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11140
11141   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11142     {
11143       tree decl;
11144
11145       /* Note that the grammar rejects storage classes
11146          in typenames, fields or parameters.  */
11147       if (current_lang_name == lang_name_java)
11148         TYPE_FOR_JAVA (type) = 1;
11149
11150       if (decl_context == FIELD)
11151         {
11152           if (declarator == constructor_name (current_class_type))
11153             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11154                         declarator);
11155           decl = build_lang_decl (TYPE_DECL, declarator, type);
11156         }
11157       else
11158         decl = build_decl (TYPE_DECL, declarator, type);
11159
11160       /* If the user declares "typedef struct {...} foo" then the
11161          struct will have an anonymous name.  Fill that name in now.
11162          Nothing can refer to it, so nothing needs know about the name
11163          change.  */
11164       if (type != error_mark_node
11165           && declarator
11166           && TYPE_NAME (type)
11167           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11168           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11169           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11170         {
11171           tree oldname = TYPE_NAME (type);
11172           tree t;
11173
11174           /* Replace the anonymous name with the real name everywhere.  */
11175           lookup_tag_reverse (type, declarator);
11176           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11177             if (TYPE_NAME (t) == oldname)
11178               TYPE_NAME (t) = decl;
11179
11180           if (TYPE_LANG_SPECIFIC (type))
11181             TYPE_WAS_ANONYMOUS (type) = 1;
11182
11183           /* If this is a typedef within a template class, the nested
11184              type is a (non-primary) template.  The name for the
11185              template needs updating as well.  */
11186           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11187             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11188               = TYPE_IDENTIFIER (type);
11189
11190           if (flag_new_abi)
11191             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11192           else
11193             {
11194               /* XXX Temporarily set the scope.
11195                  When returning, start_decl expects it as NULL_TREE,
11196                  and will then then set it using pushdecl. */
11197               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11198               if (current_class_type)
11199                 DECL_CONTEXT (decl) = current_class_type;
11200               else
11201                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11202
11203               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11204               DECL_ASSEMBLER_NAME (decl)
11205                 = get_identifier (build_overload_name (type, 1, 1));
11206               DECL_CONTEXT (decl) = NULL_TREE;
11207             }
11208
11209           /* FIXME remangle member functions; member functions of a
11210              type with external linkage have external linkage.  */
11211         }
11212
11213       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11214         {
11215           cp_error_at ("typedef name may not be class-qualified", decl);
11216           return NULL_TREE;
11217         }
11218       else if (quals)
11219         {
11220           if (ctype == NULL_TREE)
11221             {
11222               if (TREE_CODE (type) != METHOD_TYPE)
11223                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11224               else
11225                 ctype = TYPE_METHOD_BASETYPE (type);
11226             }
11227           if (ctype != NULL_TREE)
11228             grok_method_quals (ctype, decl, quals);
11229         }
11230
11231       if (RIDBIT_SETP (RID_SIGNED, specbits)
11232           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11233         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11234
11235       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11236                       inlinep, friendp, raises != NULL_TREE);
11237
11238       if (initialized)
11239         error ("typedef declaration includes an initializer");
11240
11241       return decl;
11242     }
11243
11244   /* Detect the case of an array type of unspecified size
11245      which came, as such, direct from a typedef name.
11246      We must copy the type, so that each identifier gets
11247      a distinct type, so that each identifier's size can be
11248      controlled separately by its own initializer.  */
11249
11250   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11251       && TYPE_DOMAIN (type) == NULL_TREE)
11252     {
11253       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11254     }
11255
11256   /* If this is a type name (such as, in a cast or sizeof),
11257      compute the type and return it now.  */
11258
11259   if (decl_context == TYPENAME)
11260     {
11261       /* Note that the grammar rejects storage classes
11262          in typenames, fields or parameters.  */
11263       if (type_quals != TYPE_UNQUALIFIED)
11264         type_quals = TYPE_UNQUALIFIED;
11265
11266       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11267       if (friendp)
11268         {
11269           if (type_quals != TYPE_UNQUALIFIED)
11270             {
11271               cp_error ("type qualifiers specified for friend class declaration");
11272               type_quals = TYPE_UNQUALIFIED;
11273             }
11274           if (inlinep)
11275             {
11276               cp_error ("`inline' specified for friend class declaration");
11277               inlinep = 0;
11278             }
11279
11280           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11281              But don't allow implicit typenames.  */
11282           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11283                                 || IMPLICIT_TYPENAME_P (type)))
11284             {
11285               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11286                 cp_pedwarn ("template parameters cannot be friends");
11287               else if (TREE_CODE (type) == TYPENAME_TYPE)
11288                 cp_pedwarn ("\
11289 friend declaration requires class-key, i.e. `friend class %T::%T'",
11290                             constructor_name (current_class_type),
11291                             TYPE_IDENTIFIER (type));
11292               else
11293                 cp_pedwarn ("\
11294 friend declaration requires class-key, i.e. `friend %#T'",
11295                             type);
11296             }
11297
11298           /* Only try to do this stuff if we didn't already give up.  */
11299           if (type != integer_type_node)
11300             {
11301               /* A friendly class?  */
11302               if (current_class_type)
11303                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11304               else
11305                 cp_error ("trying to make class `%T' a friend of global scope",
11306                           type);
11307               type = void_type_node;
11308             }
11309         }
11310       else if (quals)
11311         {
11312           if (ctype == NULL_TREE)
11313             {
11314               if (TREE_CODE (type) != METHOD_TYPE)
11315                 cp_error ("invalid qualifiers on non-member function type");
11316               else
11317                 ctype = TYPE_METHOD_BASETYPE (type);
11318             }
11319           if (ctype)
11320             {
11321               tree dummy = build_decl (TYPE_DECL, declarator, type);
11322               grok_method_quals (ctype, dummy, quals);
11323               type = TREE_TYPE (dummy);
11324             }
11325         }
11326
11327       return type;
11328     }
11329   else if (declarator == NULL_TREE && decl_context != PARM
11330            && decl_context != CATCHPARM
11331            && TREE_CODE (type) != UNION_TYPE
11332            && ! bitfield)
11333     {
11334       cp_error ("abstract declarator `%T' used as declaration", type);
11335       declarator = make_anon_name ();
11336     }
11337
11338   /* `void' at top level (not within pointer)
11339      is allowed only in typedefs or type names.
11340      We don't complain about parms either, but that is because
11341      a better error message can be made later.  */
11342
11343   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11344     {
11345       if (! declarator)
11346         error ("unnamed variable or field declared void");
11347       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11348         {
11349           if (IDENTIFIER_OPNAME_P (declarator))
11350             my_friendly_abort (356);
11351           else
11352             error ("variable or field `%s' declared void", name);
11353         }
11354       else
11355         error ("variable or field declared void");
11356       type = integer_type_node;
11357     }
11358
11359   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11360      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11361
11362   if (decl_context == PARM || decl_context == CATCHPARM)
11363     {
11364       if (ctype || in_namespace)
11365         error ("cannot use `::' in parameter declaration");
11366
11367       /* A parameter declared as an array of T is really a pointer to T.
11368          One declared as a function is really a pointer to a function.
11369          One declared as a member is really a pointer to member.  */
11370
11371       if (TREE_CODE (type) == ARRAY_TYPE)
11372         {
11373           /* Transfer const-ness of array into that of type pointed to.  */
11374           type = build_pointer_type (TREE_TYPE (type));
11375           type_quals = TYPE_UNQUALIFIED;
11376         }
11377       else if (TREE_CODE (type) == FUNCTION_TYPE)
11378         type = build_pointer_type (type);
11379       else if (TREE_CODE (type) == OFFSET_TYPE)
11380         type = build_pointer_type (type);
11381       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11382         {
11383           error ("declaration of `%s' as void", name);
11384           return NULL_TREE;
11385         }
11386     }
11387
11388   {
11389     register tree decl;
11390
11391     if (decl_context == PARM)
11392       {
11393         decl = build_decl (PARM_DECL, declarator, type);
11394
11395         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11396                         inlinep, friendp, raises != NULL_TREE);
11397
11398         /* Compute the type actually passed in the parmlist,
11399            for the case where there is no prototype.
11400            (For example, shorts and chars are passed as ints.)
11401            When there is a prototype, this is overridden later.  */
11402
11403         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11404       }
11405     else if (decl_context == FIELD)
11406       {
11407         if (type == error_mark_node)
11408           {
11409             /* Happens when declaring arrays of sizes which
11410                are error_mark_node, for example.  */
11411             decl = NULL_TREE;
11412           }
11413         else if (in_namespace && !friendp)
11414           {
11415             /* Something like struct S { int N::j; };  */
11416             cp_error ("invalid use of `::'");
11417             decl = NULL_TREE;
11418           }
11419         else if (TREE_CODE (type) == FUNCTION_TYPE)
11420           {
11421             int publicp = 0;
11422             tree function_context;
11423
11424             /* We catch the others as conflicts with the builtin
11425                typedefs.  */
11426             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11427               {
11428                 cp_error ("function `%D' cannot be declared friend",
11429                           declarator);
11430                 friendp = 0;
11431               }
11432
11433             if (friendp == 0)
11434               {
11435                 if (ctype == NULL_TREE)
11436                   ctype = current_class_type;
11437
11438                 if (ctype == NULL_TREE)
11439                   {
11440                     cp_error ("can't make `%D' into a method -- not in a class",
11441                               declarator);
11442                     return void_type_node;
11443                   }
11444
11445                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11446                    ARM 9.5 */
11447                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11448                   {
11449                     cp_error ("function `%D' declared virtual inside a union",
11450                               declarator);
11451                     return void_type_node;
11452                   }
11453
11454                 if (declarator == ansi_opname (NEW_EXPR)
11455                     || declarator == ansi_opname (VEC_NEW_EXPR)
11456                     || declarator == ansi_opname (DELETE_EXPR)
11457                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11458                   {
11459                     if (virtualp)
11460                       {
11461                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11462                                   declarator);
11463                         virtualp = 0;
11464                       }
11465                   }
11466                 else if (staticp < 2)
11467                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11468                                                   TYPE_ARG_TYPES (type));
11469               }
11470
11471             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11472             function_context = (ctype != NULL_TREE) ?
11473               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11474             publicp = (! friendp || ! staticp)
11475               && function_context == NULL_TREE;
11476             decl = grokfndecl (ctype, type,
11477                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11478                                ? declarator : dname,
11479                                declarator,
11480                                virtualp, flags, quals, raises,
11481                                friendp ? -1 : 0, friendp, publicp, inlinep,
11482                                funcdef_flag, template_count, in_namespace);
11483             if (decl == NULL_TREE)
11484               return decl;
11485 #if 0
11486             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11487             /* The decl and setting of decl_machine_attr is also turned off.  */
11488             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11489 #endif
11490
11491             /* [class.conv.ctor]
11492
11493                A constructor declared without the function-specifier
11494                explicit that can be called with a single parameter
11495                specifies a conversion from the type of its first
11496                parameter to the type of its class.  Such a constructor
11497                is called a converting constructor.  */
11498             if (explicitp == 2)
11499               DECL_NONCONVERTING_P (decl) = 1;
11500             else if (DECL_CONSTRUCTOR_P (decl))
11501               {
11502                 /* The constructor can be called with exactly one
11503                    parameter if there is at least one parameter, and
11504                    any subsequent parameters have default arguments.
11505                    We don't look at the first parameter, which is
11506                    really just the `this' parameter for the new
11507                    object.  */
11508                 tree arg_types =
11509                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11510
11511                 /* Skip the `in_chrg' argument too, if present.  */
11512                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11513                   arg_types = TREE_CHAIN (arg_types);
11514
11515                 if (arg_types == void_list_node
11516                     || (arg_types
11517                         && TREE_CHAIN (arg_types)
11518                         && TREE_CHAIN (arg_types) != void_list_node
11519                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11520                   DECL_NONCONVERTING_P (decl) = 1;
11521               }
11522           }
11523         else if (TREE_CODE (type) == METHOD_TYPE)
11524           {
11525             /* We only get here for friend declarations of
11526                members of other classes.  */
11527             /* All method decls are public, so tell grokfndecl to set
11528                TREE_PUBLIC, also.  */
11529             decl = grokfndecl (ctype, type, declarator, declarator,
11530                                virtualp, flags, quals, raises,
11531                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11532                                template_count, in_namespace);
11533             if (decl == NULL_TREE)
11534               return NULL_TREE;
11535           }
11536         else if (!staticp && ! processing_template_decl
11537                  && !COMPLETE_TYPE_P (complete_type (type))
11538                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11539           {
11540             if (declarator)
11541               cp_error ("field `%D' has incomplete type", declarator);
11542             else
11543               cp_error ("name `%T' has incomplete type", type);
11544
11545             /* If we're instantiating a template, tell them which
11546                instantiation made the field's type be incomplete.  */
11547             if (current_class_type
11548                 && TYPE_NAME (current_class_type)
11549                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11550                 && declspecs && TREE_VALUE (declspecs)
11551                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11552               cp_error ("  in instantiation of template `%T'",
11553                         current_class_type);
11554
11555             type = error_mark_node;
11556             decl = NULL_TREE;
11557           }
11558         else
11559           {
11560             if (friendp)
11561               {
11562                 error ("`%s' is neither function nor member function; cannot be declared friend",
11563                        IDENTIFIER_POINTER (declarator));
11564                 friendp = 0;
11565               }
11566             decl = NULL_TREE;
11567           }
11568
11569         if (friendp)
11570           {
11571             /* Friends are treated specially.  */
11572             if (ctype == current_class_type)
11573               warning ("member functions are implicitly friends of their class");
11574             else
11575               {
11576                 tree t = NULL_TREE;
11577                 if (decl && DECL_NAME (decl))
11578                   {
11579                     if (template_class_depth (current_class_type) == 0)
11580                       {
11581                         decl
11582                           = check_explicit_specialization
11583                           (declarator, decl,
11584                            template_count, 2 * (funcdef_flag != 0) + 4);
11585                         if (decl == error_mark_node)
11586                           return error_mark_node;
11587                       }
11588
11589                     t = do_friend (ctype, declarator, decl,
11590                                    last_function_parms, attrlist, flags, quals,
11591                                    funcdef_flag);
11592                   }
11593                 if (t && funcdef_flag)
11594                   return t;
11595
11596                 return void_type_node;
11597               }
11598           }
11599
11600         /* Structure field.  It may not be a function, except for C++ */
11601
11602         if (decl == NULL_TREE)
11603           {
11604             if (initialized)
11605               {
11606                 if (!staticp)
11607                   {
11608                     /* An attempt is being made to initialize a non-static
11609                        member.  But, from [class.mem]:
11610
11611                        4 A member-declarator can contain a
11612                        constant-initializer only if it declares a static
11613                        member (_class.static_) of integral or enumeration
11614                        type, see _class.static.data_.
11615
11616                        This used to be relatively common practice, but
11617                        the rest of the compiler does not correctly
11618                        handle the initialization unless the member is
11619                        static so we make it static below.  */
11620                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11621                                 declarator);
11622                     cp_pedwarn ("making `%D' static", declarator);
11623                     staticp = 1;
11624                   }
11625
11626                 if (uses_template_parms (type))
11627                   /* We'll check at instantiation time.  */
11628                   ;
11629                 else if (check_static_variable_definition (declarator,
11630                                                            type))
11631                   /* If we just return the declaration, crashes
11632                      will sometimes occur.  We therefore return
11633                      void_type_node, as if this was a friend
11634                      declaration, to cause callers to completely
11635                      ignore this declaration.  */
11636                   return void_type_node;
11637               }
11638
11639             /* 9.2p13 [class.mem] */
11640             if (declarator == constructor_name (current_class_type)
11641                 /* The standard does not allow non-static data members
11642                    here either, but we agreed at the 10/99 meeting
11643                    to change that in TC 1 so that they are allowed in
11644                    classes with no user-defined constructors.  */
11645                 && staticp)
11646               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11647                           declarator);
11648
11649             if (staticp)
11650               {
11651                 /* C++ allows static class members.  All other work
11652                    for this is done by grokfield.  */
11653                 decl = build_lang_decl (VAR_DECL, declarator, type);
11654                 TREE_STATIC (decl) = 1;
11655                 /* In class context, 'static' means public access.  */
11656                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11657               }
11658             else
11659               {
11660                 decl = build_decl (FIELD_DECL, declarator, type);
11661                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11662                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11663                   {
11664                     DECL_MUTABLE_P (decl) = 1;
11665                     RIDBIT_RESET (RID_MUTABLE, specbits);
11666                   }
11667               }
11668
11669             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11670                             inlinep, friendp, raises != NULL_TREE);
11671           }
11672       }
11673     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11674       {
11675         tree original_name;
11676         int publicp = 0;
11677
11678         if (! declarator)
11679           return NULL_TREE;
11680
11681         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11682           original_name = dname;
11683         else
11684           original_name = declarator;
11685
11686         if (RIDBIT_SETP (RID_AUTO, specbits))
11687           error ("storage class `auto' invalid for function `%s'", name);
11688         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11689           error ("storage class `register' invalid for function `%s'", name);
11690
11691         /* Function declaration not at top level.
11692            Storage classes other than `extern' are not allowed
11693            and `extern' makes no difference.  */
11694         if (! toplevel_bindings_p ()
11695             && (RIDBIT_SETP (RID_STATIC, specbits)
11696                 || RIDBIT_SETP (RID_INLINE, specbits))
11697             && pedantic)
11698           {
11699             if (RIDBIT_SETP (RID_STATIC, specbits))
11700               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11701             else
11702               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11703           }
11704
11705         if (ctype == NULL_TREE)
11706           {
11707             if (virtualp)
11708               {
11709                 error ("virtual non-class function `%s'", name);
11710                 virtualp = 0;
11711               }
11712           }
11713         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11714           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11715                                           TYPE_ARG_TYPES (type));
11716
11717         /* Record presence of `static'.  */
11718         publicp = (ctype != NULL_TREE
11719                    || RIDBIT_SETP (RID_EXTERN, specbits)
11720                    || !RIDBIT_SETP (RID_STATIC, specbits));
11721
11722         decl = grokfndecl (ctype, type, original_name, declarator,
11723                            virtualp, flags, quals, raises,
11724                            1, friendp,
11725                            publicp, inlinep, funcdef_flag,
11726                            template_count, in_namespace);
11727         if (decl == NULL_TREE)
11728           return NULL_TREE;
11729
11730         if (staticp == 1)
11731           {
11732             int illegal_static = 0;
11733
11734             /* Don't allow a static member function in a class, and forbid
11735                declaring main to be static.  */
11736             if (TREE_CODE (type) == METHOD_TYPE)
11737               {
11738                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11739                 illegal_static = 1;
11740               }
11741             else if (current_function_decl)
11742               {
11743                 /* FIXME need arm citation */
11744                 error ("cannot declare static function inside another function");
11745                 illegal_static = 1;
11746               }
11747
11748             if (illegal_static)
11749               {
11750                 staticp = 0;
11751                 RIDBIT_RESET (RID_STATIC, specbits);
11752               }
11753           }
11754       }
11755     else
11756       {
11757         /* It's a variable.  */
11758
11759         /* An uninitialized decl with `extern' is a reference.  */
11760         decl = grokvardecl (type, declarator, &specbits,
11761                             initialized,
11762                             (type_quals & TYPE_QUAL_CONST) != 0,
11763                             in_namespace);
11764         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11765                         inlinep, friendp, raises != NULL_TREE);
11766
11767         if (ctype)
11768           {
11769             DECL_CONTEXT (decl) = ctype;
11770             if (staticp == 1)
11771               {
11772                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11773                 staticp = 0;
11774                 RIDBIT_RESET (RID_STATIC, specbits);
11775               }
11776             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11777               {
11778                 cp_error ("static member `%D' declared `register'", decl);
11779                 RIDBIT_RESET (RID_REGISTER, specbits);
11780               }
11781             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11782               {
11783                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11784                             decl);
11785                 RIDBIT_RESET (RID_EXTERN, specbits);
11786               }
11787           }
11788       }
11789
11790     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11791
11792     /* Record `register' declaration for warnings on &
11793        and in case doing stupid register allocation.  */
11794
11795     if (RIDBIT_SETP (RID_REGISTER, specbits))
11796       DECL_REGISTER (decl) = 1;
11797
11798     if (RIDBIT_SETP (RID_EXTERN, specbits))
11799       DECL_THIS_EXTERN (decl) = 1;
11800
11801     if (RIDBIT_SETP (RID_STATIC, specbits))
11802       DECL_THIS_STATIC (decl) = 1;
11803
11804     /* Record constancy and volatility.  There's no need to do this
11805        when processing a template; we'll do this for the instantiated
11806        declaration based on the type of DECL.  */
11807     if (!processing_template_decl)
11808       c_apply_type_quals_to_decl (type_quals, decl);
11809
11810     return decl;
11811   }
11812 }
11813 \f
11814 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11815    An empty exprlist is a parmlist.  An exprlist which
11816    contains only identifiers at the global level
11817    is a parmlist.  Otherwise, it is an exprlist.  */
11818
11819 int
11820 parmlist_is_exprlist (exprs)
11821      tree exprs;
11822 {
11823   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11824     return 0;
11825
11826   if (toplevel_bindings_p ())
11827     {
11828       /* At the global level, if these are all identifiers,
11829          then it is a parmlist.  */
11830       while (exprs)
11831         {
11832           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11833             return 1;
11834           exprs = TREE_CHAIN (exprs);
11835         }
11836       return 0;
11837     }
11838   return 1;
11839 }
11840
11841 /* Subroutine of start_function.  Ensure that each of the parameter
11842    types (as listed in PARMS) is complete, as is required for a
11843    function definition.  */
11844
11845 static void
11846 require_complete_types_for_parms (parms)
11847      tree parms;
11848 {
11849   for (; parms; parms = TREE_CHAIN (parms))
11850     {
11851       tree type = TREE_TYPE (parms);
11852
11853       /* Try to complete the TYPE.  */
11854       type = complete_type (type);
11855
11856       if (type == error_mark_node)
11857         continue;
11858
11859       if (!COMPLETE_TYPE_P (type))
11860         {
11861           if (DECL_NAME (parms))
11862             error ("parameter `%s' has incomplete type",
11863                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11864           else
11865             error ("parameter has incomplete type");
11866           TREE_TYPE (parms) = error_mark_node;
11867         }
11868       else
11869         layout_decl (parms, 0);
11870     }
11871 }
11872
11873 /* Returns non-zero if T is a local variable.  */
11874
11875 int
11876 local_variable_p (t)
11877      tree t;
11878 {
11879   if ((TREE_CODE (t) == VAR_DECL
11880        /* A VAR_DECL with a context that is a _TYPE is a static data
11881           member.  */
11882        && !TYPE_P (CP_DECL_CONTEXT (t))
11883        /* Any other non-local variable must be at namespace scope.  */
11884        && !DECL_NAMESPACE_SCOPE_P (t))
11885       || (TREE_CODE (t) == PARM_DECL))
11886     return 1;
11887
11888   return 0;
11889 }
11890
11891 /* Returns non-zero if T is an automatic local variable or a label.
11892    (These are the declarations that need to be remapped when the code
11893    containing them is duplicated.)  */
11894
11895 int
11896 nonstatic_local_decl_p (t)
11897      tree t;
11898 {
11899   return ((local_variable_p (t) && !TREE_STATIC (t))
11900           || TREE_CODE (t) == LABEL_DECL
11901           || TREE_CODE (t) == RESULT_DECL);
11902 }
11903
11904 /* Like local_variable_p, but suitable for use as a tree-walking
11905    function.  */
11906
11907 static tree
11908 local_variable_p_walkfn (tp, walk_subtrees, data)
11909      tree *tp;
11910      int *walk_subtrees ATTRIBUTE_UNUSED;
11911      void *data ATTRIBUTE_UNUSED;
11912 {
11913   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11914           ? *tp : NULL_TREE);
11915 }
11916
11917 /* Check that ARG, which is a default-argument expression for a
11918    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11919    something goes wrong.  DECL may also be a _TYPE node, rather than a
11920    DECL, if there is no DECL available.  */
11921
11922 tree
11923 check_default_argument (decl, arg)
11924      tree decl;
11925      tree arg;
11926 {
11927   tree var;
11928   tree decl_type;
11929
11930   if (TREE_CODE (arg) == DEFAULT_ARG)
11931     /* We get a DEFAULT_ARG when looking at an in-class declaration
11932        with a default argument.  Ignore the argument for now; we'll
11933        deal with it after the class is complete.  */
11934     return arg;
11935
11936   if (processing_template_decl || uses_template_parms (arg))
11937     /* We don't do anything checking until instantiation-time.  Note
11938        that there may be uninstantiated arguments even for an
11939        instantiated function, since default arguments are not
11940        instantiated until they are needed.  */
11941     return arg;
11942
11943   if (TYPE_P (decl))
11944     {
11945       decl_type = decl;
11946       decl = NULL_TREE;
11947     }
11948   else
11949     decl_type = TREE_TYPE (decl);
11950
11951   if (arg == error_mark_node
11952       || decl == error_mark_node
11953       || TREE_TYPE (arg) == error_mark_node
11954       || decl_type == error_mark_node)
11955     /* Something already went wrong.  There's no need to check
11956        further.  */
11957     return error_mark_node;
11958
11959   /* [dcl.fct.default]
11960
11961      A default argument expression is implicitly converted to the
11962      parameter type.  */
11963   if (!TREE_TYPE (arg)
11964       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11965     {
11966       if (decl)
11967         cp_error ("default argument for `%#D' has type `%T'",
11968                   decl, TREE_TYPE (arg));
11969       else
11970         cp_error ("default argument for parameter of type `%T' has type `%T'",
11971                   decl_type, TREE_TYPE (arg));
11972
11973       return error_mark_node;
11974     }
11975
11976   /* [dcl.fct.default]
11977
11978      Local variables shall not be used in default argument
11979      expressions.
11980
11981      The keyword `this' shall not be used in a default argument of a
11982      member function.  */
11983   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11984                                       NULL);
11985   if (var)
11986     {
11987       cp_error ("default argument `%E' uses local variable `%D'",
11988                 arg, var);
11989       return error_mark_node;
11990     }
11991
11992   /* All is well.  */
11993   return arg;
11994 }
11995
11996 /* Decode the list of parameter types for a function type.
11997    Given the list of things declared inside the parens,
11998    return a list of types.
11999
12000    The list we receive can have three kinds of elements:
12001    an IDENTIFIER_NODE for names given without types,
12002    a TREE_LIST node for arguments given as typespecs or names with typespecs,
12003    or void_type_node, to mark the end of an argument list
12004    when additional arguments are not permitted (... was not used).
12005
12006    FUNCDEF_FLAG is nonzero for a function definition, 0 for
12007    a mere declaration.  A nonempty identifier-list gets an error message
12008    when FUNCDEF_FLAG is zero.
12009    If FUNCDEF_FLAG is 1, then parameter types must be complete.
12010    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
12011
12012    If all elements of the input list contain types,
12013    we return a list of the types.
12014    If all elements contain no type (except perhaps a void_type_node
12015    at the end), we return a null list.
12016    If some have types and some do not, it is an error, and we
12017    return a null list.
12018
12019    Also set last_function_parms to either
12020    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12021    A list of names is converted to a chain of PARM_DECLs
12022    by store_parm_decls so that ultimately it is always a chain of decls.
12023
12024    Note that in C++, parameters can take default values.  These default
12025    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12026    an error to specify default values which are followed by parameters
12027    that have no default values, or an ELLIPSES.  For simplicities sake,
12028    only parameters which are specified with their types can take on
12029    default values.  */
12030
12031 static tree
12032 grokparms (first_parm, funcdef_flag)
12033      tree first_parm;
12034      int funcdef_flag;
12035 {
12036   tree result = NULL_TREE;
12037   tree decls = NULL_TREE;
12038
12039   if (first_parm != NULL_TREE
12040       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12041     {
12042       if (! funcdef_flag)
12043         pedwarn ("parameter names (without types) in function declaration");
12044       last_function_parms = first_parm;
12045       return NULL_TREE;
12046     }
12047   else if (first_parm != NULL_TREE
12048            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12049            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12050     my_friendly_abort (145);
12051   else
12052     {
12053       /* Types were specified.  This is a list of declarators
12054          each represented as a TREE_LIST node.  */
12055       register tree parm, chain;
12056       int any_init = 0, any_error = 0;
12057
12058       if (first_parm != NULL_TREE)
12059         {
12060           tree last_result = NULL_TREE;
12061           tree last_decl = NULL_TREE;
12062
12063           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12064             {
12065               tree type = NULL_TREE, list_node = parm;
12066               register tree decl = TREE_VALUE (parm);
12067               tree init = TREE_PURPOSE (parm);
12068
12069               chain = TREE_CHAIN (parm);
12070               /* @@ weak defense against parse errors.  */
12071               if (TREE_CODE (decl) != VOID_TYPE
12072                   && TREE_CODE (decl) != TREE_LIST)
12073                 {
12074                   /* Give various messages as the need arises.  */
12075                   if (TREE_CODE (decl) == STRING_CST)
12076                     cp_error ("invalid string constant `%E'", decl);
12077                   else if (TREE_CODE (decl) == INTEGER_CST)
12078                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12079                   continue;
12080                 }
12081
12082               if (TREE_CODE (decl) != VOID_TYPE)
12083                 {
12084                   decl = grokdeclarator (TREE_VALUE (decl),
12085                                          TREE_PURPOSE (decl),
12086                                          PARM, init != NULL_TREE,
12087                                          NULL_TREE);
12088                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12089                     continue;
12090
12091                   /* Top-level qualifiers on the parameters are
12092                      ignored for function types.  */
12093                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12094
12095                   if (TREE_CODE (type) == VOID_TYPE)
12096                     decl = void_type_node;
12097                   else if (TREE_CODE (type) == METHOD_TYPE)
12098                     {
12099                       if (DECL_NAME (decl))
12100                         /* Cannot use the decl here because
12101                            we don't have DECL_CONTEXT set up yet.  */
12102                         cp_error ("parameter `%D' invalidly declared method type",
12103                                   DECL_NAME (decl));
12104                       else
12105                         error ("parameter invalidly declared method type");
12106                       type = build_pointer_type (type);
12107                       TREE_TYPE (decl) = type;
12108                     }
12109                   else if (TREE_CODE (type) == OFFSET_TYPE)
12110                     {
12111                       if (DECL_NAME (decl))
12112                         cp_error ("parameter `%D' invalidly declared offset type",
12113                                   DECL_NAME (decl));
12114                       else
12115                         error ("parameter invalidly declared offset type");
12116                       type = build_pointer_type (type);
12117                       TREE_TYPE (decl) = type;
12118                     }
12119                   else if (abstract_virtuals_error (decl, type))
12120                     any_error = 1;  /* Seems like a good idea. */
12121                   else if (POINTER_TYPE_P (type))
12122                     {
12123                       tree t = type;
12124                       while (POINTER_TYPE_P (t)
12125                              || (TREE_CODE (t) == ARRAY_TYPE
12126                                  && TYPE_DOMAIN (t) != NULL_TREE))
12127                         t = TREE_TYPE (t);
12128                       if (TREE_CODE (t) == ARRAY_TYPE)
12129                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12130                                   type,
12131                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12132                     }
12133                 }
12134
12135               if (TREE_CODE (decl) == VOID_TYPE)
12136                 {
12137                   if (result == NULL_TREE)
12138                     {
12139                       result = void_list_node;
12140                       last_result = result;
12141                     }
12142                   else
12143                     {
12144                       TREE_CHAIN (last_result) = void_list_node;
12145                       last_result = void_list_node;
12146                     }
12147                   if (chain
12148                       && (chain != void_list_node || TREE_CHAIN (chain)))
12149                     error ("`void' in parameter list must be entire list");
12150                   break;
12151                 }
12152
12153               /* Since there is a prototype, args are passed in their own types.  */
12154               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12155               if (PROMOTE_PROTOTYPES
12156                   && (TREE_CODE (type) == INTEGER_TYPE
12157                       || TREE_CODE (type) == ENUMERAL_TYPE)
12158                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12159                 DECL_ARG_TYPE (decl) = integer_type_node;
12160               if (!any_error && init)
12161                 {
12162                   any_init++;
12163                   init = check_default_argument (decl, init);
12164                 }
12165               else
12166                 init = NULL_TREE;
12167
12168               if (decls == NULL_TREE)
12169                 {
12170                   decls = decl;
12171                   last_decl = decls;
12172                 }
12173               else
12174                 {
12175                   TREE_CHAIN (last_decl) = decl;
12176                   last_decl = decl;
12177                 }
12178               list_node = tree_cons (init, type, NULL_TREE);
12179               if (result == NULL_TREE)
12180                 {
12181                   result = list_node;
12182                   last_result = result;
12183                 }
12184               else
12185                 {
12186                   TREE_CHAIN (last_result) = list_node;
12187                   last_result = list_node;
12188                 }
12189             }
12190           if (last_result)
12191             TREE_CHAIN (last_result) = NULL_TREE;
12192           /* If there are no parameters, and the function does not end
12193              with `...', then last_decl will be NULL_TREE.  */
12194           if (last_decl != NULL_TREE)
12195             TREE_CHAIN (last_decl) = NULL_TREE;
12196         }
12197     }
12198
12199   last_function_parms = decls;
12200
12201   return result;
12202 }
12203
12204 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12205    FUNCTION_TYPE with the newly parsed version of its default argument, which
12206    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12207
12208 void
12209 replace_defarg (arg, init)
12210      tree arg, init;
12211 {
12212   if (! processing_template_decl
12213       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12214     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12215                 TREE_TYPE (init), TREE_VALUE (arg));
12216   TREE_PURPOSE (arg) = init;
12217 }
12218 \f
12219 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12220    D's arguments allow it to be a copy constructor, or copy assignment
12221    operator.  */
12222
12223 int
12224 copy_args_p (d)
12225      tree d;
12226 {
12227   tree t;
12228
12229   if (!DECL_FUNCTION_MEMBER_P (d))
12230     return 0;
12231
12232   t = FUNCTION_ARG_CHAIN (d);
12233   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12234     t = TREE_CHAIN (t);
12235   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12236       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12237           == DECL_CONTEXT (d))
12238       && (TREE_CHAIN (t) == NULL_TREE
12239           || TREE_CHAIN (t) == void_list_node
12240           || TREE_PURPOSE (TREE_CHAIN (t))))
12241     return 1;
12242   return 0;
12243 }
12244
12245 /* These memoizing functions keep track of special properties which
12246    a class may have.  `grok_ctor_properties' notices whether a class
12247    has a constructor of the form X(X&), and also complains
12248    if the class has a constructor of the form X(X).
12249    `grok_op_properties' takes notice of the various forms of
12250    operator= which are defined, as well as what sorts of type conversion
12251    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12252
12253 int
12254 grok_ctor_properties (ctype, decl)
12255      tree ctype, decl;
12256 {
12257   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12258   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12259
12260   /* When a type has virtual baseclasses, a magical first int argument is
12261      added to any ctor so we can tell if the class has been initialized
12262      yet.  This could screw things up in this function, so we deliberately
12263      ignore the leading int if we're in that situation.  */
12264   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12265     {
12266       my_friendly_assert (parmtypes
12267                           && TREE_VALUE (parmtypes) == integer_type_node,
12268                           980529);
12269       parmtypes = TREE_CHAIN (parmtypes);
12270       parmtype = TREE_VALUE (parmtypes);
12271     }
12272
12273   /* [class.copy]
12274
12275      A non-template constructor for class X is a copy constructor if
12276      its first parameter is of type X&, const X&, volatile X& or const
12277      volatile X&, and either there are no other parameters or else all
12278      other parameters have default arguments.  */
12279   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12280       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12281       && (TREE_CHAIN (parmtypes) == NULL_TREE
12282           || TREE_CHAIN (parmtypes) == void_list_node
12283           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12284       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12285            && is_member_template (DECL_TI_TEMPLATE (decl))))
12286     {
12287       TYPE_HAS_INIT_REF (ctype) = 1;
12288       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12289         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12290     }
12291   /* [class.copy]
12292
12293      A declaration of a constructor for a class X is ill-formed if its
12294      first parameter is of type (optionally cv-qualified) X and either
12295      there are no other parameters or else all other parameters have
12296      default arguments.
12297
12298      We *don't* complain about member template instantiations that
12299      have this form, though; they can occur as we try to decide what
12300      constructor to use during overload resolution.  Since overload
12301      resolution will never prefer such a constructor to the
12302      non-template copy constructor (which is either explicitly or
12303      implicitly defined), there's no need to worry about their
12304      existence.  Theoretically, they should never even be
12305      instantiated, but that's hard to forestall.  */
12306   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12307            && (TREE_CHAIN (parmtypes) == NULL_TREE
12308                || TREE_CHAIN (parmtypes) == void_list_node
12309                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12310            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12311                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12312     {
12313       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12314                 ctype, ctype);
12315       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12316       return 0;
12317     }
12318   else if (TREE_CODE (parmtype) == VOID_TYPE
12319            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12320     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12321
12322   return 1;
12323 }
12324
12325 /* An operator with this code is unary, but can also be binary.  */
12326
12327 static int
12328 ambi_op_p (code)
12329      enum tree_code code;
12330 {
12331   return (code == INDIRECT_REF
12332           || code == ADDR_EXPR
12333           || code == CONVERT_EXPR
12334           || code == NEGATE_EXPR
12335           || code == PREINCREMENT_EXPR
12336           || code == PREDECREMENT_EXPR);
12337 }
12338
12339 /* An operator with this name can only be unary.  */
12340
12341 static int
12342 unary_op_p (code)
12343      enum tree_code code;
12344 {
12345   return (code == TRUTH_NOT_EXPR
12346           || code == BIT_NOT_EXPR
12347           || code == COMPONENT_REF
12348           || code == TYPE_EXPR);
12349 }
12350
12351 /* Do a little sanity-checking on how they declared their operator.  */
12352
12353 void
12354 grok_op_properties (decl, virtualp, friendp)
12355      tree decl;
12356      int virtualp, friendp;
12357 {
12358   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12359   tree argtype;
12360   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12361   tree name = DECL_NAME (decl);
12362   enum tree_code operator_code;
12363   int arity;
12364
12365   /* Count the number of arguments.  */
12366   for (argtype = argtypes, arity = 0;
12367        argtype && argtype != void_list_node;
12368        argtype = TREE_CHAIN (argtype))
12369     ++arity;
12370
12371   if (current_class_type == NULL_TREE)
12372     friendp = 1;
12373
12374   if (DECL_CONV_FN_P (decl))
12375     operator_code = TYPE_EXPR;
12376   else
12377     do
12378       {
12379 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12380         if (ansi_opname (CODE) == name)                                     \
12381           {                                                                 \
12382             operator_code = CODE;                                           \
12383             break;                                                          \
12384           }                                                                 \
12385         else if (ansi_assopname (CODE) == name)                             \
12386           {                                                                 \
12387             operator_code = CODE;                                           \
12388             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12389             break;                                                          \
12390           }
12391
12392 #include "operators.def"
12393 #undef DEF_OPERATOR
12394
12395         my_friendly_abort (20000527);
12396       }
12397     while (0);
12398   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12399   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12400
12401   if (! friendp)
12402     {
12403       switch (operator_code)
12404         {
12405         case CALL_EXPR:
12406           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12407           break;
12408
12409         case ARRAY_REF:
12410           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12411           break;
12412
12413         case COMPONENT_REF:
12414         case MEMBER_REF:
12415           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12416           break;
12417
12418         case NEW_EXPR:
12419           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12420           break;
12421
12422         case DELETE_EXPR:
12423           TYPE_GETS_DELETE (current_class_type) |= 1;
12424           break;
12425
12426         case VEC_NEW_EXPR:
12427           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12428           break;
12429
12430         case VEC_DELETE_EXPR:
12431           TYPE_GETS_DELETE (current_class_type) |= 2;
12432           break;
12433
12434         default:
12435           break;
12436         }
12437     }
12438
12439   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12440     {
12441       /* When the compiler encounters the definition of A::operator new, it
12442          doesn't look at the class declaration to find out if it's static.  */
12443       if (methodp)
12444         revert_static_member_fn (decl);
12445
12446       /* Take care of function decl if we had syntax errors.  */
12447       if (argtypes == NULL_TREE)
12448         TREE_TYPE (decl)
12449           = build_function_type (ptr_type_node,
12450                                  hash_tree_chain (integer_type_node,
12451                                                   void_list_node));
12452       else
12453         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12454     }
12455   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12456     {
12457       if (methodp)
12458         revert_static_member_fn (decl);
12459
12460       if (argtypes == NULL_TREE)
12461         TREE_TYPE (decl)
12462           = build_function_type (void_type_node,
12463                                  hash_tree_chain (ptr_type_node,
12464                                                   void_list_node));
12465       else
12466         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12467     }
12468   else
12469     {
12470       /* An operator function must either be a non-static member function
12471          or have at least one parameter of a class, a reference to a class,
12472          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12473       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12474         {
12475           if (operator_code == TYPE_EXPR
12476               || operator_code == CALL_EXPR
12477               || operator_code == COMPONENT_REF
12478               || operator_code == ARRAY_REF
12479               || operator_code == NOP_EXPR)
12480             cp_error ("`%D' must be a nonstatic member function", decl);
12481           else
12482             {
12483               tree p = argtypes;
12484
12485               if (DECL_STATIC_FUNCTION_P (decl))
12486                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12487
12488               if (p)
12489                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12490                   {
12491                     tree arg = TREE_VALUE (p);
12492                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12493                       arg = TREE_TYPE (arg);
12494
12495                     /* This lets bad template code slip through.  */
12496                     if (IS_AGGR_TYPE (arg)
12497                         || TREE_CODE (arg) == ENUMERAL_TYPE
12498                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12499                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12500                       goto foundaggr;
12501                   }
12502               cp_error
12503                 ("`%D' must have an argument of class or enumerated type",
12504                  decl);
12505             foundaggr:
12506               ;
12507             }
12508         }
12509
12510       if (operator_code == CALL_EXPR)
12511         return;                 /* No restrictions on args. */
12512
12513       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12514         {
12515           tree t = TREE_TYPE (name);
12516           if (! friendp)
12517             {
12518               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12519               const char *what = 0;
12520
12521               if (ref)
12522                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12523
12524               if (TREE_CODE (t) == VOID_TYPE)
12525                 what = "void";
12526               else if (t == current_class_type)
12527                 what = "the same type";
12528               /* Don't force t to be complete here.  */
12529               else if (IS_AGGR_TYPE (t)
12530                        && COMPLETE_TYPE_P (t)
12531                        && DERIVED_FROM_P (t, current_class_type))
12532                 what = "a base class";
12533
12534               if (what)
12535                 warning ("conversion to %s%s will never use a type conversion operator",
12536                          ref ? "a reference to " : "", what);
12537             }
12538         }
12539
12540       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12541           && operator_code == NOP_EXPR)
12542         {
12543           tree parmtype;
12544
12545           if (arity != 2 && methodp)
12546             {
12547               cp_error ("`%D' must take exactly one argument", decl);
12548               return;
12549             }
12550           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12551
12552           /* [class.copy]
12553
12554              A user-declared copy assignment operator X::operator= is
12555              a non-static non-template member function of class X with
12556              exactly one parameter of type X, X&, const X&, volatile
12557              X& or const volatile X&.  */
12558           if (copy_assignment_arg_p (parmtype, virtualp)
12559               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12560                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12561               && ! friendp)
12562             {
12563               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12564               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12565                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12566                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12567             }
12568         }
12569       else if (operator_code == COND_EXPR)
12570         {
12571           /* 13.4.0.3 */
12572           cp_error ("ISO C++ prohibits overloading operator ?:");
12573         }
12574       else if (ambi_op_p (operator_code))
12575         {
12576           if (arity == 1)
12577             /* We pick the one-argument operator codes by default, so
12578                we don't have to change anything.  */
12579             ;
12580           else if (arity == 2)
12581             {
12582               /* If we thought this was a unary operator, we now know
12583                  it to be a binary operator.  */
12584               switch (operator_code)
12585                 {
12586                 case INDIRECT_REF:
12587                   operator_code = MULT_EXPR;
12588                   break;
12589
12590                 case ADDR_EXPR:
12591                   operator_code = BIT_AND_EXPR;
12592                   break;
12593
12594                 case CONVERT_EXPR:
12595                   operator_code = PLUS_EXPR;
12596                   break;
12597
12598                 case NEGATE_EXPR:
12599                   operator_code = MINUS_EXPR;
12600                   break;
12601
12602                 case PREINCREMENT_EXPR:
12603                   operator_code = POSTINCREMENT_EXPR;
12604                   break;
12605
12606                 case PREDECREMENT_EXPR:
12607                   operator_code = POSTDECREMENT_EXPR;
12608                   break;
12609
12610                 default:
12611                   my_friendly_abort (20000527);
12612                 }
12613
12614               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12615
12616               if ((operator_code == POSTINCREMENT_EXPR
12617                    || operator_code == POSTDECREMENT_EXPR)
12618                   && ! processing_template_decl
12619                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12620                 {
12621                   if (methodp)
12622                     cp_error ("postfix `%D' must take `int' as its argument",
12623                               decl);
12624                   else
12625                     cp_error
12626                       ("postfix `%D' must take `int' as its second argument",
12627                        decl);
12628                 }
12629             }
12630           else
12631             {
12632               if (methodp)
12633                 cp_error ("`%D' must take either zero or one argument", decl);
12634               else
12635                 cp_error ("`%D' must take either one or two arguments", decl);
12636             }
12637
12638           /* More Effective C++ rule 6.  */
12639           if (warn_ecpp
12640               && (operator_code == POSTINCREMENT_EXPR
12641                   || operator_code == POSTDECREMENT_EXPR
12642                   || operator_code == PREINCREMENT_EXPR
12643                   || operator_code == PREDECREMENT_EXPR))
12644             {
12645               tree arg = TREE_VALUE (argtypes);
12646               tree ret = TREE_TYPE (TREE_TYPE (decl));
12647               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12648                 arg = TREE_TYPE (arg);
12649               arg = TYPE_MAIN_VARIANT (arg);
12650               if (operator_code == PREINCREMENT_EXPR
12651                   || operator_code == PREDECREMENT_EXPR)
12652                 {
12653                   if (TREE_CODE (ret) != REFERENCE_TYPE
12654                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12655                                        arg))
12656                     cp_warning ("prefix `%D' should return `%T'", decl,
12657                                 build_reference_type (arg));
12658                 }
12659               else
12660                 {
12661                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12662                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12663                 }
12664             }
12665         }
12666       else if (unary_op_p (operator_code))
12667         {
12668           if (arity != 1)
12669             {
12670               if (methodp)
12671                 cp_error ("`%D' must take `void'", decl);
12672               else
12673                 cp_error ("`%D' must take exactly one argument", decl);
12674             }
12675         }
12676       else /* if (binary_op_p (operator_code)) */
12677         {
12678           if (arity != 2)
12679             {
12680               if (methodp)
12681                 cp_error ("`%D' must take exactly one argument", decl);
12682               else
12683                 cp_error ("`%D' must take exactly two arguments", decl);
12684             }
12685
12686           /* More Effective C++ rule 7.  */
12687           if (warn_ecpp
12688               && (operator_code == TRUTH_ANDIF_EXPR
12689                   || operator_code == TRUTH_ORIF_EXPR
12690                   || operator_code == COMPOUND_EXPR))
12691             cp_warning ("user-defined `%D' always evaluates both arguments",
12692                         decl);
12693         }
12694
12695       /* Effective C++ rule 23.  */
12696       if (warn_ecpp
12697           && arity == 2
12698           && (operator_code == PLUS_EXPR
12699               || operator_code == MINUS_EXPR
12700               || operator_code == TRUNC_DIV_EXPR
12701               || operator_code == MULT_EXPR)
12702           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12703         cp_warning ("`%D' should return by value", decl);
12704
12705       /* 13.4.0.8 */
12706       for (; argtypes && argtypes != void_list_node;
12707           argtypes = TREE_CHAIN (argtypes))
12708         if (TREE_PURPOSE (argtypes))
12709           {
12710             TREE_PURPOSE (argtypes) = NULL_TREE;
12711             if (operator_code == POSTINCREMENT_EXPR
12712                 || operator_code == POSTDECREMENT_EXPR)
12713               {
12714                 if (pedantic)
12715                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12716               }
12717             else
12718               cp_error ("`%D' cannot have default arguments", decl);
12719           }
12720
12721     }
12722 }
12723 \f
12724 static const char *
12725 tag_name (code)
12726      enum tag_types code;
12727 {
12728   switch (code)
12729     {
12730     case record_type:
12731       return "struct";
12732     case class_type:
12733       return "class";
12734     case union_type:
12735       return "union ";
12736     case enum_type:
12737       return "enum";
12738     default:
12739       my_friendly_abort (981122);
12740     }
12741 }
12742
12743 /* Get the struct, enum or union (CODE says which) with tag NAME.
12744    Define the tag as a forward-reference if it is not defined.
12745
12746    C++: If a class derivation is given, process it here, and report
12747    an error if multiple derivation declarations are not identical.
12748
12749    If this is a definition, come in through xref_tag and only look in
12750    the current frame for the name (since C++ allows new names in any
12751    scope.)  */
12752
12753 tree
12754 xref_tag (code_type_node, name, globalize)
12755      tree code_type_node;
12756      tree name;
12757      int globalize;
12758 {
12759   enum tag_types tag_code;
12760   enum tree_code code;
12761   register tree ref, t;
12762   struct binding_level *b = current_binding_level;
12763   int got_type = 0;
12764   tree attributes = NULL_TREE;
12765   tree context = NULL_TREE;
12766
12767   /* If we are called from the parser, code_type_node will sometimes be a
12768      TREE_LIST.  This indicates that the user wrote
12769      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12770      use them later.  */
12771   if (TREE_CODE (code_type_node) == TREE_LIST)
12772     {
12773       attributes = TREE_PURPOSE (code_type_node);
12774       code_type_node = TREE_VALUE (code_type_node);
12775     }
12776
12777   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12778   switch (tag_code)
12779     {
12780     case record_type:
12781     case class_type:
12782       code = RECORD_TYPE;
12783       break;
12784     case union_type:
12785       code = UNION_TYPE;
12786       break;
12787     case enum_type:
12788       code = ENUMERAL_TYPE;
12789       break;
12790     default:
12791       my_friendly_abort (18);
12792     }
12793
12794   /* If a cross reference is requested, look up the type
12795      already defined for this tag and return it.  */
12796   if (TYPE_P (name))
12797     {
12798       t = name;
12799       name = TYPE_IDENTIFIER (t);
12800       got_type = 1;
12801     }
12802   else
12803     t = IDENTIFIER_TYPE_VALUE (name);
12804
12805   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12806   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12807     {
12808       static int explained;
12809
12810       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12811 to refer to the inherited type, say `%s %T::%T'%s",
12812                   tag_name (tag_code), name, tag_name (tag_code),
12813                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12814                   (!explained ? "\n\
12815 (names from dependent base classes are not visible to unqualified name lookup)"
12816                    : ""));
12817
12818       explained = 1;
12819     }
12820
12821   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12822       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12823     t = NULL_TREE;
12824
12825   if (! globalize)
12826     {
12827       /* If we know we are defining this tag, only look it up in
12828          this scope and don't try to find it as a type.  */
12829       ref = lookup_tag (code, name, b, 1);
12830     }
12831   else
12832     {
12833       if (t)
12834         {
12835           /* [dcl.type.elab] If the identifier resolves to a
12836              typedef-name or a template type-parameter, the
12837              elaborated-type-specifier is ill-formed.  */
12838           if (t != TYPE_MAIN_VARIANT (t)
12839               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12840             cp_pedwarn ("using typedef-name `%D' after `%s'",
12841                         TYPE_NAME (t), tag_name (tag_code));
12842           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12843             cp_error ("using template type parameter `%T' after `%s'",
12844                       t, tag_name (tag_code));
12845
12846           ref = t;
12847         }
12848       else
12849         ref = lookup_tag (code, name, b, 0);
12850
12851       if (! ref)
12852         {
12853           /* Try finding it as a type declaration.  If that wins,
12854              use it.  */
12855           ref = lookup_name (name, 1);
12856
12857           if (ref != NULL_TREE
12858               && processing_template_decl
12859               && DECL_CLASS_TEMPLATE_P (ref)
12860               && template_class_depth (current_class_type) == 0)
12861             /* Since GLOBALIZE is true, we're declaring a global
12862                template, so we want this type.  */
12863             ref = DECL_TEMPLATE_RESULT (ref);
12864
12865           if (ref && TREE_CODE (ref) == TYPE_DECL
12866               && TREE_CODE (TREE_TYPE (ref)) == code)
12867             ref = TREE_TYPE (ref);
12868           else
12869             ref = NULL_TREE;
12870         }
12871
12872       if (ref && current_class_type
12873           && template_class_depth (current_class_type)
12874           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12875         {
12876           /* Since GLOBALIZE is non-zero, we are not looking at a
12877              definition of this tag.  Since, in addition, we are currently
12878              processing a (member) template declaration of a template
12879              class, we must be very careful; consider:
12880
12881                template <class X>
12882                struct S1
12883
12884                template <class U>
12885                struct S2
12886                { template <class V>
12887                friend struct S1; };
12888
12889              Here, the S2::S1 declaration should not be confused with the
12890              outer declaration.  In particular, the inner version should
12891              have a template parameter of level 2, not level 1.  This
12892              would be particularly important if the member declaration
12893              were instead:
12894
12895                template <class V = U> friend struct S1;
12896
12897              say, when we should tsubst into `U' when instantiating
12898              S2.  On the other hand, when presented with:
12899
12900                  template <class T>
12901                  struct S1 {
12902                    template <class U>
12903                    struct S2 {};
12904                    template <class U>
12905                    friend struct S2;
12906                  };
12907
12908               we must find the inner binding eventually.  We
12909               accomplish this by making sure that the new type we
12910               create to represent this declaration has the right
12911               TYPE_CONTEXT.  */
12912           context = TYPE_CONTEXT (ref);
12913           ref = NULL_TREE;
12914         }
12915     }
12916
12917   if (! ref)
12918     {
12919       /* If no such tag is yet defined, create a forward-reference node
12920          and record it as the "definition".
12921          When a real declaration of this type is found,
12922          the forward-reference will be altered into a real type.  */
12923       if (code == ENUMERAL_TYPE)
12924         {
12925           cp_error ("use of enum `%#D' without previous declaration", name);
12926
12927           ref = make_node (ENUMERAL_TYPE);
12928
12929           /* Give the type a default layout like unsigned int
12930              to avoid crashing if it does not get defined.  */
12931           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12932           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12933           TYPE_USER_ALIGN (ref) = 0;
12934           TREE_UNSIGNED (ref) = 1;
12935           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12936           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12937           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12938
12939           /* Enable us to recognize when a type is created in class context.
12940              To do nested classes correctly, this should probably be cleared
12941              out when we leave this classes scope.  Currently this in only
12942              done in `start_enum'.  */
12943
12944           pushtag (name, ref, globalize);
12945         }
12946       else
12947         {
12948           struct binding_level *old_b = class_binding_level;
12949
12950           ref = make_aggr_type (code);
12951           TYPE_CONTEXT (ref) = context;
12952
12953 #ifdef NONNESTED_CLASSES
12954           /* Class types don't nest the way enums do.  */
12955           class_binding_level = (struct binding_level *)0;
12956 #endif
12957           pushtag (name, ref, globalize);
12958           class_binding_level = old_b;
12959         }
12960     }
12961   else
12962     {
12963       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12964         redeclare_class_template (ref, current_template_parms);
12965     }
12966
12967   /* Until the type is defined, tentatively accept whatever
12968      structure tag the user hands us.  */
12969   if (!COMPLETE_TYPE_P (ref)
12970       && ref != current_class_type
12971       /* Have to check this, in case we have contradictory tag info.  */
12972       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12973     {
12974       if (tag_code == class_type)
12975         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12976       else if (tag_code == record_type)
12977         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12978     }
12979
12980   TREE_TYPE (ref) = attributes;
12981
12982   return ref;
12983 }
12984
12985 tree
12986 xref_tag_from_type (old, id, globalize)
12987      tree old, id;
12988      int globalize;
12989 {
12990   tree code_type_node;
12991
12992   if (TREE_CODE (old) == RECORD_TYPE)
12993     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12994                       ? class_type_node : record_type_node);
12995   else
12996     code_type_node = union_type_node;
12997
12998   if (id == NULL_TREE)
12999     id = TYPE_IDENTIFIER (old);
13000
13001   return xref_tag (code_type_node, id, globalize);
13002 }
13003
13004 /* REF is a type (named NAME), for which we have just seen some
13005    baseclasses.  BINFO is a list of those baseclasses; the
13006    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13007    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13008    struct, or union.  */
13009
13010 void
13011 xref_basetypes (code_type_node, name, ref, binfo)
13012      tree code_type_node;
13013      tree name, ref;
13014      tree binfo;
13015 {
13016   /* In the declaration `A : X, Y, ... Z' we mark all the types
13017      (A, X, Y, ..., Z) so we can check for duplicates.  */
13018   tree binfos;
13019   tree base;
13020
13021   int i, len;
13022   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13023
13024   if (tag_code == union_type)
13025     {
13026       cp_error ("derived union `%T' invalid", ref);
13027       return;
13028     }
13029
13030   len = list_length (binfo);
13031
13032   /* First, make sure that any templates in base-classes are
13033      instantiated.  This ensures that if we call ourselves recursively
13034      we do not get confused about which classes are marked and which
13035      are not.  */
13036   for (base = binfo; base; base = TREE_CHAIN (base))
13037     complete_type (TREE_VALUE (base));
13038
13039   SET_CLASSTYPE_MARKED (ref);
13040   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13041
13042   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13043     {
13044       /* The base of a derived struct is public by default.  */
13045       int via_public
13046         = (TREE_PURPOSE (binfo) == access_public_node
13047            || TREE_PURPOSE (binfo) == access_public_virtual_node
13048            || (tag_code != class_type
13049                && (TREE_PURPOSE (binfo) == access_default_node
13050                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13051       int via_protected
13052         = (TREE_PURPOSE (binfo) == access_protected_node
13053            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13054       int via_virtual
13055         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13056            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13057            || TREE_PURPOSE (binfo) == access_public_virtual_node
13058            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13059       tree basetype = TREE_VALUE (binfo);
13060       tree base_binfo;
13061
13062       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13063         basetype = TREE_TYPE (basetype);
13064       if (!basetype
13065           || (TREE_CODE (basetype) != RECORD_TYPE
13066               && TREE_CODE (basetype) != TYPENAME_TYPE
13067               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13068               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13069         {
13070           cp_error ("base type `%T' fails to be a struct or class type",
13071                     TREE_VALUE (binfo));
13072           continue;
13073         }
13074
13075       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13076
13077       /* This code replaces similar code in layout_basetypes.
13078          We put the complete_type first for implicit `typename'.  */
13079       if (!COMPLETE_TYPE_P (basetype)
13080           && ! (current_template_parms && uses_template_parms (basetype)))
13081         {
13082           cp_error ("base class `%T' has incomplete type", basetype);
13083           continue;
13084         }
13085       else
13086         {
13087           if (CLASSTYPE_MARKED (basetype))
13088             {
13089               if (basetype == ref)
13090                 cp_error ("recursive type `%T' undefined", basetype);
13091               else
13092                 cp_error ("duplicate base type `%T' invalid", basetype);
13093               continue;
13094             }
13095
13096           if (TYPE_FOR_JAVA (basetype)
13097               && (current_lang_stack
13098                   == &VARRAY_TREE (current_lang_base, 0)))
13099             TYPE_FOR_JAVA (ref) = 1;
13100
13101           /* Note that the BINFO records which describe individual
13102              inheritances are *not* shared in the lattice!  They
13103              cannot be shared because a given baseclass may be
13104              inherited with different `accessibility' by different
13105              derived classes.  (Each BINFO record describing an
13106              individual inheritance contains flags which say what
13107              the `accessibility' of that particular inheritance is.)  */
13108
13109           base_binfo
13110             = make_binfo (size_zero_node, basetype,
13111                           CLASS_TYPE_P (basetype)
13112                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13113                           CLASS_TYPE_P (basetype)
13114                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13115
13116           TREE_VEC_ELT (binfos, i) = base_binfo;
13117           TREE_VIA_PUBLIC (base_binfo) = via_public;
13118           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13119           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13120           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13121
13122           /* We need to unshare the binfos now so that lookups during class
13123              definition work.  */
13124           unshare_base_binfos (base_binfo);
13125
13126           SET_CLASSTYPE_MARKED (basetype);
13127
13128           /* We are free to modify these bits because they are meaningless
13129              at top level, and BASETYPE is a top-level type.  */
13130           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13131             {
13132               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13133               /* Converting to a virtual base class requires looking
13134                  up the offset of the virtual base.  */
13135               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13136             }
13137
13138           if (CLASS_TYPE_P (basetype))
13139             {
13140               TYPE_HAS_NEW_OPERATOR (ref)
13141                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13142               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13143                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13144               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13145               /* If the base-class uses multiple inheritance, so do we.  */
13146               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13147                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13148               /* Likewise, if converting to a base of the base may require
13149                  code, then we may need to generate code to convert to a
13150                  base as well.  */
13151               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13152                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13153             }
13154
13155           i += 1;
13156         }
13157     }
13158   if (i)
13159     TREE_VEC_LENGTH (binfos) = i;
13160   else
13161     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13162
13163   if (i > 1)
13164     {
13165       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13166       /* If there is more than one non-empty they cannot be at the same
13167          address.  */
13168       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13169     }
13170
13171   /* Unmark all the types.  */
13172   while (--i >= 0)
13173     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13174   CLEAR_CLASSTYPE_MARKED (ref);
13175
13176   /* Now that we know all the base-classes, set up the list of virtual
13177      bases.  */
13178   get_vbase_types (ref);
13179 }
13180
13181 \f
13182 /* Begin compiling the definition of an enumeration type.
13183    NAME is its name (or null if anonymous).
13184    Returns the type object, as yet incomplete.
13185    Also records info about it so that build_enumerator
13186    may be used to declare the individual values as they are read.  */
13187
13188 tree
13189 start_enum (name)
13190      tree name;
13191 {
13192   register tree enumtype = NULL_TREE;
13193   struct binding_level *b = current_binding_level;
13194
13195   /* If this is the real definition for a previous forward reference,
13196      fill in the contents in the same object that used to be the
13197      forward reference.  */
13198
13199   if (name != NULL_TREE)
13200     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13201
13202   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13203     {
13204       cp_error ("multiple definition of `%#T'", enumtype);
13205       cp_error_at ("previous definition here", enumtype);
13206       /* Clear out TYPE_VALUES, and start again.  */
13207       TYPE_VALUES (enumtype) = NULL_TREE;
13208     }
13209   else
13210     {
13211       enumtype = make_node (ENUMERAL_TYPE);
13212       pushtag (name, enumtype, 0);
13213     }
13214
13215   if (current_class_type)
13216     TREE_ADDRESSABLE (b->tags) = 1;
13217
13218   GNU_xref_decl (current_function_decl, enumtype);
13219   return enumtype;
13220 }
13221
13222 /* After processing and defining all the values of an enumeration type,
13223    install their decls in the enumeration type and finish it off.
13224    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13225    Returns ENUMTYPE.  */
13226
13227 tree
13228 finish_enum (enumtype)
13229      tree enumtype;
13230 {
13231   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13232   /* Calculate the maximum value of any enumerator in this type.  */
13233
13234   tree values = TYPE_VALUES (enumtype);
13235   if (values)
13236     {
13237       tree pair;
13238
13239       for (pair = values; pair; pair = TREE_CHAIN (pair))
13240         {
13241           tree decl;
13242           tree value;
13243
13244           /* The TREE_VALUE is a CONST_DECL for this enumeration
13245              constant.  */
13246           decl = TREE_VALUE (pair);
13247
13248           /* [dcl.enum]
13249
13250              Following the closing brace of an enum-specifier, each
13251              enumerator has the type of its enumeration.  Prior to the
13252              closing brace, the type of each enumerator is the type of
13253              its initializing value.  */
13254           TREE_TYPE (decl) = enumtype;
13255
13256           /* The DECL_INITIAL will be NULL if we are processing a
13257              template declaration and this enumeration constant had no
13258              explicit initializer.  */
13259           value = DECL_INITIAL (decl);
13260           if (value && !processing_template_decl)
13261             {
13262               /* Set the TREE_TYPE for the VALUE as well.  That's so
13263                  that when we call decl_constant_value we get an
13264                  entity of the right type (but with the constant
13265                  value).  Since we shouldn't ever call
13266                  decl_constant_value on a template type, there's no
13267                  reason to do that when processing_template_decl.
13268                  And, if the expression is something like a
13269                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13270                  wreak havoc on the intended type of the expression.
13271
13272                  Of course, there's also no point in trying to compute
13273                  minimum or maximum values if we're in a template.  */
13274               TREE_TYPE (value) = enumtype;
13275
13276               if (!minnode)
13277                 minnode = maxnode = value;
13278               else if (tree_int_cst_lt (maxnode, value))
13279                 maxnode = value;
13280               else if (tree_int_cst_lt (value, minnode))
13281                 minnode = value;
13282             }
13283
13284           if (processing_template_decl)
13285             /* If this is just a template, leave the CONST_DECL
13286                alone.  That way tsubst_copy will find CONST_DECLs for
13287                CONST_DECLs, and not INTEGER_CSTs.  */
13288             ;
13289           else
13290             /* In the list we're building up, we want the enumeration
13291                values, not the CONST_DECLs.  */
13292             TREE_VALUE (pair) = value;
13293         }
13294     }
13295   else
13296     maxnode = minnode = integer_zero_node;
13297
13298   TYPE_VALUES (enumtype) = nreverse (values);
13299
13300   if (processing_template_decl)
13301     {
13302       tree scope = current_scope ();
13303       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13304         add_stmt (build_min (TAG_DEFN, enumtype));
13305     }
13306   else
13307     {
13308       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13309       int lowprec = min_precision (minnode, unsignedp);
13310       int highprec = min_precision (maxnode, unsignedp);
13311       int precision = MAX (lowprec, highprec);
13312       tree tem;
13313
13314       TYPE_SIZE (enumtype) = NULL_TREE;
13315
13316       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13317
13318       TYPE_PRECISION (enumtype) = precision;
13319       if (unsignedp)
13320         fixup_unsigned_type (enumtype);
13321       else
13322         fixup_signed_type (enumtype);
13323
13324       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13325         /* Use the width of the narrowest normal C type which is wide
13326            enough.  */
13327         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13328                                                     (precision, 1));
13329       else
13330         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13331
13332       TYPE_SIZE (enumtype) = 0;
13333       layout_type (enumtype);
13334
13335       /* Fix up all variant types of this enum type.  */
13336       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13337            tem = TYPE_NEXT_VARIANT (tem))
13338         {
13339           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13340           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13341           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13342           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13343           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13344           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13345           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13346           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13347           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13348           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13349         }
13350
13351       /* Finish debugging output for this type.  */
13352       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13353     }
13354
13355   return enumtype;
13356 }
13357
13358 /* Build and install a CONST_DECL for an enumeration constant of the
13359    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13360    Assignment of sequential values by default is handled here.  */
13361
13362 void
13363 build_enumerator (name, value, enumtype)
13364      tree name;
13365      tree value;
13366      tree enumtype;
13367 {
13368   tree decl;
13369   tree context;
13370   tree type;
13371   tree values;
13372
13373   /* Remove no-op casts from the value.  */
13374   if (value)
13375     STRIP_TYPE_NOPS (value);
13376
13377   if (! processing_template_decl)
13378     {
13379       /* Validate and default VALUE.  */
13380       if (value != NULL_TREE)
13381         {
13382           value = decl_constant_value (value);
13383
13384           if (TREE_CODE (value) == INTEGER_CST)
13385             {
13386               value = default_conversion (value);
13387               constant_expression_warning (value);
13388             }
13389           else
13390             {
13391               cp_error ("enumerator value for `%D' not integer constant", name);
13392               value = NULL_TREE;
13393             }
13394         }
13395
13396       /* Default based on previous value.  */
13397       if (value == NULL_TREE && ! processing_template_decl)
13398         {
13399           tree prev_value;
13400
13401           if (TYPE_VALUES (enumtype))
13402             {
13403               /* The next value is the previous value ... */
13404               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13405               /* ... plus one.  */
13406               value = cp_build_binary_op (PLUS_EXPR,
13407                                           prev_value,
13408                                           integer_one_node);
13409
13410               if (tree_int_cst_lt (value, prev_value))
13411                 cp_error ("overflow in enumeration values at `%D'", name);
13412             }
13413           else
13414             value = integer_zero_node;
13415         }
13416
13417       /* Remove no-op casts from the value.  */
13418       if (value)
13419         STRIP_TYPE_NOPS (value);
13420 #if 0
13421       /* To fix MAX_VAL enum consts. (bkoz)  */
13422       TREE_TYPE (value) = integer_type_node;
13423 #endif
13424     }
13425
13426   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13427      Even in other cases, we will later (in finish_enum) be setting
13428      the type of VALUE.  But, we don't need to make a copy if this
13429      VALUE is one of the enumeration constants for this same
13430      enumeration type.  */
13431   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13432     if (TREE_VALUE (values) == value)
13433       break;
13434   /* If we didn't break out of the loop, then we do need a copy.  */
13435   if (!values && value)
13436     value = copy_node (value);
13437
13438   /* C++ associates enums with global, function, or class declarations.  */
13439   context = current_scope ();
13440
13441   /* Build the actual enumeration constant.  Note that the enumeration
13442     constants have the type of their initializers until the
13443     enumeration is complete:
13444
13445       [ dcl.enum ]
13446
13447       Following the closing brace of an enum-specifier, each enumer-
13448       ator has the type of its enumeration.  Prior to the closing
13449       brace, the type of each enumerator is the type of its
13450       initializing value.
13451
13452     In finish_enum we will reset the type.  Of course, if we're
13453     processing a template, there may be no value.   */
13454   type = value ? TREE_TYPE (value) : NULL_TREE;
13455
13456   if (context && context == current_class_type)
13457     /* This enum declaration is local to the class.  We need the full
13458        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13459     decl = build_lang_decl (CONST_DECL, name, type);
13460   else
13461     /* It's a global enum, or it's local to a function.  (Note local to
13462       a function could mean local to a class method.  */
13463     decl = build_decl (CONST_DECL, name, type);
13464
13465   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13466   DECL_INITIAL (decl) = value;
13467   TREE_READONLY (decl) = 1;
13468
13469   if (context && context == current_class_type)
13470     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13471       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13472       things like `S::i' later.)  */
13473     finish_member_declaration (decl);
13474   else
13475     {
13476       pushdecl (decl);
13477       GNU_xref_decl (current_function_decl, decl);
13478     }
13479
13480   /* Add this enumeration constant to the list for this type.  */
13481   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13482 }
13483
13484 \f
13485 /* We're defining DECL.  Make sure that it's type is OK.  */
13486
13487 static void
13488 check_function_type (decl, current_function_parms)
13489      tree decl;
13490      tree current_function_parms;
13491 {
13492   tree fntype = TREE_TYPE (decl);
13493   tree return_type = complete_type (TREE_TYPE (fntype));
13494
13495   /* In a function definition, arg types must be complete.  */
13496   require_complete_types_for_parms (current_function_parms);
13497
13498   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13499     {
13500       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13501
13502       /* Make it return void instead, but don't change the
13503          type of the DECL_RESULT, in case we have a named return value.  */
13504       if (TREE_CODE (fntype) == METHOD_TYPE)
13505         {
13506           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13507           TREE_TYPE (decl)
13508             = build_cplus_method_type (ctype,
13509                                        void_type_node,
13510                                        FUNCTION_ARG_CHAIN (decl));
13511         }
13512       else
13513         TREE_TYPE (decl)
13514           = build_function_type (void_type_node,
13515                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13516       TREE_TYPE (decl)
13517         = build_exception_variant (fntype,
13518                                    TYPE_RAISES_EXCEPTIONS (fntype));
13519     }
13520   else
13521     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13522 }
13523
13524 /* Create the FUNCTION_DECL for a function definition.
13525    DECLSPECS and DECLARATOR are the parts of the declaration;
13526    they describe the function's name and the type it returns,
13527    but twisted together in a fashion that parallels the syntax of C.
13528
13529    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13530    DECLARATOR is really the DECL for the function we are about to
13531    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13532    indicating that the function is an inline defined in-class.
13533
13534    This function creates a binding context for the function body
13535    as well as setting up the FUNCTION_DECL in current_function_decl.
13536
13537    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13538    (it defines a datum instead), we return 0, which tells
13539    yyparse to report a parse error.
13540
13541    For C++, we must first check whether that datum makes any sense.
13542    For example, "class A local_a(1,2);" means that variable local_a
13543    is an aggregate of type A, which should have a constructor
13544    applied to it with the argument list [1, 2].  */
13545
13546 int
13547 start_function (declspecs, declarator, attrs, flags)
13548      tree declspecs, declarator, attrs;
13549      int flags;
13550 {
13551   tree decl1;
13552   tree ctype = NULL_TREE;
13553   tree fntype;
13554   tree restype;
13555   extern int have_extern_spec;
13556   extern int used_extern_spec;
13557   int doing_friend = 0;
13558   struct binding_level *bl;
13559   tree current_function_parms;
13560
13561   /* Sanity check.  */
13562   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13563   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13564
13565   /* This should only be done once on the top most decl.  */
13566   if (have_extern_spec && !used_extern_spec)
13567     {
13568       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13569       used_extern_spec = 1;
13570     }
13571
13572   if (flags & SF_PRE_PARSED)
13573     {
13574       decl1 = declarator;
13575
13576       fntype = TREE_TYPE (decl1);
13577       if (TREE_CODE (fntype) == METHOD_TYPE)
13578         ctype = TYPE_METHOD_BASETYPE (fntype);
13579
13580       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13581          the (lexical) scope of the class in which it is defined.  */
13582       if (!ctype && DECL_FRIEND_P (decl1))
13583         {
13584           ctype = DECL_FRIEND_CONTEXT (decl1);
13585
13586           /* CTYPE could be null here if we're dealing with a template;
13587              for example, `inline friend float foo()' inside a template
13588              will have no CTYPE set.  */
13589           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13590             ctype = NULL_TREE;
13591           else
13592             doing_friend = 1;
13593         }
13594
13595       last_function_parms = DECL_ARGUMENTS (decl1);
13596       last_function_parm_tags = NULL_TREE;
13597     }
13598   else
13599     {
13600       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13601       /* If the declarator is not suitable for a function definition,
13602          cause a syntax error.  */
13603       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13604
13605       fntype = TREE_TYPE (decl1);
13606
13607       restype = TREE_TYPE (fntype);
13608       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13609         {
13610           cp_error ("semicolon missing after declaration of `%#T'", restype);
13611           shadow_tag (build_tree_list (NULL_TREE, restype));
13612           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13613           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13614             fntype = build_function_type (integer_type_node,
13615                                           TYPE_ARG_TYPES (fntype));
13616           else
13617             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13618                                               integer_type_node,
13619                                               TYPE_ARG_TYPES (fntype));
13620           TREE_TYPE (decl1) = fntype;
13621         }
13622
13623       if (TREE_CODE (fntype) == METHOD_TYPE)
13624         ctype = TYPE_METHOD_BASETYPE (fntype);
13625       else if (DECL_MAIN_P (decl1))
13626         {
13627           /* If this doesn't return integer_type, complain.  */
13628           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13629             {
13630               if (pedantic || warn_return_type)
13631                 pedwarn ("return type for `main' changed to `int'");
13632               TREE_TYPE (decl1) = fntype = default_function_type;
13633             }
13634         }
13635     }
13636
13637   /* Sometimes we don't notice that a function is a static member, and
13638      build a METHOD_TYPE for it.  Fix that up now.  */
13639   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13640       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13641     {
13642       revert_static_member_fn (decl1);
13643       last_function_parms = TREE_CHAIN (last_function_parms);
13644       ctype = NULL_TREE;
13645     }
13646
13647   /* Warn if function was previously implicitly declared
13648      (but not if we warned then).  */
13649   if (! warn_implicit
13650       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13651     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13652
13653   /* Set up current_class_type, and enter the scope of the class, if
13654      appropriate.  */
13655   if (ctype)
13656     push_nested_class (ctype, 1);
13657   else if (DECL_STATIC_FUNCTION_P (decl1))
13658     push_nested_class (DECL_CONTEXT (decl1), 2);
13659
13660   /* Now that we have entered the scope of the class, we must restore
13661      the bindings for any template parameters surrounding DECL1, if it
13662      is an inline member template.  (Order is important; consider the
13663      case where a template parameter has the same name as a field of
13664      the class.)  It is not until after this point that
13665      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13666   if (flags & SF_INCLASS_INLINE)
13667     maybe_begin_member_template_processing (decl1);
13668
13669   /* Effective C++ rule 15.  */
13670   if (warn_ecpp
13671       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13672       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13673     cp_warning ("`operator=' should return a reference to `*this'");
13674
13675   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13676      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13677   if (!DECL_INITIAL (decl1))
13678     DECL_INITIAL (decl1) = error_mark_node;
13679
13680 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13681   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13682 #endif
13683
13684   /* This function exists in static storage.
13685      (This does not mean `static' in the C sense!)  */
13686   TREE_STATIC (decl1) = 1;
13687
13688   /* We must call push_template_decl after current_class_type is set
13689      up.  (If we are processing inline definitions after exiting a
13690      class scope, current_class_type will be NULL_TREE until set above
13691      by push_nested_class.)  */
13692   if (processing_template_decl)
13693     decl1 = push_template_decl (decl1);
13694
13695   /* We are now in the scope of the function being defined.  */
13696   current_function_decl = decl1;
13697
13698   /* Save the parm names or decls from this function's declarator
13699      where store_parm_decls will find them.  */
13700   current_function_parms = last_function_parms;
13701   current_function_parm_tags = last_function_parm_tags;
13702
13703   /* Make sure the parameter and return types are reasonable.  When
13704      you declare a function, these types can be incomplete, but they
13705      must be complete when you define the function.  */
13706   if (! processing_template_decl)
13707     check_function_type (decl1, current_function_parms);
13708
13709   /* Build the return declaration for the function.  */
13710   restype = TREE_TYPE (fntype);
13711   if (!processing_template_decl)
13712     {
13713       if (!DECL_RESULT (decl1))
13714         {
13715           DECL_RESULT (decl1)
13716             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13717           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13718                                       DECL_RESULT (decl1));
13719         }
13720     }
13721   else
13722     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13723     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13724
13725   /* Initialize RTL machinery.  We cannot do this until
13726      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13727      even when processing a template; this is how we get
13728      CFUN set up, and our per-function variables initialized.  */
13729   bl = current_binding_level;
13730   init_function_start (decl1, input_filename, lineno);
13731   current_binding_level = bl;
13732
13733   /* Even though we're inside a function body, we still don't want to
13734      call expand_expr to calculate the size of a variable-sized array.
13735      We haven't necessarily assigned RTL to all variables yet, so it's
13736      not safe to try to expand expressions involving them.  */
13737   immediate_size_expand = 0;
13738   cfun->x_dont_save_pending_sizes_p = 1;
13739
13740   /* Start the statement-tree, start the tree now.  */
13741   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13742
13743   /* Let the user know we're compiling this function.  */
13744   announce_function (decl1);
13745
13746   /* Record the decl so that the function name is defined.
13747      If we already have a decl for this name, and it is a FUNCTION_DECL,
13748      use the old decl.  */
13749   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13750     {
13751       /* A specialization is not used to guide overload resolution.  */
13752       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13753           && ! DECL_FUNCTION_MEMBER_P (decl1))
13754         decl1 = pushdecl (decl1);
13755       else
13756         {
13757           /* We need to set the DECL_CONTEXT. */
13758           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13759             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13760           /* And make sure we have enough default args.  */
13761           check_default_args (decl1);
13762         }
13763       fntype = TREE_TYPE (decl1);
13764     }
13765
13766   /* Reset these in case the call to pushdecl changed them.  */
13767   current_function_decl = decl1;
13768   cfun->decl = decl1;
13769
13770   /* If we are (erroneously) defining a function that we have already
13771      defined before, wipe out what we knew before.  */
13772   if (!DECL_PENDING_INLINE_P (decl1)
13773       && DECL_SAVED_FUNCTION_DATA (decl1))
13774     {
13775       free (DECL_SAVED_FUNCTION_DATA (decl1));
13776       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13777     }
13778
13779   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13780     {
13781       /* We know that this was set up by `grokclassfn'.  We do not
13782          wait until `store_parm_decls', since evil parse errors may
13783          never get us to that point.  Here we keep the consistency
13784          between `current_class_type' and `current_class_ptr'.  */
13785       tree t = DECL_ARGUMENTS (decl1);
13786
13787       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13788                           162);
13789       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13790                           19990811);
13791
13792       cp_function_chain->x_current_class_ref
13793         = build_indirect_ref (t, NULL_PTR);
13794       cp_function_chain->x_current_class_ptr = t;
13795
13796       /* Constructors and destructors need to know whether they're "in
13797          charge" of initializing virtual base classes.  */
13798       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13799         current_in_charge_parm = TREE_CHAIN (t);
13800     }
13801
13802   if (DECL_INTERFACE_KNOWN (decl1))
13803     {
13804       tree ctx = decl_function_context (decl1);
13805
13806       if (DECL_NOT_REALLY_EXTERN (decl1))
13807         DECL_EXTERNAL (decl1) = 0;
13808
13809       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13810           && TREE_PUBLIC (ctx))
13811         /* This is a function in a local class in an extern inline
13812            function.  */
13813         comdat_linkage (decl1);
13814     }
13815   /* If this function belongs to an interface, it is public.
13816      If it belongs to someone else's interface, it is also external.
13817      This only affects inlines and template instantiations.  */
13818   else if (interface_unknown == 0
13819            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13820                || flag_alt_external_templates))
13821     {
13822       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13823           || processing_template_decl)
13824         {
13825           DECL_EXTERNAL (decl1)
13826             = (interface_only
13827                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13828                    && !DECL_VINDEX (decl1)));
13829
13830           /* For WIN32 we also want to put these in linkonce sections.  */
13831           maybe_make_one_only (decl1);
13832         }
13833       else
13834         DECL_EXTERNAL (decl1) = 0;
13835       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13836       DECL_INTERFACE_KNOWN (decl1) = 1;
13837     }
13838   else if (interface_unknown && interface_only
13839            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13840                || flag_alt_external_templates))
13841     {
13842       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13843          interface, we will have interface_only set but not
13844          interface_known.  In that case, we don't want to use the normal
13845          heuristics because someone will supply a #pragma implementation
13846          elsewhere, and deducing it here would produce a conflict.  */
13847       comdat_linkage (decl1);
13848       DECL_EXTERNAL (decl1) = 0;
13849       DECL_INTERFACE_KNOWN (decl1) = 1;
13850       DECL_DEFER_OUTPUT (decl1) = 1;
13851     }
13852   else
13853     {
13854       /* This is a definition, not a reference.
13855          So clear DECL_EXTERNAL.  */
13856       DECL_EXTERNAL (decl1) = 0;
13857
13858       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13859           && ! DECL_INTERFACE_KNOWN (decl1)
13860           /* Don't try to defer nested functions for now.  */
13861           && ! decl_function_context (decl1))
13862         DECL_DEFER_OUTPUT (decl1) = 1;
13863       else
13864         DECL_INTERFACE_KNOWN (decl1) = 1;
13865     }
13866
13867   pushlevel (0);
13868   current_binding_level->parm_flag = 1;
13869
13870   if (attrs)
13871     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13872
13873   /* We need to do this even if we aren't expanding yet so that
13874      assemble_external works.  */
13875   make_function_rtl (decl1);
13876
13877   /* Promote the value to int before returning it.  */
13878   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13879     restype = type_promotes_to (restype);
13880
13881   /* If this fcn was already referenced via a block-scope `extern' decl
13882      (or an implicit decl), propagate certain information about the usage.  */
13883   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13884     TREE_ADDRESSABLE (decl1) = 1;
13885
13886   if (DECL_RESULT (decl1) == NULL_TREE)
13887     {
13888       DECL_RESULT (decl1)
13889         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13890       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13891       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13892     }
13893
13894   ++function_depth;
13895
13896   if (DECL_DESTRUCTOR_P (decl1))
13897     {
13898       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13899       DECL_CONTEXT (dtor_label) = current_function_decl;
13900     }
13901   /* Under the old ABI we return `this' from constructors, so we make
13902      ordinary `return' statements in constructors jump to CTOR_LABEL;
13903      from there we return `this'.  Under the new ABI, we don't bother
13904      with any of this.  By not setting CTOR_LABEL the remainder of the
13905      machinery is automatically disabled.  */
13906   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13907     {
13908       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13909       DECL_CONTEXT (ctor_label) = current_function_decl;
13910     }
13911
13912   store_parm_decls (current_function_parms);
13913
13914   return 1;
13915 }
13916 \f
13917 /* Store the parameter declarations into the current function declaration.
13918    This is called after parsing the parameter declarations, before
13919    digesting the body of the function.
13920
13921    Also install to binding contour return value identifier, if any.  */
13922
13923 static void
13924 store_parm_decls (current_function_parms)
13925      tree current_function_parms;
13926 {
13927   register tree fndecl = current_function_decl;
13928   register tree parm;
13929   int parms_have_cleanups = 0;
13930   tree cleanups = NULL_TREE;
13931
13932   /* This is a list of types declared among parms in a prototype.  */
13933   tree parmtags = current_function_parm_tags;
13934
13935   /* This is a chain of any other decls that came in among the parm
13936      declarations.  If a parm is declared with  enum {foo, bar} x;
13937      then CONST_DECLs for foo and bar are put here.  */
13938   tree nonparms = NULL_TREE;
13939
13940   if (current_function_parms)
13941     {
13942       /* This case is when the function was defined with an ANSI prototype.
13943          The parms already have decls, so we need not do anything here
13944          except record them as in effect
13945          and complain if any redundant old-style parm decls were written.  */
13946
13947       tree specparms = current_function_parms;
13948       tree next;
13949
13950       /* Must clear this because it might contain TYPE_DECLs declared
13951              at class level.  */
13952       storedecls (NULL_TREE);
13953
13954       /* If we're doing semantic analysis, then we'll call pushdecl
13955              for each of these.  We must do them in reverse order so that
13956              they end in the correct forward order.  */
13957       specparms = nreverse (specparms);
13958
13959       for (parm = specparms; parm; parm = next)
13960         {
13961           next = TREE_CHAIN (parm);
13962           if (TREE_CODE (parm) == PARM_DECL)
13963             {
13964               tree cleanup;
13965
13966               if (DECL_NAME (parm) == NULL_TREE
13967                   || TREE_CODE (parm) != VOID_TYPE)
13968                 pushdecl (parm);
13969               else
13970                 cp_error ("parameter `%D' declared void", parm);
13971
13972               cleanup = (processing_template_decl
13973                          ? NULL_TREE
13974                          : maybe_build_cleanup (parm));
13975
13976               if (cleanup)
13977                 cleanups = tree_cons (parm, cleanup, cleanups);
13978             }
13979           else
13980             {
13981               /* If we find an enum constant or a type tag,
13982                  put it aside for the moment.  */
13983               TREE_CHAIN (parm) = NULL_TREE;
13984               nonparms = chainon (nonparms, parm);
13985             }
13986         }
13987
13988       /* Get the decls in their original chain order and record in the
13989          function.  This is all and only the PARM_DECLs that were
13990          pushed into scope by the loop above.  */
13991       DECL_ARGUMENTS (fndecl) = getdecls ();
13992       storetags (chainon (parmtags, gettags ()));
13993     }
13994   else
13995     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13996
13997   /* Now store the final chain of decls for the arguments
13998      as the decl-chain of the current lexical scope.
13999      Put the enumerators in as well, at the front so that
14000      DECL_ARGUMENTS is not modified.  */
14001   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14002
14003   /* Now that we have initialized the parms, we can start their
14004      cleanups.  We cannot do this before, since expand_decl_cleanup
14005      should not be called before the parm can be used.  */
14006   while (cleanups)
14007     {
14008       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14009                            TREE_VALUE (cleanups));
14010       cleanups = TREE_CHAIN (cleanups);
14011     }
14012
14013   /* Create a binding contour which can be used to catch
14014      cleanup-generated temporaries.  */
14015   if (parms_have_cleanups)
14016     pushlevel (0);
14017
14018   /* Do the starting of the exception specifications, if we have any.  */
14019   if (flag_exceptions && !processing_template_decl
14020       && flag_enforce_eh_specs
14021       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14022     current_eh_spec_try_block = expand_start_eh_spec ();
14023 }
14024
14025 \f
14026 /* We have finished doing semantic analysis on DECL, but have not yet
14027    generated RTL for its body.  Save away our current state, so that
14028    when we want to generate RTL later we know what to do.  */
14029
14030 static void
14031 save_function_data (decl)
14032      tree decl;
14033 {
14034   struct cp_language_function *f;
14035
14036   /* Save the language-specific per-function data so that we can
14037      get it back when we really expand this function.  */
14038   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14039                       19990908);
14040
14041   /* Make a copy.  */
14042   f = ((struct cp_language_function *)
14043        xmalloc (sizeof (struct cp_language_function)));
14044   bcopy ((char *) cp_function_chain, (char *) f,
14045          sizeof (struct cp_language_function));
14046   DECL_SAVED_FUNCTION_DATA (decl) = f;
14047
14048   /* Clear out the bits we don't need.  */
14049   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14050   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14051   f->x_named_label_uses = NULL;
14052   f->bindings = NULL;
14053
14054   /* When we get back here again, we will be expanding.  */
14055   f->x_expanding_p = 1;
14056
14057   /* If we've already decided that we cannot inline this function, we
14058      must remember that fact when we actually go to expand the
14059      function.  */
14060   f->cannot_inline = current_function_cannot_inline;
14061 }
14062
14063 /* At the end of every constructor we generate to code to return
14064    `this'.  Do that now.  */
14065
14066 static void
14067 finish_constructor_body ()
14068 {
14069   /* Any return from a constructor will end up here.  */
14070   if (ctor_label)
14071     add_stmt (build_stmt (LABEL_STMT, ctor_label));
14072
14073   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14074      generate the return, rather than a goto to CTOR_LABEL.  */
14075   ctor_label = NULL_TREE;
14076   /* In check_return_expr we translate an empty return from a
14077      constructor to a return of `this'.  */
14078   finish_return_stmt (NULL_TREE);
14079   /* Mark the end of the constructor.  */
14080   add_stmt (build_stmt (CTOR_STMT));
14081 }
14082
14083 /* At the end of every destructor we generate code to restore virtual
14084    function tables to the values desired by base classes and to call
14085    to base class destructors.  Do that now.  */
14086
14087 static void
14088 finish_destructor_body ()
14089 {
14090   tree compound_stmt;
14091   tree virtual_size;
14092   tree exprstmt;
14093   tree if_stmt;
14094
14095   /* Create a block to contain all the extra code.  */
14096   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14097
14098   /* Any return from a destructor will end up here.  */
14099   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14100
14101   /* Generate the code to call destructor on base class.  If this
14102      destructor belongs to a class with virtual functions, then set
14103      the virtual function table pointer to represent the type of our
14104      base class.  */
14105
14106   /* This side-effect makes call to `build_delete' generate the code
14107      we have to have at the end of this destructor.  `build_delete'
14108      will set the flag again.  */
14109   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14110
14111   exprstmt = build_delete (current_class_type,
14112                            current_class_ref,
14113                            sfk_base_destructor,
14114                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14115                            0);
14116
14117   if (exprstmt != error_mark_node
14118       && (TREE_CODE (exprstmt) != NOP_EXPR
14119           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14120           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14121     {
14122       if (exprstmt != void_zero_node)
14123         /* Don't call `expand_expr_stmt' if we're not going to do
14124            anything, since -Wall will give a diagnostic.  */
14125         finish_expr_stmt (exprstmt);
14126
14127       /* Run destructors for all virtual baseclasses.  */
14128       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14129         {
14130           tree vbases;
14131           tree if_stmt;
14132
14133           if_stmt = begin_if_stmt ();
14134           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14135                                       current_in_charge_parm,
14136                                       integer_two_node),
14137                                if_stmt);
14138
14139           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14140           /* The CLASSTYPE_VBASECLASSES list is in initialization
14141              order, so we have to march through it in reverse order.  */
14142           for (vbases = nreverse (copy_list (vbases));
14143                vbases;
14144                vbases = TREE_CHAIN (vbases))
14145             {
14146               tree vbase = TREE_VALUE (vbases);
14147
14148               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14149                 {
14150                   tree vb = get_vbase
14151                     (BINFO_TYPE (vbase),
14152                      TYPE_BINFO (current_class_type));
14153                   finish_expr_stmt
14154                     (build_scoped_method_call
14155                      (current_class_ref, vb, base_dtor_identifier,
14156                       NULL_TREE));
14157                 }
14158             }
14159
14160           finish_then_clause (if_stmt);
14161           finish_if_stmt ();
14162         }
14163     }
14164
14165   virtual_size = c_sizeof (current_class_type);
14166
14167   /* At the end, call delete if that's what's requested.  */
14168
14169   /* FDIS sez: At the point of definition of a virtual destructor
14170      (including an implicit definition), non-placement operator delete
14171      shall be looked up in the scope of the destructor's class and if
14172      found shall be accessible and unambiguous.
14173
14174      This is somewhat unclear, but I take it to mean that if the class
14175      only defines placement deletes we don't do anything here.  So we
14176      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14177      they ever try to delete one of these.  */
14178   exprstmt = build_op_delete_call
14179     (DELETE_EXPR, current_class_ptr, virtual_size,
14180      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14181
14182   if_stmt = begin_if_stmt ();
14183   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14184                               current_in_charge_parm,
14185                               integer_one_node),
14186                        if_stmt);
14187   finish_expr_stmt (exprstmt);
14188   finish_then_clause (if_stmt);
14189   finish_if_stmt ();
14190
14191   /* Close the block we started above.  */
14192   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14193 }
14194
14195 /* Finish up a function declaration and compile that function
14196    all the way to assembler language output.  The free the storage
14197    for the function definition.
14198
14199    FLAGS is a bitwise or of the following values:
14200      1 - CALL_POPLEVEL
14201        An extra call to poplevel (and expand_end_bindings) must be
14202        made to take care of the binding contour for the base
14203        initializers.  This is only relevant for constructors.
14204      2 - INCLASS_INLINE
14205        We just finished processing the body of an in-class inline
14206        function definition.  (This processing will have taken place
14207        after the class definition is complete.)  */
14208
14209 tree
14210 finish_function (flags)
14211      int flags;
14212 {
14213   register tree fndecl = current_function_decl;
14214   tree fntype, ctype = NULL_TREE;
14215   int call_poplevel = (flags & 1) != 0;
14216   int inclass_inline = (flags & 2) != 0;
14217   int nested;
14218
14219   /* When we get some parse errors, we can end up without a
14220      current_function_decl, so cope.  */
14221   if (fndecl == NULL_TREE)
14222     return error_mark_node;
14223
14224   nested = function_depth > 1;
14225   fntype = TREE_TYPE (fndecl);
14226
14227   /*  TREE_READONLY (fndecl) = 1;
14228       This caused &foo to be of type ptr-to-const-function
14229       which then got a warning when stored in a ptr-to-function variable.  */
14230
14231   my_friendly_assert (building_stmt_tree (), 20000911);
14232
14233   /* For a cloned function, we've already got all the code we need;
14234      there's no need to add any extra bits.  */
14235   if (!DECL_CLONED_FUNCTION_P (fndecl))
14236     {
14237       if (DECL_CONSTRUCTOR_P (fndecl))
14238         {
14239           finish_constructor_body ();
14240           if (call_poplevel)
14241             do_poplevel ();
14242         }
14243       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14244         finish_destructor_body ();
14245       else if (DECL_MAIN_P (fndecl))
14246         {
14247           /* Make it so that `main' always returns 0 by default.  */
14248 #ifdef VMS
14249           finish_return_stmt (integer_one_node);
14250 #else
14251           finish_return_stmt (integer_zero_node);
14252 #endif
14253         }
14254
14255       /* Finish dealing with exception specifiers.  */
14256       if (flag_exceptions && !processing_template_decl
14257           && flag_enforce_eh_specs
14258           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14259         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14260                             (TREE_TYPE (current_function_decl)),
14261                             current_eh_spec_try_block);
14262     }
14263
14264   /* If we're saving up tree structure, tie off the function now.  */
14265   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14266
14267   /* This must come after expand_function_end because cleanups might
14268      have declarations (from inline functions) that need to go into
14269      this function's blocks.  */
14270   if (current_binding_level->parm_flag != 1)
14271     my_friendly_abort (122);
14272   poplevel (1, 0, 1);
14273
14274   /* Remember that we were in class scope.  */
14275   if (current_class_name)
14276     ctype = current_class_type;
14277
14278   /* Must mark the RESULT_DECL as being in this function.  */
14279   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14280
14281   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14282      to the FUNCTION_DECL node itself.  */
14283   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14284
14285   /* Save away current state, if appropriate.  */
14286   if (!processing_template_decl)
14287     save_function_data (fndecl);
14288
14289   /* If this function calls `setjmp' it cannot be inlined.  When
14290      `longjmp' is called it is not guaranteed to restore the value of
14291      local variables that have been modified since the call to
14292      `setjmp'.  So, if were to inline this function into some caller
14293      `c', then when we `longjmp', we might not restore all variables
14294      in `c'.  (It might seem, at first blush, that there's no way for
14295      this function to modify local variables in `c', but their
14296      addresses may have been stored somewhere accessible to this
14297      function.)  */
14298   if (!processing_template_decl && calls_setjmp_p (fndecl))
14299     DECL_UNINLINABLE (fndecl) = 1;
14300
14301   /* Clear out memory we no longer need.  */
14302   free_after_parsing (cfun);
14303   /* Since we never call rest_of_compilation, we never clear
14304      CFUN.  Do so explicitly.  */
14305   free_after_compilation (cfun);
14306   cfun = NULL;
14307
14308   /* If this is a in-class inline definition, we may have to pop the
14309      bindings for the template parameters that we added in
14310      maybe_begin_member_template_processing when start_function was
14311      called.  */
14312   if (inclass_inline)
14313     maybe_end_member_template_processing ();
14314
14315   /* Leave the scope of the class.  */
14316   if (ctype)
14317     pop_nested_class ();
14318
14319   --function_depth;
14320
14321   /* Clean up.  */
14322   if (! nested)
14323     /* Let the error reporting routines know that we're outside a
14324        function.  For a nested function, this value is used in
14325        pop_cp_function_context and then reset via pop_function_context.  */
14326     current_function_decl = NULL_TREE;
14327
14328   return fndecl;
14329 }
14330 \f
14331 /* Create the FUNCTION_DECL for a function definition.
14332    DECLSPECS and DECLARATOR are the parts of the declaration;
14333    they describe the return type and the name of the function,
14334    but twisted together in a fashion that parallels the syntax of C.
14335
14336    This function creates a binding context for the function body
14337    as well as setting up the FUNCTION_DECL in current_function_decl.
14338
14339    Returns a FUNCTION_DECL on success.
14340
14341    If the DECLARATOR is not suitable for a function (it defines a datum
14342    instead), we return 0, which tells yyparse to report a parse error.
14343
14344    May return void_type_node indicating that this method is actually
14345    a friend.  See grokfield for more details.
14346
14347    Came here with a `.pushlevel' .
14348
14349    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14350    CHANGES TO CODE IN `grokfield'.  */
14351
14352 tree
14353 start_method (declspecs, declarator, attrlist)
14354      tree declarator, declspecs, attrlist;
14355 {
14356   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14357                                 attrlist);
14358
14359   /* Something too ugly to handle.  */
14360   if (fndecl == NULL_TREE)
14361     return NULL_TREE;
14362
14363   /* Pass friends other than inline friend functions back.  */
14364   if (fndecl == void_type_node)
14365     return fndecl;
14366
14367   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14368     /* Not a function, tell parser to report parse error.  */
14369     return NULL_TREE;
14370
14371   if (DECL_IN_AGGR_P (fndecl))
14372     {
14373       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14374         {
14375           if (DECL_CONTEXT (fndecl)
14376               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14377             cp_error ("`%D' is already defined in class `%T'", fndecl,
14378                       DECL_CONTEXT (fndecl));
14379         }
14380       return void_type_node;
14381     }
14382
14383   check_template_shadow (fndecl);
14384
14385   DECL_THIS_INLINE (fndecl) = 1;
14386
14387   if (flag_default_inline)
14388     DECL_INLINE (fndecl) = 1;
14389
14390   /* We process method specializations in finish_struct_1.  */
14391   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14392     fndecl = push_template_decl (fndecl);
14393
14394   if (! DECL_FRIEND_P (fndecl))
14395     {
14396       if (TREE_CHAIN (fndecl))
14397         {
14398           fndecl = copy_node (fndecl);
14399           TREE_CHAIN (fndecl) = NULL_TREE;
14400         }
14401
14402       if (DECL_CONSTRUCTOR_P (fndecl))
14403         {
14404           if (! grok_ctor_properties (current_class_type, fndecl))
14405             return void_type_node;
14406         }
14407       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14408         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14409     }
14410
14411   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14412
14413   /* Make a place for the parms */
14414   pushlevel (0);
14415   current_binding_level->parm_flag = 1;
14416
14417   DECL_IN_AGGR_P (fndecl) = 1;
14418   return fndecl;
14419 }
14420
14421 /* Go through the motions of finishing a function definition.
14422    We don't compile this method until after the whole class has
14423    been processed.
14424
14425    FINISH_METHOD must return something that looks as though it
14426    came from GROKFIELD (since we are defining a method, after all).
14427
14428    This is called after parsing the body of the function definition.
14429    STMTS is the chain of statements that makes up the function body.
14430
14431    DECL is the ..._DECL that `start_method' provided.  */
14432
14433 tree
14434 finish_method (decl)
14435      tree decl;
14436 {
14437   register tree fndecl = decl;
14438   tree old_initial;
14439
14440   register tree link;
14441
14442   if (decl == void_type_node)
14443     return decl;
14444
14445   old_initial = DECL_INITIAL (fndecl);
14446
14447   /* Undo the level for the parms (from start_method).
14448      This is like poplevel, but it causes nothing to be
14449      saved.  Saving information here confuses symbol-table
14450      output routines.  Besides, this information will
14451      be correctly output when this method is actually
14452      compiled.  */
14453
14454   /* Clear out the meanings of the local variables of this level;
14455      also record in each decl which block it belongs to.  */
14456
14457   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14458     {
14459       if (DECL_NAME (link) != NULL_TREE)
14460         pop_binding (DECL_NAME (link), link);
14461       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14462       DECL_CONTEXT (link) = NULL_TREE;
14463     }
14464
14465   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14466                       (HOST_WIDE_INT) current_binding_level->level_chain,
14467                       current_binding_level->parm_flag,
14468                       current_binding_level->keep);
14469
14470   poplevel (0, 0, 0);
14471
14472   DECL_INITIAL (fndecl) = old_initial;
14473
14474   /* We used to check if the context of FNDECL was different from
14475      current_class_type as another way to get inside here.  This didn't work
14476      for String.cc in libg++.  */
14477   if (DECL_FRIEND_P (fndecl))
14478     {
14479       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14480         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14481       decl = void_type_node;
14482     }
14483
14484   return decl;
14485 }
14486 \f
14487 /* Called when a new struct TYPE is defined.
14488    If this structure or union completes the type of any previous
14489    variable declaration, lay it out and output its rtl.  */
14490
14491 void
14492 hack_incomplete_structures (type)
14493      tree type;
14494 {
14495   tree *list;
14496   struct binding_level *level;
14497
14498   if (!type) /* Don't do this for class templates.  */
14499     return;
14500
14501   if (namespace_bindings_p ())
14502     {
14503       level = 0;
14504       list = &namespace_scope_incomplete;
14505     }
14506   else
14507     {
14508       level = innermost_nonclass_level ();
14509       list = &level->incomplete;
14510     }
14511
14512   while (1)
14513     {
14514       while (*list)
14515         {
14516           tree decl = TREE_VALUE (*list);
14517           if ((decl && TREE_TYPE (decl) == type)
14518               || (TREE_TYPE (decl)
14519                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14520                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14521             {
14522               int toplevel = toplevel_bindings_p ();
14523               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14524                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14525                 layout_type (TREE_TYPE (decl));
14526               layout_decl (decl, 0);
14527               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14528               if (! toplevel)
14529                 {
14530                   tree cleanup;
14531                   expand_decl (decl);
14532                   cleanup = maybe_build_cleanup (decl);
14533                   expand_decl_init (decl);
14534                   if (! expand_decl_cleanup (decl, cleanup))
14535                     cp_error ("parser lost in parsing declaration of `%D'",
14536                               decl);
14537                 }
14538               *list = TREE_CHAIN (*list);
14539             }
14540           else
14541             list = &TREE_CHAIN (*list);
14542         }
14543
14544       /* Keep looking through artificial binding levels generated
14545          for local variables.  */
14546       if (level && level->keep == 2)
14547         {
14548           level = level->level_chain;
14549           list = &level->incomplete;
14550         }
14551       else
14552         break;
14553     }
14554 }
14555
14556 /* If DECL is of a type which needs a cleanup, build that cleanup
14557    here.  */
14558
14559 tree
14560 maybe_build_cleanup (decl)
14561      tree decl;
14562 {
14563   tree type = TREE_TYPE (decl);
14564
14565   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14566     {
14567       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14568       tree rval;
14569
14570       if (TREE_CODE (type) == ARRAY_TYPE)
14571         rval = decl;
14572       else
14573         {
14574           mark_addressable (decl);
14575           rval = build_unary_op (ADDR_EXPR, decl, 0);
14576         }
14577
14578       /* Optimize for space over speed here.  */
14579       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14580           || flag_expensive_optimizations)
14581         flags |= LOOKUP_NONVIRTUAL;
14582
14583       rval = build_delete (TREE_TYPE (rval), rval,
14584                            sfk_complete_destructor, flags, 0);
14585
14586       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14587           && ! TYPE_HAS_DESTRUCTOR (type))
14588         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14589                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14590
14591       return rval;
14592     }
14593   return 0;
14594 }
14595 \f
14596 /* When a stmt has been parsed, this function is called.  */
14597
14598 void
14599 finish_stmt ()
14600 {
14601   /* Always assume this statement was not an expression statement.  If
14602      it actually was an expression statement, its our callers
14603      responsibility to fix this up.  */
14604   last_expr_type = NULL_TREE;
14605 }
14606
14607 /* DECL was originally constructed as a non-static member function,
14608    but turned out to be static.  Update it accordingly.  */
14609
14610 void
14611 revert_static_member_fn (decl)
14612      tree decl;
14613 {
14614   tree tmp;
14615   tree function = TREE_TYPE (decl);
14616   tree args = TYPE_ARG_TYPES (function);
14617
14618   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14619       != TYPE_UNQUALIFIED)
14620     cp_error ("static member function `%#D' declared with type qualifiers",
14621               decl);
14622
14623   args = TREE_CHAIN (args);
14624   tmp = build_function_type (TREE_TYPE (function), args);
14625   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14626   tmp = build_exception_variant (tmp,
14627                                  TYPE_RAISES_EXCEPTIONS (function));
14628   TREE_TYPE (decl) = tmp;
14629   if (DECL_ARGUMENTS (decl))
14630     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14631   DECL_STATIC_FUNCTION_P (decl) = 1;
14632 }
14633
14634 /* Initialize the variables used during compilation of a C++
14635    function.  */
14636
14637 static void
14638 push_cp_function_context (f)
14639      struct function *f;
14640 {
14641   struct cp_language_function *p
14642     = ((struct cp_language_function *)
14643        xcalloc (1, sizeof (struct cp_language_function)));
14644   f->language = (struct language_function *) p;
14645
14646   /* It takes an explicit call to expand_body to generate RTL for a
14647      function.  */
14648   expanding_p = 0;
14649
14650   /* Whenever we start a new function, we destroy temporaries in the
14651      usual way.  */
14652   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14653 }
14654
14655 /* Free the language-specific parts of F, now that we've finished
14656    compiling the function.  */
14657
14658 static void
14659 pop_cp_function_context (f)
14660      struct function *f;
14661 {
14662   if (f->language)
14663     free (f->language);
14664   f->language = 0;
14665 }
14666
14667 /* Mark P for GC.  */
14668
14669 static void
14670 mark_lang_function (p)
14671      struct cp_language_function *p;
14672 {
14673   if (!p)
14674     return;
14675
14676   mark_c_language_function (&p->base);
14677
14678   ggc_mark_tree (p->x_ctor_label);
14679   ggc_mark_tree (p->x_dtor_label);
14680   ggc_mark_tree (p->x_current_class_ptr);
14681   ggc_mark_tree (p->x_current_class_ref);
14682   ggc_mark_tree (p->x_eh_spec_try_block);
14683
14684   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14685   mark_binding_level (&p->bindings);
14686 }
14687
14688 /* Mark the language-specific data in F for GC.  */
14689
14690 static void
14691 mark_cp_function_context (f)
14692      struct function *f;
14693 {
14694   mark_lang_function ((struct cp_language_function *) f->language);
14695 }
14696
14697 void
14698 lang_mark_tree (t)
14699      tree t;
14700 {
14701   enum tree_code code = TREE_CODE (t);
14702   if (code == IDENTIFIER_NODE)
14703     {
14704       struct lang_identifier *li = (struct lang_identifier *) t;
14705       struct lang_id2 *li2 = li->x;
14706       ggc_mark_tree (li->namespace_bindings);
14707       ggc_mark_tree (li->bindings);
14708       ggc_mark_tree (li->class_value);
14709       ggc_mark_tree (li->class_template_info);
14710
14711       if (li2)
14712         {
14713           ggc_mark_tree (li2->label_value);
14714           ggc_mark_tree (li2->implicit_decl);
14715           ggc_mark_tree (li2->error_locus);
14716         }
14717     }
14718   else if (code == CPLUS_BINDING)
14719     {
14720       if (BINDING_HAS_LEVEL_P (t))
14721         mark_binding_level (&BINDING_LEVEL (t));
14722       else
14723         ggc_mark_tree (BINDING_SCOPE (t));
14724       ggc_mark_tree (BINDING_VALUE (t));
14725     }
14726   else if (code == OVERLOAD)
14727     ggc_mark_tree (OVL_FUNCTION (t));
14728   else if (code == TEMPLATE_PARM_INDEX)
14729     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14730   else if (TREE_CODE_CLASS (code) == 'd')
14731     {
14732       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14733
14734       if (ld)
14735         {
14736           ggc_mark (ld);
14737           c_mark_lang_decl (&ld->decl_flags.base);
14738           if (!DECL_GLOBAL_CTOR_P (t)
14739               && !DECL_GLOBAL_DTOR_P (t)
14740               && !DECL_THUNK_P (t))
14741             ggc_mark_tree (ld->decl_flags.u2.access);
14742           else if (DECL_THUNK_P (t))
14743             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14744           if (TREE_CODE (t) != NAMESPACE_DECL)
14745             ggc_mark_tree (ld->decl_flags.u.template_info);
14746           else
14747             mark_binding_level (&NAMESPACE_LEVEL (t));
14748           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14749             {
14750               ggc_mark_tree (ld->befriending_classes);
14751               ggc_mark_tree (ld->context);
14752               ggc_mark_tree (ld->cloned_function);
14753               if (!DECL_OVERLOADED_OPERATOR_P (t))
14754                 ggc_mark_tree (ld->u2.vtt_parm);
14755               if (TREE_CODE (t) == TYPE_DECL)
14756                 ggc_mark_tree (ld->u.sorted_fields);
14757               else if (TREE_CODE (t) == FUNCTION_DECL
14758                        && !DECL_PENDING_INLINE_P (t))
14759                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14760             }
14761         }
14762     }
14763   else if (TREE_CODE_CLASS (code) == 't')
14764     {
14765       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14766
14767       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14768                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14769         {
14770           ggc_mark (lt);
14771           ggc_mark_tree (lt->primary_base);
14772           ggc_mark_tree (lt->vfields);
14773           ggc_mark_tree (lt->vbases);
14774           ggc_mark_tree (lt->tags);
14775           ggc_mark_tree (lt->size);
14776           ggc_mark_tree (lt->pure_virtuals);
14777           ggc_mark_tree (lt->friend_classes);
14778           ggc_mark_tree (lt->rtti);
14779           ggc_mark_tree (lt->methods);
14780           ggc_mark_tree (lt->template_info);
14781           ggc_mark_tree (lt->befriending_classes);
14782         }
14783       else if (lt)
14784         /* In the case of pointer-to-member function types, the
14785            TYPE_LANG_SPECIFIC is really just a tree.  */
14786         ggc_mark_tree ((tree) lt);
14787     }
14788 }