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   if (LOOKUP_NAMESPACES_ONLY (flags))
5697     {
5698       /* We are not interested in types. */
5699       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5700         return val;
5701       return NULL_TREE;
5702     }
5703
5704   /* If we could have a type and
5705      we have nothing or we need a type and have none.  */
5706   if (BINDING_TYPE (binding)
5707       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5708                    && TREE_CODE (val) != TYPE_DECL)))
5709     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5710   /* Don't return non-types if we really prefer types. */
5711   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5712            && (TREE_CODE (val) != TEMPLATE_DECL
5713                || !DECL_CLASS_TEMPLATE_P (val)))
5714     val = NULL_TREE;
5715
5716   return val;
5717 }
5718
5719 /* Unscoped lookup of a global: iterate over current namespaces,
5720    considering using-directives.  If SPACESP is non-NULL, store a list
5721    of the namespaces we've considered in it.  */
5722
5723 tree
5724 unqualified_namespace_lookup (name, flags, spacesp)
5725      tree name;
5726      int flags;
5727      tree *spacesp;
5728 {
5729   tree b = make_node (CPLUS_BINDING);
5730   tree initial = current_decl_namespace();
5731   tree scope = initial;
5732   tree siter;
5733   struct binding_level *level;
5734   tree val = NULL_TREE;
5735
5736   if (spacesp)
5737     *spacesp = NULL_TREE;
5738
5739   for (; !val; scope = CP_DECL_CONTEXT (scope))
5740     {
5741       if (spacesp)
5742         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5743       val = binding_for_name (name, scope);
5744
5745       /* Initialize binding for this context. */
5746       BINDING_VALUE (b) = BINDING_VALUE (val);
5747       BINDING_TYPE (b) = BINDING_TYPE (val);
5748
5749       /* Add all _DECLs seen through local using-directives. */
5750       for (level = current_binding_level;
5751            !level->namespace_p;
5752            level = level->level_chain)
5753         if (!lookup_using_namespace (name, b, level->using_directives,
5754                                      scope, flags, spacesp))
5755           /* Give up because of error. */
5756           return error_mark_node;
5757
5758       /* Add all _DECLs seen through global using-directives. */
5759       /* XXX local and global using lists should work equally. */
5760       siter = initial;
5761       while (1)
5762         {
5763           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5764                                        scope, flags, spacesp))
5765             /* Give up because of error. */
5766             return error_mark_node;
5767           if (siter == scope) break;
5768           siter = CP_DECL_CONTEXT (siter);
5769         }
5770
5771       val = select_decl (b, flags);
5772       if (scope == global_namespace)
5773         break;
5774     }
5775   return val;
5776 }
5777
5778 /* Combine prefer_type and namespaces_only into flags.  */
5779
5780 static int
5781 lookup_flags (prefer_type, namespaces_only)
5782   int prefer_type, namespaces_only;
5783 {
5784   if (namespaces_only)
5785     return LOOKUP_PREFER_NAMESPACES;
5786   if (prefer_type > 1)
5787     return LOOKUP_PREFER_TYPES;
5788   if (prefer_type > 0)
5789     return LOOKUP_PREFER_BOTH;
5790   return 0;
5791 }
5792
5793 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5794    ignore it or not.  Subroutine of lookup_name_real.  */
5795
5796 static tree
5797 qualify_lookup (val, flags)
5798      tree val;
5799      int flags;
5800 {
5801   if (val == NULL_TREE)
5802     return val;
5803   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5804     return val;
5805   if ((flags & LOOKUP_PREFER_TYPES)
5806       && (TREE_CODE (val) == TYPE_DECL
5807           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5808               && DECL_CLASS_TEMPLATE_P (val))))
5809     return val;
5810   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5811     return NULL_TREE;
5812   return val;
5813 }
5814
5815 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5816    that.  */
5817
5818 static void
5819 warn_about_implicit_typename_lookup (typename, binding)
5820      tree typename;
5821      tree binding;
5822 {
5823   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5824   tree name = DECL_NAME (typename);
5825
5826   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5827          && CLASSTYPE_TEMPLATE_INFO (subtype)
5828          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5829       && ! (TREE_CODE (binding) == TYPE_DECL
5830             && same_type_p (TREE_TYPE (binding), subtype)))
5831     {
5832       cp_warning ("lookup of `%D' finds `%#D'",
5833                   name, binding);
5834       cp_warning ("  instead of `%D' from dependent base class",
5835                   typename);
5836       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5837                   constructor_name (current_class_type), name);
5838     }
5839 }
5840
5841 /* Look up NAME in the current binding level and its superiors in the
5842    namespace of variables, functions and typedefs.  Return a ..._DECL
5843    node of some kind representing its definition if there is only one
5844    such declaration, or return a TREE_LIST with all the overloaded
5845    definitions if there are many, or return 0 if it is undefined.
5846
5847    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5848    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5849    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5850    Otherwise we prefer non-TYPE_DECLs.
5851
5852    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5853    using IDENTIFIER_CLASS_VALUE.  */
5854
5855 static tree
5856 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5857      tree name;
5858      int prefer_type, nonclass, namespaces_only;
5859 {
5860   tree t;
5861   tree val = NULL_TREE;
5862   int yylex = 0;
5863   tree from_obj = NULL_TREE;
5864   int flags;
5865   int val_is_implicit_typename = 0;
5866
5867   /* Hack: copy flag set by parser, if set. */
5868   if (only_namespace_names)
5869     namespaces_only = 1;
5870
5871   if (prefer_type == -2)
5872     {
5873       extern int looking_for_typename;
5874       tree type = NULL_TREE;
5875
5876       yylex = 1;
5877       prefer_type = looking_for_typename;
5878
5879       flags = lookup_flags (prefer_type, namespaces_only);
5880       /* If the next thing is '<', class templates are types. */
5881       if (looking_for_template)
5882         flags |= LOOKUP_TEMPLATES_EXPECTED;
5883
5884       /* std:: becomes :: for now.  */
5885       if (got_scope && got_scope == fake_std_node)
5886         got_scope = void_type_node;
5887
5888       if (got_scope)
5889         type = got_scope;
5890       else if (got_object != error_mark_node)
5891         type = got_object;
5892
5893       if (type)
5894         {
5895           if (type == error_mark_node)
5896             return error_mark_node;
5897           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5898             type = TREE_TYPE (type);
5899
5900           if (TYPE_P (type))
5901             type = complete_type (type);
5902
5903           if (TREE_CODE (type) == VOID_TYPE)
5904             type = global_namespace;
5905           if (TREE_CODE (type) == NAMESPACE_DECL)
5906             {
5907               val = make_node (CPLUS_BINDING);
5908               flags |= LOOKUP_COMPLAIN;
5909               if (!qualified_lookup_using_namespace (name, type, val, flags))
5910                 return NULL_TREE;
5911               val = select_decl (val, flags);
5912             }
5913           else if (! IS_AGGR_TYPE (type)
5914                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5915                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5916                    || TREE_CODE (type) == TYPENAME_TYPE)
5917             /* Someone else will give an error about this if needed.  */
5918             val = NULL_TREE;
5919           else if (type == current_class_type)
5920             val = IDENTIFIER_CLASS_VALUE (name);
5921           else
5922             {
5923               val = lookup_member (type, name, 0, prefer_type);
5924               type_access_control (type, val);
5925
5926               /* Restore the containing TYPENAME_TYPE if we looked
5927                  through it before.  */
5928               if (got_scope && got_scope != type
5929                   && val && TREE_CODE (val) == TYPE_DECL
5930                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5931                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5932             }
5933         }
5934       else
5935         val = NULL_TREE;
5936
5937       if (got_scope)
5938         goto done;
5939       else if (got_object && val)
5940         from_obj = val;
5941     }
5942   else
5943     {
5944       flags = lookup_flags (prefer_type, namespaces_only);
5945       /* If we're not parsing, we need to complain. */
5946       flags |= LOOKUP_COMPLAIN;
5947     }
5948
5949   /* First, look in non-namespace scopes.  */
5950
5951   if (current_class_type == NULL_TREE)
5952     nonclass = 1;
5953
5954   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5955     {
5956       tree binding;
5957
5958       if (!LOCAL_BINDING_P (t) && nonclass)
5959         /* We're not looking for class-scoped bindings, so keep going.  */
5960         continue;
5961
5962       /* If this is the kind of thing we're looking for, we're done.  */
5963       if (qualify_lookup (BINDING_VALUE (t), flags))
5964         binding = BINDING_VALUE (t);
5965       else if ((flags & LOOKUP_PREFER_TYPES)
5966                && qualify_lookup (BINDING_TYPE (t), flags))
5967         binding = BINDING_TYPE (t);
5968       else
5969         binding = NULL_TREE;
5970
5971       /* Handle access control on types from enclosing or base classes.  */
5972       if (binding && ! yylex
5973           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5974         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5975
5976       if (binding
5977           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5978         {
5979           if (val_is_implicit_typename && !yylex)
5980             warn_about_implicit_typename_lookup (val, binding);
5981           val = binding;
5982           val_is_implicit_typename
5983             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5984           if (!val_is_implicit_typename)
5985             break;
5986         }
5987     }
5988
5989   /* Now lookup in namespace scopes.  */
5990   if (!val || val_is_implicit_typename)
5991     {
5992       t = unqualified_namespace_lookup (name, flags, 0);
5993       if (t)
5994         {
5995           if (val_is_implicit_typename && !yylex)
5996             warn_about_implicit_typename_lookup (val, t);
5997           val = t;
5998         }
5999     }
6000
6001  done:
6002   if (val)
6003     {
6004       /* This should only warn about types used in qualified-ids.  */
6005       if (from_obj && from_obj != val)
6006         {
6007           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6008               && TREE_CODE (val) == TYPE_DECL
6009               && TREE_TYPE (from_obj) != TREE_TYPE (val))
6010             {
6011               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6012                           name, got_object, TREE_TYPE (from_obj));
6013               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
6014                           TREE_TYPE (val));
6015             }
6016
6017           /* We don't change val to from_obj if got_object depends on
6018              template parms because that breaks implicit typename for
6019              destructor calls.  */
6020           if (! uses_template_parms (got_object))
6021             val = from_obj;
6022         }
6023
6024       /* If we have a single function from a using decl, pull it out.  */
6025       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6026         val = OVL_FUNCTION (val);
6027     }
6028   else if (from_obj)
6029     val = from_obj;
6030
6031   return val;
6032 }
6033
6034 tree
6035 lookup_name_nonclass (name)
6036      tree name;
6037 {
6038   return lookup_name_real (name, 0, 1, 0);
6039 }
6040
6041 tree
6042 lookup_function_nonclass (name, args)
6043      tree name;
6044      tree args;
6045 {
6046   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6047 }
6048
6049 tree
6050 lookup_name_namespace_only (name)
6051      tree name;
6052 {
6053   /* type-or-namespace, nonclass, namespace_only */
6054   return lookup_name_real (name, 1, 1, 1);
6055 }
6056
6057 tree
6058 lookup_name (name, prefer_type)
6059      tree name;
6060      int prefer_type;
6061 {
6062   return lookup_name_real (name, prefer_type, 0, 0);
6063 }
6064
6065 /* Similar to `lookup_name' but look only in the innermost non-class
6066    binding level.  */
6067
6068 tree
6069 lookup_name_current_level (name)
6070      tree name;
6071 {
6072   struct binding_level *b;
6073   tree t = NULL_TREE;
6074
6075   b = current_binding_level;
6076   while (b->parm_flag == 2)
6077     b = b->level_chain;
6078
6079   if (b->namespace_p)
6080     {
6081       t = IDENTIFIER_NAMESPACE_VALUE (name);
6082
6083       /* extern "C" function() */
6084       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6085         t = TREE_VALUE (t);
6086     }
6087   else if (IDENTIFIER_BINDING (name)
6088            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6089     {
6090       while (1)
6091         {
6092           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6093             return IDENTIFIER_VALUE (name);
6094
6095           if (b->keep == 2)
6096             b = b->level_chain;
6097           else
6098             break;
6099         }
6100     }
6101
6102   return t;
6103 }
6104
6105 /* Like lookup_name_current_level, but for types.  */
6106
6107 tree
6108 lookup_type_current_level (name)
6109      tree name;
6110 {
6111   register tree t = NULL_TREE;
6112
6113   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6114
6115   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6116       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6117     {
6118       struct binding_level *b = current_binding_level;
6119       while (1)
6120         {
6121           if (purpose_member (name, b->type_shadowed))
6122             return REAL_IDENTIFIER_TYPE_VALUE (name);
6123           if (b->keep == 2)
6124             b = b->level_chain;
6125           else
6126             break;
6127         }
6128     }
6129
6130   return t;
6131 }
6132
6133 void
6134 begin_only_namespace_names ()
6135 {
6136   only_namespace_names = 1;
6137 }
6138
6139 void
6140 end_only_namespace_names ()
6141 {
6142   only_namespace_names = 0;
6143 }
6144 \f
6145 /* Push the declarations of builtin types into the namespace.
6146    RID_INDEX is the index of the builtin type
6147    in the array RID_POINTERS.  NAME is the name used when looking
6148    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6149
6150 static void
6151 record_builtin_type (rid_index, name, type)
6152      enum rid rid_index;
6153      const char *name;
6154      tree type;
6155 {
6156   tree rname = NULL_TREE, tname = NULL_TREE;
6157   tree tdecl = NULL_TREE;
6158
6159   if ((int) rid_index < (int) RID_MAX)
6160     rname = ridpointers[(int) rid_index];
6161   if (name)
6162     tname = get_identifier (name);
6163
6164   TYPE_BUILT_IN (type) = 1;
6165
6166   if (tname)
6167     {
6168       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6169       set_identifier_type_value (tname, NULL_TREE);
6170       if ((int) rid_index < (int) RID_MAX)
6171         /* Built-in types live in the global namespace. */
6172         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6173     }
6174   if (rname != NULL_TREE)
6175     {
6176       if (tname != NULL_TREE)
6177         {
6178           set_identifier_type_value (rname, NULL_TREE);
6179           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6180         }
6181       else
6182         {
6183           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6184           set_identifier_type_value (rname, NULL_TREE);
6185         }
6186     }
6187 }
6188
6189 /* Record one of the standard Java types.
6190  * Declare it as having the given NAME.
6191  * If SIZE > 0, it is the size of one of the integral types;
6192  * otherwise it is the negative of the size of one of the other types.  */
6193
6194 static tree
6195 record_builtin_java_type (name, size)
6196      const char *name;
6197      int size;
6198 {
6199   tree type, decl;
6200   if (size > 0)
6201     type = make_signed_type (size);
6202   else if (size > -32)
6203     { /* "__java_char" or ""__java_boolean". */
6204       type = make_unsigned_type (-size);
6205       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6206     }
6207   else
6208     { /* "__java_float" or ""__java_double". */
6209       type = make_node (REAL_TYPE);
6210       TYPE_PRECISION (type) = - size;
6211       layout_type (type);
6212     }
6213   record_builtin_type (RID_MAX, name, type);
6214   decl = TYPE_NAME (type);
6215
6216   /* Suppress generate debug symbol entries for these types,
6217      since for normal C++ they are just clutter.
6218      However, push_lang_context undoes this if extern "Java" is seen. */
6219   DECL_IGNORED_P (decl) = 1;
6220
6221   TYPE_FOR_JAVA (type) = 1;
6222   return type;
6223 }
6224
6225 /* Push a type into the namespace so that the back-ends ignore it. */
6226
6227 static void
6228 record_unknown_type (type, name)
6229      tree type;
6230      const char *name;
6231 {
6232   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6233   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6234   DECL_IGNORED_P (decl) = 1;
6235   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6236   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6237   TYPE_ALIGN (type) = 1;
6238   TYPE_USER_ALIGN (type) = 0;
6239   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6240 }
6241
6242 /* An string for which we should create an IDENTIFIER_NODE at
6243    startup.  */
6244
6245 typedef struct predefined_identifier
6246 {
6247   /* The name of the identifier.  */
6248   const char *name;
6249   /* The place where the IDENTIFIER_NODE should be stored.  */
6250   tree *node;
6251   /* Non-zero if this is the name of a constructor or destructor.  */
6252   int ctor_or_dtor_p;
6253 } predefined_identifier;
6254
6255 /* Create all the predefined identifiers.  */
6256
6257 static void
6258 initialize_predefined_identifiers ()
6259 {
6260   struct predefined_identifier *pid;
6261
6262   /* A table of identifiers to create at startup.  */
6263   static predefined_identifier predefined_identifiers[] = {
6264     { "C++", &lang_name_cplusplus, 0 },
6265     { "C", &lang_name_c, 0 },
6266     { "Java", &lang_name_java, 0 },
6267     { CTOR_NAME, &ctor_identifier, 1 },
6268     { "__base_ctor", &base_ctor_identifier, 1 },
6269     { "__comp_ctor", &complete_ctor_identifier, 1 },
6270     { DTOR_NAME, &dtor_identifier, 1 },
6271     { "__comp_dtor", &complete_dtor_identifier, 1 },
6272     { "__base_dtor", &base_dtor_identifier, 1 },
6273     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6274     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6275     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6276     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6277     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6278     { "nelts", &nelts_identifier, 0 },
6279     { THIS_NAME, &this_identifier, 0 },
6280     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6281     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6282     { "_vptr", &vptr_identifier, 0 },
6283     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6284     { "__vtt_parm", &vtt_parm_identifier, 0 },
6285     { "std", &std_identifier, 0 },
6286     { NULL, NULL, 0 }
6287   };
6288
6289   for (pid = predefined_identifiers; pid->name; ++pid)
6290     {
6291       *pid->node = get_identifier (pid->name);
6292       if (pid->ctor_or_dtor_p)
6293         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6294     }
6295 }
6296
6297 /* Create the predefined scalar types of C,
6298    and some nodes representing standard constants (0, 1, (void *)0).
6299    Initialize the global binding level.
6300    Make definitions for built-in primitive functions.  */
6301
6302 void
6303 init_decl_processing ()
6304 {
6305   tree fields[20];
6306   int wchar_type_size;
6307   tree array_domain_type;
6308
6309   /* Check to see that the user did not specify an invalid combination
6310      of command-line options.  */
6311   if (flag_new_abi && !flag_vtable_thunks)
6312     fatal ("the new ABI requires vtable thunks");
6313
6314   /* Create all the identifiers we need.  */
6315   initialize_predefined_identifiers ();
6316
6317   /* Fill in back-end hooks.  */
6318   init_lang_status = &push_cp_function_context;
6319   free_lang_status = &pop_cp_function_context;
6320   mark_lang_status = &mark_cp_function_context;
6321   lang_safe_from_p = &c_safe_from_p;
6322
6323   cp_parse_init ();
6324   init_decl2 ();
6325   init_pt ();
6326
6327   /* Create the global variables.  */
6328   push_to_top_level ();
6329
6330   /* Enter the global namespace. */
6331   my_friendly_assert (global_namespace == NULL_TREE, 375);
6332   push_namespace (get_identifier ("::"));
6333   global_namespace = current_namespace;
6334   current_lang_name = NULL_TREE;
6335
6336   /* Adjust various flags based on command-line settings.  */
6337   if (! flag_permissive && ! pedantic)
6338     flag_pedantic_errors = 1;
6339   if (!flag_no_inline)
6340     flag_inline_trees = 1;
6341
6342   /* Initially, C.  */
6343   current_lang_name = lang_name_c;
6344
6345   current_function_decl = NULL_TREE;
6346   current_binding_level = NULL_BINDING_LEVEL;
6347   free_binding_level = NULL_BINDING_LEVEL;
6348
6349   build_common_tree_nodes (flag_signed_char);
6350
6351   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6352   TREE_TYPE (error_mark_list) = error_mark_node;
6353
6354   /* Make the binding_level structure for global names.  */
6355   pushlevel (0);
6356   global_binding_level = current_binding_level;
6357   /* The global level is the namespace level of ::.  */
6358   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6359   declare_namespace_level ();
6360
6361   /* Create the `std' namespace.  */
6362   if (flag_honor_std)
6363     {
6364       push_namespace (std_identifier);
6365       std_node = current_namespace;
6366       pop_namespace ();
6367       fake_std_node = error_mark_node;
6368     }
6369   else
6370     {
6371       fake_std_node = build_decl (NAMESPACE_DECL,
6372                                   std_identifier,
6373                                   void_type_node);
6374       pushdecl (fake_std_node);
6375     }
6376
6377   /* Define `int' and `char' first so that dbx will output them first.  */
6378   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6379   record_builtin_type (RID_CHAR, "char", char_type_node);
6380
6381   /* `signed' is the same as `int' */
6382   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6383   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6384   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6385   record_builtin_type (RID_MAX, "long unsigned int",
6386                        long_unsigned_type_node);
6387   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6388   record_builtin_type (RID_MAX, "long long int",
6389                        long_long_integer_type_node);
6390   record_builtin_type (RID_MAX, "long long unsigned int",
6391                        long_long_unsigned_type_node);
6392   record_builtin_type (RID_MAX, "long long unsigned",
6393                        long_long_unsigned_type_node);
6394   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6395   record_builtin_type (RID_MAX, "short unsigned int",
6396                        short_unsigned_type_node);
6397   record_builtin_type (RID_MAX, "unsigned short",
6398                        short_unsigned_type_node);
6399
6400   ptrdiff_type_node
6401     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6402   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
6403
6404   /* Define both `signed char' and `unsigned char'.  */
6405   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6406   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6407
6408   /* `unsigned long' is the standard type for sizeof.
6409      Note that stddef.h uses `unsigned long',
6410      and this must agree, even if long and int are the same size.  */
6411   c_size_type_node =
6412     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
6413   signed_size_type_node = signed_type (c_size_type_node);
6414   set_sizetype (c_size_type_node);
6415
6416   /* Create the widest literal types. */
6417   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6419                         widest_integer_literal_type_node));
6420
6421   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6422   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6423                         widest_unsigned_literal_type_node));
6424
6425   /* These are types that type_for_size and type_for_mode use.  */
6426   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6427   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6428   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6429   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6430 #if HOST_BITS_PER_WIDE_INT >= 64
6431   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6432 #endif
6433   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6434   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6435   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6436   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6437 #if HOST_BITS_PER_WIDE_INT >= 64
6438   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6439 #endif
6440
6441   build_common_tree_nodes_2 (flag_short_double);
6442
6443   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6444   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6445   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6446   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6447   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6448   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6449   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6450   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6451
6452   integer_two_node = build_int_2 (2, 0);
6453   TREE_TYPE (integer_two_node) = integer_type_node;
6454   integer_three_node = build_int_2 (3, 0);
6455   TREE_TYPE (integer_three_node) = integer_type_node;
6456
6457   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6458   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6459   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6460   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6461   TYPE_PRECISION (boolean_type_node) = 1;
6462   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6463   boolean_false_node = build_int_2 (0, 0);
6464   TREE_TYPE (boolean_false_node) = boolean_type_node;
6465   boolean_true_node = build_int_2 (1, 0);
6466   TREE_TYPE (boolean_true_node) = boolean_type_node;
6467
6468   signed_size_zero_node = build_int_2 (0, 0);
6469   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6470   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6471   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6472
6473   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6474                         complex_integer_type_node));
6475   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6476                         complex_float_type_node));
6477   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6478                         complex_double_type_node));
6479   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6480                         complex_long_double_type_node));
6481
6482   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6483
6484   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6485   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6486   TREE_PARMLIST (void_list_node) = 1;
6487
6488   string_type_node = build_pointer_type (char_type_node);
6489   const_string_type_node
6490     = build_pointer_type (build_qualified_type (char_type_node,
6491                                                 TYPE_QUAL_CONST));
6492   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6493 #if 0
6494   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6495 #endif
6496
6497   /* Make a type to be the domain of a few array types
6498      whose domains don't really matter.
6499      200 is small enough that it always fits in size_t.  */
6500   array_domain_type = build_index_type (build_int_2 (200, 0));
6501
6502   /* Make a type for arrays of characters.
6503      With luck nothing will ever really depend on the length of this
6504      array type.  */
6505   char_array_type_node
6506     = build_array_type (char_type_node, array_domain_type);
6507
6508   /* Likewise for arrays of ints.  */
6509   int_array_type_node
6510     = build_array_type (integer_type_node, array_domain_type);
6511
6512   if (flag_new_abi)
6513     delta_type_node = ptrdiff_type_node;
6514   else if (flag_huge_objects)
6515     delta_type_node = long_integer_type_node;
6516   else
6517     delta_type_node = short_integer_type_node;
6518
6519   if (flag_new_abi)
6520     vtable_index_type = ptrdiff_type_node;
6521   else
6522     vtable_index_type = delta_type_node;
6523
6524   default_function_type
6525     = build_function_type (integer_type_node, NULL_TREE);
6526
6527   ptr_type_node = build_pointer_type (void_type_node);
6528   const_ptr_type_node
6529     = build_pointer_type (build_qualified_type (void_type_node,
6530                                                 TYPE_QUAL_CONST));
6531   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6532   c_common_nodes_and_builtins ();
6533   lang_type_promotes_to = convert_type_from_ellipsis;
6534
6535   void_ftype_ptr
6536     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6537
6538   /* C++ extensions */
6539
6540   unknown_type_node = make_node (UNKNOWN_TYPE);
6541   record_unknown_type (unknown_type_node, "unknown type");
6542
6543   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6544   TREE_TYPE (unknown_type_node) = unknown_type_node;
6545
6546   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6547
6548   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6549      result.  */
6550   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6551   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6552
6553   /* This is special for C++ so functions can be overloaded.  */
6554   wchar_type_node = get_identifier (flag_short_wchar
6555                                     ? "short unsigned int"
6556                                     : WCHAR_TYPE);
6557   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6558   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6559   if (TREE_UNSIGNED (wchar_type_node))
6560     wchar_type_node = make_signed_type (wchar_type_size);
6561   else
6562     wchar_type_node = make_unsigned_type (wchar_type_size);
6563   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6564
6565   /* Artificial declaration of wchar_t -- can be bashed */
6566   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6567                                 wchar_type_node);
6568   pushdecl (wchar_decl_node);
6569
6570   /* This is for wide string constants.  */
6571   wchar_array_type_node
6572     = build_array_type (wchar_type_node, array_domain_type);
6573
6574   wint_type_node =
6575     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WINT_TYPE)));
6576
6577   intmax_type_node =
6578     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE)));
6579   uintmax_type_node =
6580     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE)));
6581
6582   if (flag_vtable_thunks)
6583     {
6584       /* Make sure we get a unique function type, so we can give
6585          its pointer type a name.  (This wins for gdb.) */
6586       tree vfunc_type = make_node (FUNCTION_TYPE);
6587       TREE_TYPE (vfunc_type) = integer_type_node;
6588       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6589       layout_type (vfunc_type);
6590
6591       vtable_entry_type = build_pointer_type (vfunc_type);
6592     }
6593   else
6594     {
6595       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6596       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6597                               delta_type_node);
6598       fields[1] = build_decl (FIELD_DECL, index_identifier,
6599                               delta_type_node);
6600       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6601                               ptr_type_node);
6602       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6603                            double_type_node);
6604
6605       /* Make this part of an invisible union.  */
6606       fields[3] = copy_node (fields[2]);
6607       TREE_TYPE (fields[3]) = delta_type_node;
6608       DECL_NAME (fields[3]) = delta2_identifier;
6609       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6610       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6611       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6612       TREE_UNSIGNED (fields[3]) = 0;
6613       TREE_CHAIN (fields[2]) = fields[3];
6614       vtable_entry_type = build_qualified_type (vtable_entry_type,
6615                                                 TYPE_QUAL_CONST);
6616     }
6617   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6618
6619   vtbl_type_node
6620     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6621   layout_type (vtbl_type_node);
6622   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6623   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6624   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6625   layout_type (vtbl_ptr_type_node);
6626   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6627
6628   if (flag_new_abi)
6629     {
6630       push_namespace (get_identifier ("__cxxabiv1"));
6631       abi_node = current_namespace;
6632       pop_namespace ();
6633     }
6634
6635   global_type_node = make_node (LANG_TYPE);
6636   record_unknown_type (global_type_node, "global type");
6637
6638   /* Now, C++.  */
6639   current_lang_name = lang_name_cplusplus;
6640
6641   {
6642     tree bad_alloc_type_node, newtype, deltype;
6643     if (flag_honor_std)
6644       push_namespace (std_identifier);
6645     bad_alloc_type_node = xref_tag
6646       (class_type_node, get_identifier ("bad_alloc"), 1);
6647     if (flag_honor_std)
6648       pop_namespace ();
6649     newtype = build_exception_variant
6650       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6651     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6652     push_cp_library_fn (NEW_EXPR, newtype);
6653     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6654     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6655     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6656   }
6657
6658   abort_fndecl
6659     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6660
6661   /* Perform other language dependent initializations.  */
6662   init_class_processing ();
6663   init_init_processing ();
6664   init_search_processing ();
6665   init_rtti_processing ();
6666
6667   if (flag_exceptions)
6668     init_exception_processing ();
6669   if (flag_no_inline)
6670     {
6671       flag_inline_functions = 0;
6672     }
6673
6674   if (! supports_one_only ())
6675     flag_weak = 0;
6676
6677   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6678   function_id_node = get_identifier ("__FUNCTION__");
6679   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6680   func_id_node = get_identifier ("__func__");
6681
6682   make_fname_decl = cp_make_fname_decl;
6683   declare_function_name ();
6684
6685   /* Prepare to check format strings against argument lists.  */
6686   init_function_format_info ();
6687
6688   /* Show we use EH for cleanups.  */
6689   using_eh_for_cleanups ();
6690
6691   valid_lang_attribute = cp_valid_lang_attribute;
6692
6693   /* Maintain consistency.  Perhaps we should just complain if they
6694      say -fwritable-strings?  */
6695   if (flag_writable_strings)
6696     flag_const_strings = 0;
6697
6698   /* Add GC roots for all of our global variables.  */
6699   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6700   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6701   ggc_add_tree_root (&integer_three_node, 1);
6702   ggc_add_tree_root (&integer_two_node, 1);
6703   ggc_add_tree_root (&signed_size_zero_node, 1);
6704   ggc_add_tree_root (&size_one_node, 1);
6705   ggc_add_tree_root (&size_zero_node, 1);
6706   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6707                 mark_binding_level);
6708   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6709   ggc_add_tree_root (&static_ctors, 1);
6710   ggc_add_tree_root (&static_dtors, 1);
6711   ggc_add_tree_root (&lastiddecl, 1);
6712
6713   ggc_add_tree_root (&last_function_parm_tags, 1);
6714   ggc_add_tree_root (&current_function_return_value, 1);
6715   ggc_add_tree_root (&current_function_parm_tags, 1);
6716   ggc_add_tree_root (&last_function_parms, 1);
6717   ggc_add_tree_root (&error_mark_list, 1);
6718
6719   ggc_add_tree_root (&global_namespace, 1);
6720   ggc_add_tree_root (&global_type_node, 1);
6721   ggc_add_tree_root (&anonymous_namespace_name, 1);
6722
6723   ggc_add_tree_root (&got_object, 1);
6724   ggc_add_tree_root (&got_scope, 1);
6725
6726   ggc_add_tree_root (&current_lang_name, 1);
6727   ggc_add_tree_root (&static_aggregates, 1);
6728 }
6729
6730 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6731    decl, NAME is the initialization string and TYPE_DEP indicates whether
6732    NAME depended on the type of the function. We make use of that to detect
6733    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6734    the function before emitting any of it, we don't need to treat the
6735    VAR_DECL specially. We can decide whether to emit it later, if it was
6736    used.  */
6737
6738 static tree
6739 cp_make_fname_decl (id, name, type_dep)
6740      tree id;
6741      const char *name;
6742      int type_dep;
6743 {
6744   tree decl, type, init;
6745   size_t length = strlen (name);
6746   tree domain = NULL_TREE;
6747
6748   if (!processing_template_decl)
6749     type_dep = 0;
6750   if (!type_dep)
6751     domain = build_index_type (build_int_2 (length, 0));
6752
6753   type =  build_cplus_array_type
6754           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6755            domain);
6756
6757   decl = build_decl (VAR_DECL, id, type);
6758   TREE_STATIC (decl) = 1;
6759   TREE_READONLY (decl) = 1;
6760   DECL_SOURCE_LINE (decl) = 0;
6761   DECL_ARTIFICIAL (decl) = 1;
6762   DECL_IN_SYSTEM_HEADER (decl) = 1;
6763   pushdecl (decl);
6764   if (processing_template_decl)
6765     decl = push_template_decl (decl);
6766   if (type_dep)
6767     {
6768       init = build (FUNCTION_NAME, type);
6769       DECL_PRETTY_FUNCTION_P (decl) = 1;
6770     }
6771   else
6772     {
6773       init = build_string (length + 1, name);
6774       TREE_TYPE (init) = type;
6775     }
6776   DECL_INITIAL (decl) = init;
6777   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6778
6779   /* We will have to make sure we only emit this, if it is actually used. */
6780   return decl;
6781 }
6782
6783 /* Entry point for the benefit of c_common_nodes_and_builtins.
6784
6785    Make a definition for a builtin function named NAME and whose data type
6786    is TYPE.  TYPE should be a function type with argument types.
6787
6788    CLASS and CODE tell later passes how to compile calls to this function.
6789    See tree.h for possible values.
6790
6791    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6792    the name to be called if we can't opencode the function.  */
6793
6794 tree
6795 builtin_function (name, type, code, class, libname)
6796      const char *name;
6797      tree type;
6798      int code;
6799      enum built_in_class class;
6800      const char *libname;
6801 {
6802   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6803   DECL_BUILT_IN_CLASS (decl) = class;
6804   DECL_FUNCTION_CODE (decl) = code;
6805
6806   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6807
6808   /* All builtins that don't begin with an `_' should go in the `std'
6809      namespace.  */
6810   if (flag_honor_std && name[0] != '_')
6811     {
6812       push_namespace (std_identifier);
6813       DECL_CONTEXT (decl) = std_node;
6814     }
6815   pushdecl (decl);
6816   if (flag_honor_std && name[0] != '_')
6817     pop_namespace ();
6818
6819   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6820      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6821      function in the namespace.  */
6822   if (libname)
6823     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6824   make_function_rtl (decl);
6825
6826   /* Warn if a function in the namespace for users
6827      is used without an occasion to consider it declared.  */
6828   if (name[0] != '_' || name[1] != '_')
6829     DECL_ANTICIPATED (decl) = 1;
6830
6831   return decl;
6832 }
6833
6834 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6835    function.  Not called directly.  */
6836
6837 static tree
6838 build_library_fn_1 (name, operator_code, type)
6839      tree name;
6840      enum tree_code operator_code;
6841      tree type;
6842 {
6843   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6844   DECL_EXTERNAL (fn) = 1;
6845   TREE_PUBLIC (fn) = 1;
6846   DECL_ARTIFICIAL (fn) = 1;
6847   TREE_NOTHROW (fn) = 1;
6848   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6849   return fn;
6850 }
6851
6852 /* Returns the _DECL for a library function with C linkage.
6853    We assume that such functions never throw; if this is incorrect,
6854    callers should unset TREE_NOTHROW.  */
6855
6856 tree
6857 build_library_fn (name, type)
6858      tree name;
6859      tree type;
6860 {
6861   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6862   make_function_rtl (fn);
6863   return fn;
6864 }
6865
6866 /* Returns the _DECL for a library function with C++ linkage.  */
6867
6868 static tree
6869 build_cp_library_fn (name, operator_code, type)
6870      tree name;
6871      enum tree_code operator_code;
6872      tree type;
6873 {
6874   tree fn = build_library_fn_1 (name, operator_code, type);
6875   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6876   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6877   set_mangled_name_for_decl (fn);
6878   make_function_rtl (fn);
6879   return fn;
6880 }
6881
6882 /* Like build_library_fn, but takes a C string instead of an
6883    IDENTIFIER_NODE.  */
6884
6885 tree
6886 build_library_fn_ptr (name, type)
6887      const char *name;
6888      tree type;
6889 {
6890   return build_library_fn (get_identifier (name), type);
6891 }
6892
6893 /* Like build_cp_library_fn, but takes a C string instead of an
6894    IDENTIFIER_NODE.  */
6895
6896 tree
6897 build_cp_library_fn_ptr (name, type)
6898      const char *name;
6899      tree type;
6900 {
6901   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6902 }
6903
6904 /* Like build_library_fn, but also pushes the function so that we will
6905    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6906
6907 tree
6908 push_library_fn (name, type)
6909      tree name, type;
6910 {
6911   tree fn = build_library_fn (name, type);
6912   pushdecl_top_level (fn);
6913   return fn;
6914 }
6915
6916 /* Like build_cp_library_fn, but also pushes the function so that it
6917    will be found by normal lookup.  */
6918
6919 static tree
6920 push_cp_library_fn (operator_code, type)
6921      enum tree_code operator_code;
6922      tree type;
6923 {
6924   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6925                                  operator_code,
6926                                  type);
6927   pushdecl (fn);
6928   return fn;
6929 }
6930
6931 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6932    a FUNCTION_TYPE.  */
6933
6934 tree
6935 push_void_library_fn (name, parmtypes)
6936      tree name, parmtypes;
6937 {
6938   tree type = build_function_type (void_type_node, parmtypes);
6939   return push_library_fn (name, type);
6940 }
6941
6942 /* Like push_library_fn, but also note that this function throws
6943    and does not return.  Used for __throw_foo and the like.  */
6944
6945 tree
6946 push_throw_library_fn (name, type)
6947      tree name, type;
6948 {
6949   tree fn = push_library_fn (name, type);
6950   TREE_THIS_VOLATILE (fn) = 1;
6951   TREE_NOTHROW (fn) = 0;
6952   return fn;
6953 }
6954 \f
6955 /* When we call finish_struct for an anonymous union, we create
6956    default copy constructors and such.  But, an anonymous union
6957    shouldn't have such things; this function undoes the damage to the
6958    anonymous union type T.
6959
6960    (The reason that we create the synthesized methods is that we don't
6961    distinguish `union { int i; }' from `typedef union { int i; } U'.
6962    The first is an anonymous union; the second is just an ordinary
6963    union type.)  */
6964
6965 void
6966 fixup_anonymous_aggr (t)
6967      tree t;
6968 {
6969   tree *q;
6970
6971   /* Wipe out memory of synthesized methods */
6972   TYPE_HAS_CONSTRUCTOR (t) = 0;
6973   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6974   TYPE_HAS_INIT_REF (t) = 0;
6975   TYPE_HAS_CONST_INIT_REF (t) = 0;
6976   TYPE_HAS_ASSIGN_REF (t) = 0;
6977   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6978
6979   /* Splice the implicitly generated functions out of the TYPE_METHODS
6980      list.  */
6981   q = &TYPE_METHODS (t);
6982   while (*q)
6983     {
6984       if (DECL_ARTIFICIAL (*q))
6985         *q = TREE_CHAIN (*q);
6986       else
6987         q = &TREE_CHAIN (*q);
6988     }
6989
6990   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6991   if (TYPE_METHODS (t))
6992     error ("an anonymous union cannot have function members");
6993 }
6994
6995 /* Make sure that a declaration with no declarator is well-formed, i.e.
6996    just defines a tagged type or anonymous union.
6997
6998    Returns the type defined, if any.  */
6999
7000 tree
7001 check_tag_decl (declspecs)
7002      tree declspecs;
7003 {
7004   int found_type = 0;
7005   int saw_friend = 0;
7006   tree ob_modifier = NULL_TREE;
7007   register tree link;
7008   register tree t = NULL_TREE;
7009
7010   for (link = declspecs; link; link = TREE_CHAIN (link))
7011     {
7012       register tree value = TREE_VALUE (link);
7013
7014       if (TYPE_P (value)
7015           || (TREE_CODE (value) == IDENTIFIER_NODE
7016               && IDENTIFIER_GLOBAL_VALUE (value)
7017               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7018         {
7019           ++found_type;
7020
7021           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7022               || TREE_CODE (value) == ENUMERAL_TYPE)
7023             {
7024               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7025               t = value;
7026             }
7027         }
7028       else if (value == ridpointers[(int) RID_FRIEND])
7029         {
7030           if (current_class_type == NULL_TREE
7031               || current_scope () != current_class_type)
7032             ob_modifier = value;
7033           else
7034             saw_friend = 1;
7035         }
7036       else if (value == ridpointers[(int) RID_STATIC]
7037                || value == ridpointers[(int) RID_EXTERN]
7038                || value == ridpointers[(int) RID_AUTO]
7039                || value == ridpointers[(int) RID_REGISTER]
7040                || value == ridpointers[(int) RID_INLINE]
7041                || value == ridpointers[(int) RID_VIRTUAL]
7042                || value == ridpointers[(int) RID_CONST]
7043                || value == ridpointers[(int) RID_VOLATILE]
7044                || value == ridpointers[(int) RID_EXPLICIT])
7045         ob_modifier = value;
7046     }
7047
7048   if (found_type > 1)
7049     error ("multiple types in one declaration");
7050
7051   if (t == NULL_TREE && ! saw_friend)
7052     pedwarn ("declaration does not declare anything");
7053
7054   /* Check for an anonymous union.  We're careful
7055      accessing TYPE_IDENTIFIER because some built-in types, like
7056      pointer-to-member types, do not have TYPE_NAME.  */
7057   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7058            && TYPE_NAME (t)
7059            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7060     {
7061       /* Anonymous unions are objects, so they can have specifiers.  */;
7062       SET_ANON_AGGR_TYPE_P (t);
7063
7064       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7065         pedwarn ("ISO C++ prohibits anonymous structs");
7066     }
7067
7068   else if (ob_modifier)
7069     {
7070       if (ob_modifier == ridpointers[(int) RID_INLINE]
7071           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7072         cp_error ("`%D' can only be specified for functions", ob_modifier);
7073       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7074         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7075       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7076         cp_error ("`%D' can only be specified for constructors",
7077                   ob_modifier);
7078       else
7079         cp_error ("`%D' can only be specified for objects and functions",
7080                   ob_modifier);
7081     }
7082
7083   return t;
7084 }
7085
7086 /* Called when a declaration is seen that contains no names to declare.
7087    If its type is a reference to a structure, union or enum inherited
7088    from a containing scope, shadow that tag name for the current scope
7089    with a forward reference.
7090    If its type defines a new named structure or union
7091    or defines an enum, it is valid but we need not do anything here.
7092    Otherwise, it is an error.
7093
7094    C++: may have to grok the declspecs to learn about static,
7095    complain for anonymous unions.  */
7096
7097 void
7098 shadow_tag (declspecs)
7099      tree declspecs;
7100 {
7101   tree t = check_tag_decl (declspecs);
7102
7103   if (t)
7104     maybe_process_partial_specialization (t);
7105
7106   /* This is where the variables in an anonymous union are
7107      declared.  An anonymous union declaration looks like:
7108      union { ... } ;
7109      because there is no declarator after the union, the parser
7110      sends that declaration here.  */
7111   if (t && ANON_AGGR_TYPE_P (t))
7112     {
7113       fixup_anonymous_aggr (t);
7114
7115       if (TYPE_FIELDS (t))
7116         {
7117           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7118                                       NULL_TREE);
7119           finish_anon_union (decl);
7120         }
7121     }
7122 }
7123 \f
7124 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7125
7126 tree
7127 groktypename (typename)
7128      tree typename;
7129 {
7130   if (TREE_CODE (typename) != TREE_LIST)
7131     return typename;
7132   return grokdeclarator (TREE_VALUE (typename),
7133                          TREE_PURPOSE (typename),
7134                          TYPENAME, 0, NULL_TREE);
7135 }
7136
7137 /* Decode a declarator in an ordinary declaration or data definition.
7138    This is called as soon as the type information and variable name
7139    have been parsed, before parsing the initializer if any.
7140    Here we create the ..._DECL node, fill in its type,
7141    and put it on the list of decls for the current context.
7142    The ..._DECL node is returned as the value.
7143
7144    Exception: for arrays where the length is not specified,
7145    the type is left null, to be filled in by `cp_finish_decl'.
7146
7147    Function definitions do not come here; they go to start_function
7148    instead.  However, external and forward declarations of functions
7149    do go through here.  Structure field declarations are done by
7150    grokfield and not through here.  */
7151
7152 tree
7153 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7154      tree declarator, declspecs;
7155      int initialized;
7156      tree attributes, prefix_attributes;
7157 {
7158   register tree decl;
7159   register tree type, tem;
7160   tree context;
7161   extern int have_extern_spec;
7162   extern int used_extern_spec;
7163   tree attrlist;
7164
7165 #if 0
7166   /* See code below that used this.  */
7167   int init_written = initialized;
7168 #endif
7169
7170   /* This should only be done once on the top most decl.  */
7171   if (have_extern_spec && !used_extern_spec)
7172     {
7173       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7174                              declspecs);
7175       used_extern_spec = 1;
7176     }
7177
7178   if (attributes || prefix_attributes)
7179     attrlist = build_tree_list (attributes, prefix_attributes);
7180   else
7181     attrlist = NULL_TREE;
7182
7183   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7184                          attrlist);
7185
7186   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7187     return NULL_TREE;
7188
7189   type = TREE_TYPE (decl);
7190
7191   if (type == error_mark_node)
7192     return NULL_TREE;
7193
7194   context = DECL_CONTEXT (decl);
7195
7196   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7197       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7198     {
7199       /* When parsing the initializer, lookup should use the object's
7200          namespace. */
7201       push_decl_namespace (context);
7202     }
7203
7204   /* We are only interested in class contexts, later. */
7205   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7206     context = NULL_TREE;
7207
7208   if (initialized)
7209     /* Is it valid for this decl to have an initializer at all?
7210        If not, set INITIALIZED to zero, which will indirectly
7211        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7212     switch (TREE_CODE (decl))
7213       {
7214       case TYPE_DECL:
7215         /* typedef foo = bar  means give foo the same type as bar.
7216            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7217            Any other case of an initialization in a TYPE_DECL is an error.  */
7218         if (pedantic || list_length (declspecs) > 1)
7219           {
7220             cp_error ("typedef `%D' is initialized", decl);
7221             initialized = 0;
7222           }
7223         break;
7224
7225       case FUNCTION_DECL:
7226         cp_error ("function `%#D' is initialized like a variable", decl);
7227         initialized = 0;
7228         break;
7229
7230       default:
7231         break;
7232       }
7233
7234   if (initialized)
7235     {
7236       if (! toplevel_bindings_p ()
7237           && DECL_EXTERNAL (decl))
7238         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7239                     decl);
7240       DECL_EXTERNAL (decl) = 0;
7241       if (toplevel_bindings_p ())
7242         TREE_STATIC (decl) = 1;
7243
7244       /* Tell `pushdecl' this is an initialized decl
7245          even though we don't yet have the initializer expression.
7246          Also tell `cp_finish_decl' it may store the real initializer.  */
7247       DECL_INITIAL (decl) = error_mark_node;
7248     }
7249
7250 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7251   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7252 #endif
7253
7254   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7255   cplus_decl_attributes (decl, attributes, prefix_attributes);
7256
7257   if (context && COMPLETE_TYPE_P (complete_type (context)))
7258     {
7259       push_nested_class (context, 2);
7260
7261       if (TREE_CODE (decl) == VAR_DECL)
7262         {
7263           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7264           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7265             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7266           else
7267             {
7268               if (DECL_CONTEXT (field) != context)
7269                 {
7270                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7271                               DECL_CONTEXT (field), DECL_NAME (decl),
7272                               context, DECL_NAME (decl));
7273                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7274                 }
7275               /* Static data member are tricky; an in-class initialization
7276                  still doesn't provide a definition, so the in-class
7277                  declaration will have DECL_EXTERNAL set, but will have an
7278                  initialization.  Thus, duplicate_decls won't warn
7279                  about this situation, and so we check here.  */
7280               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7281                 cp_error ("duplicate initialization of %D", decl);
7282               if (duplicate_decls (decl, field))
7283                 decl = field;
7284             }
7285         }
7286       else
7287         {
7288           tree field = check_classfn (context, decl);
7289           if (field && duplicate_decls (decl, field))
7290             decl = field;
7291         }
7292
7293       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7294       DECL_IN_AGGR_P (decl) = 0;
7295       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7296           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7297         {
7298           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7299           /* [temp.expl.spec] An explicit specialization of a static data
7300              member of a template is a definition if the declaration
7301              includes an initializer; otherwise, it is a declaration.
7302
7303              We check for processing_specialization so this only applies
7304              to the new specialization syntax.  */
7305           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7306             DECL_EXTERNAL (decl) = 1;
7307         }
7308
7309       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7310         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7311                     decl);
7312     }
7313
7314   /* Enter this declaration into the symbol table.  */
7315   tem = maybe_push_decl (decl);
7316
7317   if (processing_template_decl)
7318     tem = push_template_decl (tem);
7319
7320 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7321   /* Tell the back-end to use or not use .common as appropriate.  If we say
7322      -fconserve-space, we want this to save .data space, at the expense of
7323      wrong semantics.  If we say -fno-conserve-space, we want this to
7324      produce errors about redefs; to do this we force variables into the
7325      data segment.  */
7326   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7327 #endif
7328
7329   if (! processing_template_decl)
7330     start_decl_1 (tem);
7331
7332   return tem;
7333 }
7334
7335 void
7336 start_decl_1 (decl)
7337      tree decl;
7338 {
7339   tree type = TREE_TYPE (decl);
7340   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7341
7342   if (type == error_mark_node)
7343     return;
7344
7345   /* If this type of object needs a cleanup, but we're not allowed to
7346      add any more objects with cleanups to the current scope, create a
7347      new binding level.  */
7348   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7349       && current_binding_level->more_cleanups_ok == 0)
7350     {
7351       keep_next_level (2);
7352       pushlevel (1);
7353       clear_last_expr ();
7354       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7355     }
7356
7357   if (initialized)
7358     /* Is it valid for this decl to have an initializer at all?
7359        If not, set INITIALIZED to zero, which will indirectly
7360        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7361     {
7362       /* Don't allow initializations for incomplete types except for
7363          arrays which might be completed by the initialization.  */
7364       if (COMPLETE_TYPE_P (complete_type (type)))
7365         ;                       /* A complete type is ok.  */
7366       else if (TREE_CODE (type) != ARRAY_TYPE)
7367         {
7368           cp_error ("variable `%#D' has initializer but incomplete type",
7369                     decl);
7370           initialized = 0;
7371           type = TREE_TYPE (decl) = error_mark_node;
7372         }
7373       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7374         {
7375           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7376             cp_error ("elements of array `%#D' have incomplete type", decl);
7377           /* else we already gave an error in start_decl.  */
7378           initialized = 0;
7379         }
7380     }
7381
7382   if (!initialized
7383       && TREE_CODE (decl) != TYPE_DECL
7384       && TREE_CODE (decl) != TEMPLATE_DECL
7385       && type != error_mark_node
7386       && IS_AGGR_TYPE (type)
7387       && ! DECL_EXTERNAL (decl))
7388     {
7389       if ((! processing_template_decl || ! uses_template_parms (type))
7390           && !COMPLETE_TYPE_P (complete_type (type)))
7391         {
7392           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7393                  decl);
7394           /* Change the type so that assemble_variable will give
7395              DECL an rtl we can live with: (mem (const_int 0)).  */
7396           type = TREE_TYPE (decl) = error_mark_node;
7397         }
7398       else
7399         {
7400           /* If any base type in the hierarchy of TYPE needs a constructor,
7401              then we set initialized to 1.  This way any nodes which are
7402              created for the purposes of initializing this aggregate
7403              will live as long as it does.  This is necessary for global
7404              aggregates which do not have their initializers processed until
7405              the end of the file.  */
7406           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7407         }
7408     }
7409
7410   if (! initialized)
7411     DECL_INITIAL (decl) = NULL_TREE;
7412 }
7413
7414 /* Handle initialization of references.
7415    These three arguments are from `cp_finish_decl', and have the
7416    same meaning here that they do there.
7417
7418    Quotes on semantics can be found in ARM 8.4.3.  */
7419
7420 static void
7421 grok_reference_init (decl, type, init)
7422      tree decl, type, init;
7423 {
7424   tree tmp;
7425
7426   if (init == NULL_TREE)
7427     {
7428       if ((DECL_LANG_SPECIFIC (decl) == 0
7429            || DECL_IN_AGGR_P (decl) == 0)
7430           && ! DECL_THIS_EXTERN (decl))
7431         cp_error ("`%D' declared as reference but not initialized", decl);
7432       return;
7433     }
7434
7435   if (init == error_mark_node)
7436     return;
7437
7438   if (TREE_CODE (init) == CONSTRUCTOR)
7439     {
7440       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7441       return;
7442     }
7443
7444   if (TREE_CODE (init) == TREE_LIST)
7445     init = build_compound_expr (init);
7446
7447   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7448     init = convert_from_reference (init);
7449
7450   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7451       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7452     {
7453       /* Note: default conversion is only called in very special cases.  */
7454       init = default_conversion (init);
7455     }
7456
7457   /* Convert INIT to the reference type TYPE.  This may involve the
7458      creation of a temporary, whose lifetime must be the same as that
7459      of the reference.  If so, a DECL_STMT for the temporary will be
7460      added just after the DECL_STMT for DECL.  That's why we don't set
7461      DECL_INITIAL for local references (instead assigning to them
7462      explicitly); we need to allow the temporary to be initialized
7463      first.  */
7464   tmp = convert_to_reference
7465     (type, init, CONV_IMPLICIT,
7466      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7467      decl);
7468
7469   if (tmp == error_mark_node)
7470     return;
7471   else if (tmp != NULL_TREE)
7472     {
7473       init = tmp;
7474       tmp = save_expr (tmp);
7475       if (building_stmt_tree ())
7476         {
7477           /* Initialize the declaration.  */
7478           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7479           finish_expr_stmt (tmp);
7480         }
7481       else
7482         DECL_INITIAL (decl) = tmp;
7483     }
7484   else
7485     {
7486       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7487       return;
7488     }
7489
7490   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7491     {
7492       expand_static_init (decl, DECL_INITIAL (decl));
7493       DECL_INITIAL (decl) = NULL_TREE;
7494     }
7495   return;
7496 }
7497
7498 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7499    mucking with forces it does not comprehend (i.e. initialization with a
7500    constructor).  If we are at global scope and won't go into COMMON, fill
7501    it in with a dummy CONSTRUCTOR to force the variable into .data;
7502    otherwise we can use error_mark_node.  */
7503
7504 static tree
7505 obscure_complex_init (decl, init)
7506      tree decl, init;
7507 {
7508   if (! flag_no_inline && TREE_STATIC (decl))
7509     {
7510       if (extract_init (decl, init))
7511         return NULL_TREE;
7512     }
7513
7514 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7515   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7516     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7517                                  NULL_TREE);
7518   else
7519 #endif
7520     DECL_INITIAL (decl) = error_mark_node;
7521
7522   return init;
7523 }
7524
7525 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7526    array until we finish parsing the initializer.  If that's the
7527    situation we're in, update DECL accordingly.  */
7528
7529 static void
7530 maybe_deduce_size_from_array_init (decl, init)
7531      tree decl;
7532      tree init;
7533 {
7534   tree type = TREE_TYPE (decl);
7535
7536   if (TREE_CODE (type) == ARRAY_TYPE
7537       && TYPE_DOMAIN (type) == NULL_TREE
7538       && TREE_CODE (decl) != TYPE_DECL)
7539     {
7540       /* do_default is really a C-ism to deal with tentative definitions.
7541          But let's leave it here to ease the eventual merge.  */
7542       int do_default = !DECL_EXTERNAL (decl);
7543       tree initializer = init ? init : DECL_INITIAL (decl);
7544       int failure = complete_array_type (type, initializer, do_default);
7545
7546       if (failure == 1)
7547         cp_error ("initializer fails to determine size of `%D'", decl);
7548
7549       if (failure == 2)
7550         {
7551           if (do_default)
7552             cp_error ("array size missing in `%D'", decl);
7553           /* If a `static' var's size isn't known, make it extern as
7554              well as static, so it does not get allocated.  If it's not
7555              `static', then don't mark it extern; finish_incomplete_decl
7556              will give it a default size and it will get allocated.  */
7557           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7558             DECL_EXTERNAL (decl) = 1;
7559         }
7560
7561       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7562           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7563                               integer_zero_node))
7564         cp_error ("zero-size array `%D'", decl);
7565
7566       layout_decl (decl, 0);
7567     }
7568 }
7569
7570 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7571    any appropriate error messages regarding the layout.  */
7572
7573 static void
7574 layout_var_decl (decl)
7575      tree decl;
7576 {
7577   tree type = TREE_TYPE (decl);
7578 #if 0
7579   tree ttype = target_type (type);
7580 #endif
7581
7582   /* If we haven't already layed out this declaration, do so now.
7583      Note that we must not call complete type for an external object
7584      because it's type might involve templates that we are not
7585      supposed to isntantiate yet.  (And it's perfectly legal to say
7586      `extern X x' for some incomplete type `X'.)  */
7587   if (!DECL_EXTERNAL (decl))
7588     complete_type (type);
7589   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7590     layout_decl (decl, 0);
7591
7592   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7593     {
7594       /* An automatic variable with an incomplete type: that is an error.
7595          Don't talk about array types here, since we took care of that
7596          message in grokdeclarator.  */
7597       cp_error ("storage size of `%D' isn't known", decl);
7598       TREE_TYPE (decl) = error_mark_node;
7599     }
7600 #if 0
7601   /* Keep this code around in case we later want to control debug info
7602      based on whether a type is "used".  (jason 1999-11-11) */
7603
7604   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7605     /* Let debugger know it should output info for this type.  */
7606     note_debug_info_needed (ttype);
7607
7608   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7609     note_debug_info_needed (DECL_CONTEXT (decl));
7610 #endif
7611
7612   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7613       && DECL_SIZE (decl) != NULL_TREE
7614       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7615     {
7616       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7617         constant_expression_warning (DECL_SIZE (decl));
7618       else
7619         cp_error ("storage size of `%D' isn't constant", decl);
7620     }
7621 }
7622
7623 /* If a local static variable is declared in an inline function, or if
7624    we have a weak definition, we must endeavor to create only one
7625    instance of the variable at link-time.  */
7626
7627 static void
7628 maybe_commonize_var (decl)
7629      tree decl;
7630 {
7631   /* Static data in a function with comdat linkage also has comdat
7632      linkage.  */
7633   if (TREE_STATIC (decl)
7634       /* Don't mess with __FUNCTION__.  */
7635       && ! DECL_ARTIFICIAL (decl)
7636       && current_function_decl
7637       && DECL_CONTEXT (decl) == current_function_decl
7638       && (DECL_THIS_INLINE (current_function_decl)
7639           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7640       && TREE_PUBLIC (current_function_decl))
7641     {
7642       /* Rather than try to get this right with inlining, we suppress
7643          inlining of such functions.  */
7644       current_function_cannot_inline
7645         = "function with static variable cannot be inline";
7646
7647       /* If flag_weak, we don't need to mess with this, as we can just
7648          make the function weak, and let it refer to its unique local
7649          copy.  This works because we don't allow the function to be
7650          inlined.  */
7651       if (! flag_weak)
7652         {
7653           if (DECL_INTERFACE_KNOWN (current_function_decl))
7654             {
7655               TREE_PUBLIC (decl) = 1;
7656               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7657             }
7658           else if (DECL_INITIAL (decl) == NULL_TREE
7659                    || DECL_INITIAL (decl) == error_mark_node)
7660             {
7661               TREE_PUBLIC (decl) = 1;
7662               DECL_COMMON (decl) = 1;
7663             }
7664           /* else we lose. We can only do this if we can use common,
7665              which we can't if it has been initialized.  */
7666
7667           if (TREE_PUBLIC (decl))
7668             DECL_ASSEMBLER_NAME (decl)
7669               = build_static_name (current_function_decl, DECL_NAME (decl));
7670           else
7671             {
7672               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7673               cp_warning_at ("  you can work around this by removing the initializer", decl);
7674             }
7675         }
7676     }
7677   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7678     /* Set it up again; we might have set DECL_INITIAL since the last
7679        time.  */
7680     comdat_linkage (decl);
7681 }
7682
7683 /* Issue an error message if DECL is an uninitialized const variable.  */
7684
7685 static void
7686 check_for_uninitialized_const_var (decl)
7687      tree decl;
7688 {
7689   tree type = TREE_TYPE (decl);
7690
7691   /* ``Unless explicitly declared extern, a const object does not have
7692      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7693      7.1.6 */
7694   if (TREE_CODE (decl) == VAR_DECL
7695       && TREE_CODE (type) != REFERENCE_TYPE
7696       && CP_TYPE_CONST_P (type)
7697       && !TYPE_NEEDS_CONSTRUCTING (type)
7698       && !DECL_INITIAL (decl))
7699     cp_error ("uninitialized const `%D'", decl);
7700 }
7701
7702 /* Verify INIT (the initializer for DECL), and record the
7703    initialization in DECL_INITIAL, if appropriate.  Returns a new
7704    value for INIT.  */
7705
7706 static tree
7707 check_initializer (decl, init)
7708      tree decl;
7709      tree init;
7710 {
7711   tree type;
7712
7713   if (TREE_CODE (decl) == FIELD_DECL)
7714     return init;
7715
7716   type = TREE_TYPE (decl);
7717
7718   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7719   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7720     init = NULL_TREE;
7721
7722   /* Check the initializer.  */
7723   if (init)
7724     {
7725       /* Things that are going to be initialized need to have complete
7726          type.  */
7727       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7728
7729       if (type == error_mark_node)
7730         /* We will have already complained.  */
7731         init = NULL_TREE;
7732       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7733         {
7734           cp_error ("variable-sized object `%D' may not be initialized", decl);
7735           init = NULL_TREE;
7736         }
7737       else if (TREE_CODE (type) == ARRAY_TYPE
7738                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7739         {
7740           cp_error ("elements of array `%#D' have incomplete type", decl);
7741           init = NULL_TREE;
7742         }
7743       else if (!COMPLETE_TYPE_P (type))
7744         {
7745           cp_error ("`%D' has incomplete type", decl);
7746           TREE_TYPE (decl) = error_mark_node;
7747           init = NULL_TREE;
7748         }
7749     }
7750
7751   if (TREE_CODE (decl) == CONST_DECL)
7752     {
7753       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7754
7755       DECL_INITIAL (decl) = init;
7756
7757       /* This will keep us from needing to worry about our obstacks.  */
7758       my_friendly_assert (init != NULL_TREE, 149);
7759       init = NULL_TREE;
7760     }
7761   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7762     {
7763       if (TREE_STATIC (decl))
7764         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7765       grok_reference_init (decl, type, init);
7766       init = NULL_TREE;
7767     }
7768   else if (init)
7769     {
7770       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7771         {
7772           if (TREE_CODE (type) == ARRAY_TYPE)
7773             init = digest_init (type, init, (tree *) 0);
7774           else if (TREE_CODE (init) == CONSTRUCTOR
7775                    && TREE_HAS_CONSTRUCTOR (init))
7776             {
7777               if (TYPE_NON_AGGREGATE_CLASS (type))
7778                 {
7779                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7780                             decl);
7781                   init = error_mark_node;
7782                 }
7783               else
7784                 goto dont_use_constructor;
7785             }
7786         }
7787       else
7788         {
7789         dont_use_constructor:
7790           if (TREE_CODE (init) != TREE_VEC)
7791             init = store_init_value (decl, init);
7792         }
7793
7794       if (init)
7795         /* We must hide the initializer so that expand_decl
7796            won't try to do something it does not understand.  */
7797         init = obscure_complex_init (decl, init);
7798     }
7799   else if (DECL_EXTERNAL (decl))
7800     ;
7801   else if (TYPE_P (type)
7802            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7803     {
7804       tree core_type = strip_array_types (type);
7805
7806       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7807         {
7808           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7809             cp_error ("structure `%D' with uninitialized const members", decl);
7810           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7811             cp_error ("structure `%D' with uninitialized reference members",
7812                       decl);
7813         }
7814
7815       check_for_uninitialized_const_var (decl);
7816
7817       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7818         init = obscure_complex_init (decl, NULL_TREE);
7819
7820     }
7821   else
7822     check_for_uninitialized_const_var (decl);
7823
7824   return init;
7825 }
7826
7827 /* If DECL is not a local variable, give it RTL.  */
7828
7829 static void
7830 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7831      tree decl;
7832      tree init;
7833      const char *asmspec;
7834 {
7835   int toplev = toplevel_bindings_p ();
7836   int defer_p;
7837
7838   /* Handle non-variables up front.  */
7839   if (TREE_CODE (decl) != VAR_DECL)
7840     {
7841       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7842       return;
7843     }
7844
7845   /* If we see a class member here, it should be a static data
7846      member.  */
7847   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7848     {
7849       my_friendly_assert (TREE_STATIC (decl), 19990828);
7850       /* An in-class declaration of a static data member should be
7851          external; it is only a declaration, and not a definition.  */
7852       if (init == NULL_TREE)
7853         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7854     }
7855
7856   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7857   if (asmspec)
7858     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7859
7860   /* We don't create any RTL for local variables.  */
7861   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7862     return;
7863
7864   /* We defer emission of local statics until the corresponding
7865      DECL_STMT is expanded.  */
7866   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7867
7868   /* We try to defer namespace-scope static constants so that they are
7869      not emitted into the object file unncessarily.  */
7870   if (!DECL_VIRTUAL_P (decl)
7871       && TREE_READONLY (decl)
7872       && DECL_INITIAL (decl) != NULL_TREE
7873       && DECL_INITIAL (decl) != error_mark_node
7874       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7875       && toplev
7876       && !TREE_PUBLIC (decl))
7877     {
7878       /* Fool with the linkage according to #pragma interface.  */
7879       if (!interface_unknown)
7880         {
7881           TREE_PUBLIC (decl) = 1;
7882           DECL_EXTERNAL (decl) = interface_only;
7883         }
7884
7885       defer_p = 1;
7886     }
7887
7888   /* If we're deferring the variable, just make RTL.  Do not actually
7889      emit the variable.  */
7890   if (defer_p)
7891     make_decl_rtl (decl, asmspec, toplev);
7892   /* If we're not deferring, go ahead and assemble the variable.  */
7893   else
7894     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7895 }
7896
7897 /* The old ARM scoping rules injected variables declared in the
7898    initialization statement of a for-statement into the surrounding
7899    scope.  We support this usage, in order to be backward-compatible.
7900    DECL is a just-declared VAR_DECL; if necessary inject its
7901    declaration into the surrounding scope.  */
7902
7903 void
7904 maybe_inject_for_scope_var (decl)
7905      tree decl;
7906 {
7907   if (!DECL_NAME (decl))
7908     return;
7909
7910   if (current_binding_level->is_for_scope)
7911     {
7912       struct binding_level *outer
7913         = current_binding_level->level_chain;
7914
7915       /* Check to see if the same name is already bound at the outer
7916          level, either because it was directly declared, or because a
7917          dead for-decl got preserved.  In either case, the code would
7918          not have been valid under the ARM scope rules, so clear
7919          is_for_scope for the current_binding_level.
7920
7921          Otherwise, we need to preserve the temp slot for decl to last
7922          into the outer binding level.  */
7923
7924       tree outer_binding
7925         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7926
7927       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7928           && (TREE_CODE (BINDING_VALUE (outer_binding))
7929               == VAR_DECL)
7930           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7931         {
7932           BINDING_VALUE (outer_binding)
7933             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7934           current_binding_level->is_for_scope = 0;
7935         }
7936       else if (DECL_IN_MEMORY_P (decl))
7937         preserve_temp_slots (DECL_RTL (decl));
7938     }
7939 }
7940
7941 /* Generate code to initialize DECL (a local variable).  */
7942
7943 void
7944 initialize_local_var (decl, init, flags)
7945      tree decl;
7946      tree init;
7947      int flags;
7948 {
7949   tree type = TREE_TYPE (decl);
7950
7951   /* If the type is bogus, don't bother initializing the variable.  */
7952   if (type == error_mark_node)
7953     return;
7954
7955   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7956     {
7957       /* If we used it already as memory, it must stay in memory.  */
7958       DECL_INITIAL (decl) = NULL_TREE;
7959       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7960     }
7961
7962   /* Local statics are handled differently from ordinary automatic
7963      variables.  */
7964   if (TREE_STATIC (decl))
7965     {
7966       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7967           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7968         expand_static_init (decl, init);
7969       return;
7970     }
7971
7972   if (DECL_SIZE (decl) && type != error_mark_node)
7973     {
7974       int already_used;
7975
7976       /* Compute and store the initial value.  */
7977       already_used = TREE_USED (decl) || TREE_USED (type);
7978
7979       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7980         {
7981           int saved_stmts_are_full_exprs_p;
7982
7983           my_friendly_assert (building_stmt_tree (), 20000906);
7984           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7985           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7986           finish_expr_stmt (build_aggr_init (decl, init, flags));
7987           current_stmt_tree ()->stmts_are_full_exprs_p =
7988             saved_stmts_are_full_exprs_p;
7989         }
7990
7991       /* Set this to 0 so we can tell whether an aggregate which was
7992          initialized was ever used.  Don't do this if it has a
7993          destructor, so we don't complain about the 'resource
7994          allocation is initialization' idiom.  Now set
7995          attribute((unused)) on types so decls of that type will be
7996          marked used. (see TREE_USED, above.)  */
7997       if (TYPE_NEEDS_CONSTRUCTING (type)
7998           && ! already_used
7999           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8000           && DECL_NAME (decl))
8001         TREE_USED (decl) = 0;
8002       else if (already_used)
8003         TREE_USED (decl) = 1;
8004     }
8005 }
8006
8007 /* Generate code to destroy DECL (a local variable).  */
8008
8009 static void
8010 destroy_local_var (decl)
8011      tree decl;
8012 {
8013   tree type = TREE_TYPE (decl);
8014   tree cleanup;
8015
8016   /* Only variables get cleaned up.  */
8017   if (TREE_CODE (decl) != VAR_DECL)
8018     return;
8019
8020   /* And only things with destructors need cleaning up.  */
8021   if (type == error_mark_node
8022       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8023     return;
8024
8025   if (TREE_CODE (decl) == VAR_DECL &&
8026       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8027     /* We don't clean up things that aren't defined in this
8028        translation unit, or that need a static cleanup.  The latter
8029        are handled by finish_file.  */
8030     return;
8031
8032   /* Compute the cleanup.  */
8033   cleanup = maybe_build_cleanup (decl);
8034
8035   /* Record the cleanup required for this declaration.  */
8036   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8037       && cleanup)
8038     finish_decl_cleanup (decl, cleanup);
8039 }
8040
8041 /* Finish processing of a declaration;
8042    install its line number and initial value.
8043    If the length of an array type is not known before,
8044    it must be determined now, from the initial value, or it is an error.
8045
8046    INIT holds the value of an initializer that should be allowed to escape
8047    the normal rules.
8048
8049    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8050    if the (init) syntax was used.  */
8051
8052 void
8053 cp_finish_decl (decl, init, asmspec_tree, flags)
8054      tree decl, init;
8055      tree asmspec_tree;
8056      int flags;
8057 {
8058   register tree type;
8059   tree ttype = NULL_TREE;
8060   const char *asmspec = NULL;
8061   int was_readonly = 0;
8062
8063   if (! decl)
8064     {
8065       if (init)
8066         error ("assignment (not initialization) in declaration");
8067       return;
8068     }
8069
8070   /* If a name was specified, get the string.  */
8071   if (asmspec_tree)
8072       asmspec = TREE_STRING_POINTER (asmspec_tree);
8073
8074   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8075     {
8076       cp_error ("cannot initialize `%D' to namespace `%D'",
8077                 decl, init);
8078       init = NULL_TREE;
8079     }
8080
8081   if (current_class_type
8082       && CP_DECL_CONTEXT (decl) == current_class_type
8083       && TYPE_BEING_DEFINED (current_class_type)
8084       && (DECL_INITIAL (decl) || init))
8085     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8086
8087   if (TREE_CODE (decl) == VAR_DECL
8088       && DECL_CONTEXT (decl)
8089       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8090       && DECL_CONTEXT (decl) != current_namespace
8091       && init)
8092     {
8093       /* Leave the namespace of the object. */
8094       pop_decl_namespace ();
8095     }
8096
8097   type = TREE_TYPE (decl);
8098
8099   if (type == error_mark_node)
8100     return;
8101
8102   /* Add this declaration to the statement-tree.  */
8103   if (building_stmt_tree ()
8104       && at_function_scope_p ()
8105       && TREE_CODE (decl) != RESULT_DECL)
8106     add_decl_stmt (decl);
8107
8108   if (TYPE_HAS_MUTABLE_P (type))
8109     TREE_READONLY (decl) = 0;
8110
8111   if (processing_template_decl)
8112     {
8113       if (init && DECL_INITIAL (decl))
8114         DECL_INITIAL (decl) = init;
8115       goto finish_end0;
8116     }
8117
8118   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8119   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8120
8121   /* Take care of TYPE_DECLs up front.  */
8122   if (TREE_CODE (decl) == TYPE_DECL)
8123     {
8124       if (init && DECL_INITIAL (decl))
8125         {
8126           /* typedef foo = bar; store the type of bar as the type of foo.  */
8127           TREE_TYPE (decl) = type = TREE_TYPE (init);
8128           DECL_INITIAL (decl) = init = NULL_TREE;
8129         }
8130       if (type != error_mark_node
8131           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8132         {
8133           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8134             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8135           set_identifier_type_value (DECL_NAME (decl), type);
8136           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8137         }
8138       GNU_xref_decl (current_function_decl, decl);
8139
8140       /* If we have installed this as the canonical typedef for this
8141          type, and that type has not been defined yet, delay emitting
8142          the debug information for it, as we will emit it later.  */
8143       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8144           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8145         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8146
8147       rest_of_decl_compilation (decl, NULL_PTR,
8148                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8149       goto finish_end;
8150     }
8151
8152   if (TREE_CODE (decl) != FUNCTION_DECL)
8153     ttype = target_type (type);
8154
8155   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8156       && TYPE_NEEDS_CONSTRUCTING (type))
8157     {
8158       /* Currently, GNU C++ puts constants in text space, making them
8159          impossible to initialize.  In the future, one would hope for
8160          an operating system which understood the difference between
8161          initialization and the running of a program.  */
8162       was_readonly = 1;
8163       TREE_READONLY (decl) = 0;
8164     }
8165
8166   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8167     {
8168       /* This must override the asm specifier which was placed by
8169          grokclassfn.  Lay this out fresh.  */
8170       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8171       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8172       make_decl_rtl (decl, asmspec, 0);
8173     }
8174
8175   /* Deduce size of array from initialization, if not already known.  */
8176   maybe_deduce_size_from_array_init (decl, init);
8177   init = check_initializer (decl, init);
8178
8179   GNU_xref_decl (current_function_decl, decl);
8180
8181   if (TREE_CODE (decl) == VAR_DECL)
8182     layout_var_decl (decl);
8183
8184   /* Output the assembler code and/or RTL code for variables and functions,
8185      unless the type is an undefined structure or union.
8186      If not, it will get done when the type is completed.  */
8187   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8188       || TREE_CODE (decl) == RESULT_DECL)
8189     {
8190       if (TREE_CODE (decl) == VAR_DECL)
8191         maybe_commonize_var (decl);
8192
8193       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8194
8195       if (TREE_CODE (type) == FUNCTION_TYPE
8196           || TREE_CODE (type) == METHOD_TYPE)
8197         abstract_virtuals_error (decl,
8198                                  strip_array_types (TREE_TYPE (type)));
8199       else
8200         abstract_virtuals_error (decl, strip_array_types (type));
8201
8202       if (TREE_CODE (decl) == FUNCTION_DECL)
8203         ;
8204       else if (DECL_EXTERNAL (decl)
8205                && ! (DECL_LANG_SPECIFIC (decl)
8206                      && DECL_NOT_REALLY_EXTERN (decl)))
8207         {
8208           if (init)
8209             DECL_INITIAL (decl) = init;
8210         }
8211       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8212         {
8213           /* This is a local declaration.  */
8214           if (doing_semantic_analysis_p ())
8215             maybe_inject_for_scope_var (decl);
8216           /* Initialize the local variable.  But, if we're building a
8217              statement-tree, we'll do the initialization when we
8218              expand the tree.  */
8219           if (processing_template_decl)
8220             {
8221               if (init || DECL_INITIAL (decl) == error_mark_node)
8222                 DECL_INITIAL (decl) = init;
8223             }
8224           else
8225             {
8226               /* If we're not building RTL, then we need to do so
8227                  now.  */
8228               my_friendly_assert (building_stmt_tree (), 20000906);
8229               /* Initialize the variable.  */
8230               initialize_local_var (decl, init, flags);
8231               /* Clean up the variable.  */
8232               destroy_local_var (decl);
8233             }
8234         }
8235       else if (TREE_STATIC (decl) && type != error_mark_node)
8236         {
8237           /* Cleanups for static variables are handled by `finish_file'.  */
8238           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8239               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8240             expand_static_init (decl, init);
8241         }
8242     finish_end0:
8243
8244       /* Undo call to `pushclass' that was done in `start_decl'
8245          due to initialization of qualified member variable.
8246          I.e., Foo::x = 10;  */
8247       {
8248         tree context = CP_DECL_CONTEXT (decl);
8249         if (context
8250             && TYPE_P (context)
8251             && (TREE_CODE (decl) == VAR_DECL
8252                 /* We also have a pushclass done that we need to undo here
8253                    if we're at top level and declare a method.  */
8254                 || TREE_CODE (decl) == FUNCTION_DECL)
8255             /* If size hasn't been set, we're still defining it,
8256                and therefore inside the class body; don't pop
8257                the binding level..  */
8258             && COMPLETE_TYPE_P (context)
8259             && context == current_class_type)
8260           pop_nested_class ();
8261       }
8262     }
8263
8264  finish_end:
8265
8266   if (was_readonly)
8267     TREE_READONLY (decl) = 1;
8268 }
8269
8270 /* This is here for a midend callback from c-common.c */
8271
8272 void
8273 finish_decl (decl, init, asmspec_tree)
8274      tree decl, init;
8275      tree asmspec_tree;
8276 {
8277   cp_finish_decl (decl, init, asmspec_tree, 0);
8278 }
8279
8280 /* Returns a declaration for a VAR_DECL as if:
8281
8282      extern "C" TYPE NAME;
8283
8284    had been seen.  Used to create compiler-generated global
8285    variables.  */
8286
8287 tree
8288 declare_global_var (name, type)
8289      tree name;
8290      tree type;
8291 {
8292   tree decl;
8293
8294   push_to_top_level ();
8295   decl = build_decl (VAR_DECL, name, type);
8296   TREE_PUBLIC (decl) = 1;
8297   DECL_EXTERNAL (decl) = 1;
8298   DECL_ARTIFICIAL (decl) = 1;
8299   pushdecl (decl);
8300   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8301   pop_from_top_level ();
8302
8303   return decl;
8304 }
8305
8306 /* Returns a pointer to the `atexit' function.  Note that if
8307    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8308    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8309
8310 static tree
8311 get_atexit_node ()
8312 {
8313   tree atexit_fndecl;
8314   tree arg_types;
8315   tree fn_type;
8316   tree fn_ptr_type;
8317   const char *name;
8318
8319   if (atexit_node)
8320     return atexit_node;
8321
8322   if (flag_use_cxa_atexit)
8323     {
8324       /* The declaration for `__cxa_atexit' is:
8325
8326            int __cxa_atexit (void (*)(void *), void *, void *)
8327
8328          We build up the argument types and then then function type
8329          itself.  */
8330
8331       /* First, build the pointer-to-function type for the first
8332          argument.  */
8333       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8334       fn_type = build_function_type (void_type_node, arg_types);
8335       fn_ptr_type = build_pointer_type (fn_type);
8336       /* Then, build the rest of the argument types.  */
8337       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8338       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8339       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8340       /* And the final __cxa_atexit type.  */
8341       fn_type = build_function_type (integer_type_node, arg_types);
8342       fn_ptr_type = build_pointer_type (fn_type);
8343       name = "__cxa_atexit";
8344     }
8345   else
8346     {
8347       /* The declaration for `atexit' is:
8348
8349            int atexit (void (*)());
8350
8351          We build up the argument types and then then function type
8352          itself.  */
8353       fn_type = build_function_type (void_type_node, void_list_node);
8354       fn_ptr_type = build_pointer_type (fn_type);
8355       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8356       /* Build the final atexit type.  */
8357       fn_type = build_function_type (integer_type_node, arg_types);
8358       name = "atexit";
8359     }
8360
8361   /* Now, build the function declaration.  */
8362   push_lang_context (lang_name_c);
8363   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8364   mark_used (atexit_fndecl);
8365   pop_lang_context ();
8366   atexit_node = default_conversion (atexit_fndecl);
8367
8368   return atexit_node;
8369 }
8370
8371 /* Returns the __dso_handle VAR_DECL.  */
8372
8373 static tree
8374 get_dso_handle_node ()
8375 {
8376   if (dso_handle_node)
8377     return dso_handle_node;
8378
8379   /* Declare the variable.  */
8380   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8381                                         ptr_type_node);
8382
8383   return dso_handle_node;
8384 }
8385
8386 /* Begin a new function with internal linkage whose job will be simply
8387    to destroy some particular variable.  */
8388
8389 static tree
8390 start_cleanup_fn ()
8391 {
8392   static int counter = 0;
8393   int old_interface_unknown = interface_unknown;
8394   char name[32];
8395   tree parmtypes;
8396   tree fntype;
8397   tree fndecl;
8398
8399   push_to_top_level ();
8400
8401   /* No need to mangle this.  */
8402   push_lang_context (lang_name_c);
8403
8404   interface_unknown = 1;
8405
8406   /* Build the parameter-types.  */
8407   parmtypes = void_list_node;
8408   /* Functions passed to __cxa_atexit take an additional parameter.
8409      We'll just ignore it.  After we implement the new calling
8410      convention for destructors, we can eliminate the use of
8411      additional cleanup functions entirely in the -fnew-abi case.  */
8412   if (flag_use_cxa_atexit)
8413     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8414   /* Build the function type itself.  */
8415   fntype = build_function_type (void_type_node, parmtypes);
8416   /* Build the name of the function.  */
8417   sprintf (name, "__tcf_%d", counter++);
8418   /* Build the function declaration.  */
8419   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8420   /* It's a function with internal linkage, generated by the
8421      compiler.  */
8422   TREE_PUBLIC (fndecl) = 0;
8423   DECL_ARTIFICIAL (fndecl) = 1;
8424   /* Make the function `inline' so that it is only emitted if it is
8425      actually needed.  It is unlikely that it will be inlined, since
8426      it is only called via a function pointer, but we avoid unncessary
8427      emissions this way.  */
8428   DECL_INLINE (fndecl) = 1;
8429   /* Build the parameter.  */
8430   if (flag_use_cxa_atexit)
8431     {
8432       tree parmdecl;
8433
8434       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8435       DECL_CONTEXT (parmdecl) = fndecl;
8436       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8437       TREE_USED (parmdecl) = 1;
8438       DECL_ARGUMENTS (fndecl) = parmdecl;
8439     }
8440
8441   pushdecl (fndecl);
8442   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8443   do_pushlevel ();
8444
8445   interface_unknown = old_interface_unknown;
8446
8447   pop_lang_context ();
8448
8449   return current_function_decl;
8450 }
8451
8452 /* Finish the cleanup function begun by start_cleanup_fn.  */
8453
8454 static void
8455 end_cleanup_fn ()
8456 {
8457   do_poplevel ();
8458
8459   expand_body (finish_function (0));
8460
8461   pop_from_top_level ();
8462 }
8463
8464 /* Generate code to handle the destruction of DECL, an object with
8465    static storage duration.  */
8466
8467 void
8468 register_dtor_fn (decl)
8469      tree decl;
8470 {
8471   tree cleanup;
8472   tree compound_stmt;
8473   tree args;
8474   tree fcall;
8475
8476   int saved_flag_access_control;
8477
8478   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8479     return;
8480
8481   /* Call build_cleanup before we enter the anonymous function so that
8482      any access checks will be done relative to the current scope,
8483      rather than the scope of the anonymous function.  */
8484   build_cleanup (decl);
8485
8486   /* Now start the function.  */
8487   cleanup = start_cleanup_fn ();
8488
8489   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8490      to the original function, rather than the anonymous one.  That
8491      will make the back-end think that nested functions are in use,
8492      which causes confusion.  */
8493   saved_flag_access_control = flag_access_control;
8494   flag_access_control = 0;
8495   fcall = build_cleanup (decl);
8496   flag_access_control = saved_flag_access_control;
8497
8498   /* Create the body of the anonymous function.  */
8499   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8500   finish_expr_stmt (fcall);
8501   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8502   end_cleanup_fn ();
8503
8504   /* Call atexit with the cleanup function.  */
8505   mark_addressable (cleanup);
8506   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8507   if (flag_use_cxa_atexit)
8508     {
8509       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8510       args = tree_cons (NULL_TREE, null_pointer_node, args);
8511       args = tree_cons (NULL_TREE, cleanup, args);
8512     }
8513   else
8514     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8515   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8516 }
8517
8518 void
8519 expand_static_init (decl, init)
8520      tree decl;
8521      tree init;
8522 {
8523   tree oldstatic = value_member (decl, static_aggregates);
8524
8525   if (oldstatic)
8526     {
8527       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8528         cp_error ("multiple initializations given for `%D'", decl);
8529     }
8530   else if (! toplevel_bindings_p ())
8531     {
8532       /* Emit code to perform this initialization but once.  */
8533       tree if_stmt;
8534       tree then_clause;
8535       tree assignment;
8536       tree guard;
8537       tree guard_init;
8538
8539       /* Emit code to perform this initialization but once.  This code
8540          looks like:
8541
8542            static int guard = 0;
8543            if (!guard) {
8544              // Do initialization.
8545              guard = 1;
8546              // Register variable for destruction at end of program.
8547            }
8548
8549          Note that the `temp' variable is only set to 1 *after* the
8550          initialization is complete.  This ensures that an exception,
8551          thrown during the construction, will cause the variable to
8552          reinitialized when we pass through this code again, as per:
8553
8554            [stmt.dcl]
8555
8556            If the initialization exits by throwing an exception, the
8557            initialization is not complete, so it will be tried again
8558            the next time control enters the declaration.
8559
8560          In theory, this process should be thread-safe, too; multiple
8561          threads should not be able to initialize the variable more
8562          than once.  We don't yet attempt to ensure thread-safety.  */
8563
8564       /* Create the guard variable.  */
8565       guard = get_guard (decl);
8566
8567       /* Begin the conditional initialization.  */
8568       if_stmt = begin_if_stmt ();
8569       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8570       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8571
8572       /* Do the initialization itself.  */
8573       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8574           || (init && TREE_CODE (init) == TREE_LIST))
8575         assignment = build_aggr_init (decl, init, 0);
8576       else if (init)
8577         /* The initialization we're doing here is just a bitwise
8578            copy.  */
8579         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8580       else
8581         assignment = NULL_TREE;
8582
8583       /* Once the assignment is complete, set TEMP to 1.  Since the
8584          construction of the static object is complete at this point,
8585          we want to make sure TEMP is set to 1 even if a temporary
8586          constructed during the initialization throws an exception
8587          when it is destroyed.  So, we combine the initialization and
8588          the assignment to TEMP into a single expression, ensuring
8589          that when we call finish_expr_stmt the cleanups will not be
8590          run until after TEMP is set to 1.  */
8591       guard_init = set_guard (guard);
8592       if (assignment)
8593         {
8594           assignment = tree_cons (NULL_TREE, assignment,
8595                                   build_tree_list (NULL_TREE,
8596                                                    guard_init));
8597           assignment = build_compound_expr (assignment);
8598         }
8599       else
8600         assignment = guard_init;
8601       finish_expr_stmt (assignment);
8602
8603       /* Use atexit to register a function for destroying this static
8604          variable.  */
8605       register_dtor_fn (decl);
8606
8607       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8608       finish_then_clause (if_stmt);
8609       finish_if_stmt ();
8610     }
8611   else
8612     static_aggregates = tree_cons (init, decl, static_aggregates);
8613 }
8614
8615 /* Finish the declaration of a catch-parameter.  */
8616
8617 tree
8618 start_handler_parms (declspecs, declarator)
8619      tree declspecs;
8620      tree declarator;
8621 {
8622   tree decl;
8623   if (declspecs)
8624     {
8625       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8626                              1, NULL_TREE);
8627       if (decl == NULL_TREE)
8628         error ("invalid catch parameter");
8629     }
8630   else
8631     decl = NULL_TREE;
8632
8633   return decl;
8634 }
8635
8636 \f
8637 /* Make TYPE a complete type based on INITIAL_VALUE.
8638    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8639    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8640
8641 int
8642 complete_array_type (type, initial_value, do_default)
8643      tree type, initial_value;
8644      int do_default;
8645 {
8646   register tree maxindex = NULL_TREE;
8647   int value = 0;
8648
8649   if (initial_value)
8650     {
8651       /* An array of character type can be initialized from a
8652          brace-enclosed string constant.  */
8653       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8654           && TREE_CODE (initial_value) == CONSTRUCTOR
8655           && CONSTRUCTOR_ELTS (initial_value)
8656           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8657               == STRING_CST)
8658           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8659         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8660
8661       /* Note MAXINDEX is really the maximum index, one less than the
8662          size.  */
8663       if (TREE_CODE (initial_value) == STRING_CST)
8664         {
8665           int eltsize
8666             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8667           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8668                                    / eltsize) - 1, 0);
8669         }
8670       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8671         {
8672           tree elts = CONSTRUCTOR_ELTS (initial_value);
8673
8674           maxindex = ssize_int (-1);
8675           for (; elts; elts = TREE_CHAIN (elts))
8676             {
8677               if (TREE_PURPOSE (elts))
8678                 maxindex = TREE_PURPOSE (elts);
8679               else
8680                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8681             }
8682           maxindex = copy_node (maxindex);
8683         }
8684       else
8685         {
8686           /* Make an error message unless that happened already.  */
8687           if (initial_value != error_mark_node)
8688             value = 1;
8689           else
8690             initial_value = NULL_TREE;
8691
8692           /* Prevent further error messages.  */
8693           maxindex = build_int_2 (0, 0);
8694         }
8695     }
8696
8697   if (!maxindex)
8698     {
8699       if (do_default)
8700         maxindex = build_int_2 (0, 0);
8701       value = 2;
8702     }
8703
8704   if (maxindex)
8705     {
8706       tree itype;
8707       tree domain;
8708
8709       domain = build_index_type (maxindex);
8710       TYPE_DOMAIN (type) = domain;
8711
8712       if (! TREE_TYPE (maxindex))
8713         TREE_TYPE (maxindex) = domain;
8714       if (initial_value)
8715         itype = TREE_TYPE (initial_value);
8716       else
8717         itype = NULL;
8718       if (itype && !TYPE_DOMAIN (itype))
8719         TYPE_DOMAIN (itype) = domain;
8720       /* The type of the main variant should never be used for arrays
8721          of different sizes.  It should only ever be completed with the
8722          size of the array.  */
8723       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8724         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8725     }
8726
8727   /* Lay out the type now that we can get the real answer.  */
8728
8729   layout_type (type);
8730
8731   return value;
8732 }
8733 \f
8734 /* Return zero if something is declared to be a member of type
8735    CTYPE when in the context of CUR_TYPE.  STRING is the error
8736    message to print in that case.  Otherwise, quietly return 1.  */
8737
8738 static int
8739 member_function_or_else (ctype, cur_type, flags)
8740      tree ctype, cur_type;
8741      enum overload_flags flags;
8742 {
8743   if (ctype && ctype != cur_type)
8744     {
8745       if (flags == DTOR_FLAG)
8746         cp_error ("destructor for alien class `%T' cannot be a member",
8747                   ctype);
8748       else
8749         cp_error ("constructor for alien class `%T' cannot be a member",
8750                   ctype);
8751       return 0;
8752     }
8753   return 1;
8754 }
8755 \f
8756 /* Subroutine of `grokdeclarator'.  */
8757
8758 /* Generate errors possibly applicable for a given set of specifiers.
8759    This is for ARM $7.1.2.  */
8760
8761 static void
8762 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8763      tree object;
8764      const char *type;
8765      int virtualp, quals, friendp, raises, inlinep;
8766 {
8767   if (virtualp)
8768     cp_error ("`%D' declared as a `virtual' %s", object, type);
8769   if (inlinep)
8770     cp_error ("`%D' declared as an `inline' %s", object, type);
8771   if (quals)
8772     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8773               object, type);
8774   if (friendp)
8775     cp_error_at ("`%D' declared as a friend", object);
8776   if (raises)
8777     cp_error_at ("`%D' declared with an exception specification", object);
8778 }
8779
8780 /* CTYPE is class type, or null if non-class.
8781    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8782    or METHOD_TYPE.
8783    DECLARATOR is the function's name.
8784    VIRTUALP is truthvalue of whether the function is virtual or not.
8785    FLAGS are to be passed through to `grokclassfn'.
8786    QUALS are qualifiers indicating whether the function is `const'
8787    or `volatile'.
8788    RAISES is a list of exceptions that this function can raise.
8789    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8790    not look, and -1 if we should not call `grokclassfn' at all.
8791
8792    Returns `NULL_TREE' if something goes wrong, after issuing
8793    applicable error messages.  */
8794
8795 static tree
8796 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8797             raises, check, friendp, publicp, inlinep, funcdef_flag,
8798             template_count, in_namespace)
8799      tree ctype, type;
8800      tree declarator;
8801      tree orig_declarator;
8802      int virtualp;
8803      enum overload_flags flags;
8804      tree quals, raises;
8805      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8806      tree in_namespace;
8807 {
8808   tree cname, decl;
8809   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8810   int has_default_arg = 0;
8811   tree t;
8812
8813   if (ctype)
8814     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8815       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8816   else
8817     cname = NULL_TREE;
8818
8819   if (raises)
8820     {
8821       type = build_exception_variant (type, raises);
8822     }
8823
8824   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8825   /* Propagate volatile out from type to decl. */
8826   if (TYPE_VOLATILE (type))
8827     TREE_THIS_VOLATILE (decl) = 1;
8828
8829   /* If this decl has namespace scope, set that up.  */
8830   if (in_namespace)
8831     set_decl_namespace (decl, in_namespace, friendp);
8832   else if (!ctype)
8833     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8834
8835   /* `main' and builtins have implicit 'C' linkage.  */
8836   if ((MAIN_NAME_P (declarator)
8837        || (IDENTIFIER_LENGTH (declarator) > 10
8838            && IDENTIFIER_POINTER (declarator)[0] == '_'
8839            && IDENTIFIER_POINTER (declarator)[1] == '_'
8840            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8841       && current_lang_name == lang_name_cplusplus
8842       && ctype == NULL_TREE
8843       /* NULL_TREE means global namespace.  */
8844       && DECL_CONTEXT (decl) == NULL_TREE)
8845     DECL_LANGUAGE (decl) = lang_c;
8846
8847   /* Should probably propagate const out from type to decl I bet (mrs).  */
8848   if (staticp)
8849     {
8850       DECL_STATIC_FUNCTION_P (decl) = 1;
8851       DECL_CONTEXT (decl) = ctype;
8852     }
8853
8854   if (ctype)
8855     DECL_CONTEXT (decl) = ctype;
8856
8857   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8858     {
8859       if (processing_template_decl)
8860         error ("cannot declare `::main' to be a template");
8861       if (inlinep)
8862         error ("cannot declare `::main' to be inline");
8863       if (!publicp)
8864         error ("cannot declare `::main' to be static");
8865       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8866                         integer_type_node))
8867         error ("`main' must return `int'");
8868       inlinep = 0;
8869       publicp = 1;
8870     }
8871
8872   /* Members of anonymous types and local classes have no linkage; make
8873      them internal.  */
8874   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8875                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8876     publicp = 0;
8877
8878   if (publicp)
8879     {
8880       /* [basic.link]: A name with no linkage (notably, the name of a class
8881          or enumeration declared in a local scope) shall not be used to
8882          declare an entity with linkage.
8883
8884          Only check this for public decls for now.  */
8885       t = no_linkage_check (TREE_TYPE (decl));
8886       if (t)
8887         {
8888           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8889             {
8890               if (DECL_EXTERN_C_P (decl))
8891                 /* Allow this; it's pretty common in C.  */;
8892               else
8893                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8894                             decl);
8895             }
8896           else
8897             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8898                         decl, t);
8899         }
8900     }
8901
8902   TREE_PUBLIC (decl) = publicp;
8903   if (! publicp)
8904     {
8905       DECL_INTERFACE_KNOWN (decl) = 1;
8906       DECL_NOT_REALLY_EXTERN (decl) = 1;
8907     }
8908
8909   if (inlinep)
8910     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8911
8912   DECL_EXTERNAL (decl) = 1;
8913   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8914     {
8915       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8916                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8917       quals = NULL_TREE;
8918     }
8919
8920   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8921     grok_op_properties (decl, virtualp, check < 0);
8922
8923   if (ctype && decl_function_context (decl))
8924     DECL_NO_STATIC_CHAIN (decl) = 1;
8925
8926   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8927     if (TREE_PURPOSE (t)
8928         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8929       {
8930         has_default_arg = 1;
8931         break;
8932       }
8933
8934   if (friendp
8935       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8936     {
8937       if (funcdef_flag)
8938         cp_error
8939           ("defining explicit specialization `%D' in friend declaration",
8940            orig_declarator);
8941       else
8942         {
8943           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8944             {
8945               /* Something like `template <class T> friend void f<T>()'.  */
8946               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8947                         orig_declarator);
8948               return NULL_TREE;
8949             }
8950
8951
8952           /* A friend declaration of the form friend void f<>().  Record
8953              the information in the TEMPLATE_ID_EXPR.  */
8954           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8955           DECL_TEMPLATE_INFO (decl)
8956             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8957                          TREE_OPERAND (orig_declarator, 1),
8958                          NULL_TREE);
8959
8960           if (has_default_arg)
8961             {
8962               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8963                         decl);
8964               return NULL_TREE;
8965             }
8966
8967           if (inlinep)
8968             {
8969               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8970                         decl);
8971               return NULL_TREE;
8972             }
8973         }
8974     }
8975
8976   if (has_default_arg)
8977     add_defarg_fn (decl);
8978
8979   /* Plain overloading: will not be grok'd by grokclassfn.  */
8980   if (! ctype && ! processing_template_decl
8981       && !DECL_EXTERN_C_P (decl)
8982       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8983     set_mangled_name_for_decl (decl);
8984
8985   if (funcdef_flag)
8986     /* Make the init_value nonzero so pushdecl knows this is not
8987        tentative.  error_mark_node is replaced later with the BLOCK.  */
8988     DECL_INITIAL (decl) = error_mark_node;
8989
8990   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8991     TREE_NOTHROW (decl) = 1;
8992
8993   /* Caller will do the rest of this.  */
8994   if (check < 0)
8995     return decl;
8996
8997   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8998     DECL_CONSTRUCTOR_P (decl) = 1;
8999
9000   /* Function gets the ugly name, field gets the nice one.  This call
9001      may change the type of the function (because of default
9002      parameters)!  */
9003   if (ctype != NULL_TREE)
9004     grokclassfn (ctype, decl, flags, quals);
9005
9006   decl = check_explicit_specialization (orig_declarator, decl,
9007                                         template_count,
9008                                         2 * (funcdef_flag != 0) +
9009                                         4 * (friendp != 0));
9010   if (decl == error_mark_node)
9011     return NULL_TREE;
9012
9013   if (ctype != NULL_TREE
9014       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9015       && check)
9016     {
9017       tree old_decl;
9018
9019       old_decl = check_classfn (ctype, decl);
9020
9021       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9022         /* Because grokfndecl is always supposed to return a
9023            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9024            here.  We depend on our callers to figure out that its
9025            really a template that's being returned.  */
9026         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9027
9028       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9029           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9030         {
9031           /* Remove the `this' parm added by grokclassfn.
9032              XXX Isn't this done in start_function, too?  */
9033           revert_static_member_fn (decl);
9034           last_function_parms = TREE_CHAIN (last_function_parms);
9035         }
9036       if (old_decl && DECL_ARTIFICIAL (old_decl))
9037         cp_error ("definition of implicitly-declared `%D'", old_decl);
9038
9039       if (old_decl)
9040         {
9041           /* Since we've smashed OLD_DECL to its
9042              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9043           if (TREE_CODE (decl) == TEMPLATE_DECL)
9044             decl = DECL_TEMPLATE_RESULT (decl);
9045
9046           /* Attempt to merge the declarations.  This can fail, in
9047              the case of some illegal specialization declarations.  */
9048           if (!duplicate_decls (decl, old_decl))
9049             cp_error ("no `%#D' member function declared in class `%T'",
9050                       decl, ctype);
9051           return old_decl;
9052         }
9053     }
9054
9055   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9056     return NULL_TREE;
9057
9058   if (ctype == NULL_TREE || check)
9059     return decl;
9060
9061   if (virtualp)
9062     {
9063       DECL_VIRTUAL_P (decl) = 1;
9064       if (DECL_VINDEX (decl) == NULL_TREE)
9065         DECL_VINDEX (decl) = error_mark_node;
9066       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9067     }
9068
9069   return decl;
9070 }
9071
9072 static tree
9073 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9074      tree type;
9075      tree declarator;
9076      RID_BIT_TYPE *specbits_in;
9077      int initialized;
9078      int constp;
9079      tree in_namespace;
9080 {
9081   tree decl;
9082   RID_BIT_TYPE specbits;
9083
9084   specbits = *specbits_in;
9085
9086   if (TREE_CODE (type) == OFFSET_TYPE)
9087     {
9088       /* If you declare a static member so that it
9089          can be initialized, the code will reach here.  */
9090       tree basetype = TYPE_OFFSET_BASETYPE (type);
9091       type = TREE_TYPE (type);
9092       decl = build_lang_decl (VAR_DECL, declarator, type);
9093       DECL_CONTEXT (decl) = basetype;
9094       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9095          templates.  */
9096       if (!uses_template_parms (decl))
9097         {
9098           if (flag_new_abi)
9099             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9100           else
9101             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9102                                                             declarator);
9103         }
9104     }
9105   else
9106     {
9107       tree context;
9108
9109       if (in_namespace)
9110         context = in_namespace;
9111       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9112         context = current_namespace;
9113       else
9114         context = NULL_TREE;
9115
9116       if (processing_template_decl && context)
9117         /* For global variables, declared in a template, we need the
9118            full lang_decl.  */
9119         decl = build_lang_decl (VAR_DECL, declarator, type);
9120       else
9121         decl = build_decl (VAR_DECL, declarator, type);
9122
9123       if (context)
9124         set_decl_namespace (decl, context, 0);
9125
9126       context = DECL_CONTEXT (decl);
9127       if (declarator && context && current_lang_name != lang_name_c)
9128         {
9129           if (flag_new_abi)
9130             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9131           else
9132             DECL_ASSEMBLER_NAME (decl)
9133               = build_static_name (context, declarator);
9134         }
9135     }
9136
9137   if (in_namespace)
9138     set_decl_namespace (decl, in_namespace, 0);
9139
9140   if (RIDBIT_SETP (RID_EXTERN, specbits))
9141     {
9142       DECL_THIS_EXTERN (decl) = 1;
9143       DECL_EXTERNAL (decl) = !initialized;
9144     }
9145
9146   /* In class context, static means one per class,
9147      public access, and static storage.  */
9148   if (DECL_CLASS_SCOPE_P (decl))
9149     {
9150       TREE_PUBLIC (decl) = 1;
9151       TREE_STATIC (decl) = 1;
9152       DECL_EXTERNAL (decl) = 0;
9153     }
9154   /* At top level, either `static' or no s.c. makes a definition
9155      (perhaps tentative), and absence of `static' makes it public.  */
9156   else if (toplevel_bindings_p ())
9157     {
9158       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9159                             && (DECL_THIS_EXTERN (decl) || ! constp));
9160       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9161     }
9162   /* Not at top level, only `static' makes a static definition.  */
9163   else
9164     {
9165       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9166       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9167     }
9168
9169   if (TREE_PUBLIC (decl))
9170     {
9171       /* [basic.link]: A name with no linkage (notably, the name of a class
9172          or enumeration declared in a local scope) shall not be used to
9173          declare an entity with linkage.
9174
9175          Only check this for public decls for now.  */
9176       tree t = no_linkage_check (TREE_TYPE (decl));
9177       if (t)
9178         {
9179           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9180             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9181           else
9182             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9183                         decl, t);
9184         }
9185     }
9186
9187   return decl;
9188 }
9189
9190 /* Create and return a canonical pointer to member function type, for
9191    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9192
9193 tree
9194 build_ptrmemfunc_type (type)
9195      tree type;
9196 {
9197   tree fields[4];
9198   tree t;
9199   tree u;
9200   tree unqualified_variant = NULL_TREE;
9201
9202   /* If a canonical type already exists for this type, use it.  We use
9203      this method instead of type_hash_canon, because it only does a
9204      simple equality check on the list of field members.  */
9205
9206   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9207     return t;
9208
9209   /* Make sure that we always have the unqualified pointer-to-member
9210      type first.  */
9211   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9212     unqualified_variant
9213       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9214
9215   t = make_aggr_type (RECORD_TYPE);
9216   /* Let the front-end know this is a pointer to member function...  */
9217   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9218   /* ... and not really an aggregate.  */
9219   SET_IS_AGGR_TYPE (t, 0);
9220
9221   if (!flag_new_abi)
9222     {
9223       u = make_aggr_type (UNION_TYPE);
9224       SET_IS_AGGR_TYPE (u, 0);
9225       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9226       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9227                               delta_type_node);
9228       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9229       TYPE_NAME (u) = NULL_TREE;
9230
9231       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9232                               delta_type_node);
9233       fields[1] = build_decl (FIELD_DECL, index_identifier,
9234                               delta_type_node);
9235       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9236       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9237     }
9238   else
9239     {
9240       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9241       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9242                               delta_type_node);
9243       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9244     }
9245
9246   /* Zap out the name so that the back-end will give us the debugging
9247      information for this anonymous RECORD_TYPE.  */
9248   TYPE_NAME (t) = NULL_TREE;
9249
9250   /* If this is not the unqualified form of this pointer-to-member
9251      type, set the TYPE_MAIN_VARIANT for this type to be the
9252      unqualified type.  Since they are actually RECORD_TYPEs that are
9253      not variants of each other, we must do this manually.  */
9254   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9255     {
9256       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9257       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9258       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9259       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9260     }
9261
9262   /* Cache this pointer-to-member type so that we can find it again
9263      later.  */
9264   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9265
9266   /* Seems to be wanted.  */
9267   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9268
9269   return t;
9270 }
9271
9272 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9273    Check to see that the definition is valid.  Issue appropriate error
9274    messages.  Return 1 if the definition is particularly bad, or 0
9275    otherwise.  */
9276
9277 int
9278 check_static_variable_definition (decl, type)
9279      tree decl;
9280      tree type;
9281 {
9282   /* Motion 10 at San Diego: If a static const integral data member is
9283      initialized with an integral constant expression, the initializer
9284      may appear either in the declaration (within the class), or in
9285      the definition, but not both.  If it appears in the class, the
9286      member is a member constant.  The file-scope definition is always
9287      required.  */
9288   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9289     {
9290       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9291                 type);
9292       /* If we just return the declaration, crashes will sometimes
9293          occur.  We therefore return void_type_node, as if this was a
9294          friend declaration, to cause callers to completely ignore
9295          this declaration.  */
9296       return 1;
9297     }
9298   else if (!CP_TYPE_CONST_P (type))
9299     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9300               decl);
9301   else if (pedantic && !INTEGRAL_TYPE_P (type))
9302     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9303
9304   return 0;
9305 }
9306
9307 /* Given the SIZE (i.e., number of elements) in an array, compute an
9308    appropriate index type for the array.  If non-NULL, NAME is the
9309    name of the thing being declared.  */
9310
9311 tree
9312 compute_array_index_type (name, size)
9313      tree name;
9314      tree size;
9315 {
9316   tree itype;
9317
9318   /* The size might be the result of a cast. */
9319   STRIP_TYPE_NOPS (size);
9320
9321   /* It might be a const variable or enumeration constant.  */
9322   size = decl_constant_value (size);
9323
9324   /* If this involves a template parameter, it will be a constant at
9325      instantiation time, but we don't know what the value is yet.
9326      Even if no template parameters are involved, we may an expression
9327      that is not a constant; we don't even simplify `1 + 2' when
9328      processing a template.  */
9329   if (processing_template_decl)
9330     {
9331       /* Resolve a qualified reference to an enumerator or static
9332          const data member of ours.  */
9333       if (TREE_CODE (size) == SCOPE_REF
9334           && TREE_OPERAND (size, 0) == current_class_type)
9335         {
9336           tree t = lookup_field (current_class_type,
9337                                  TREE_OPERAND (size, 1), 0, 0);
9338           if (t)
9339             size = t;
9340         }
9341
9342       return build_index_type (build_min (MINUS_EXPR, sizetype,
9343                                           size, integer_one_node));
9344     }
9345
9346   /* The array bound must be an integer type.  */
9347   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9348       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9349       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9350     {
9351       if (name)
9352         cp_error ("size of array `%D' has non-integer type", name);
9353       else
9354         cp_error ("size of array has non-integer type");
9355       size = integer_one_node;
9356     }
9357
9358   /* Normally, the array-bound will be a constant.  */
9359   if (TREE_CODE (size) == INTEGER_CST)
9360     {
9361       /* Check to see if the array bound overflowed.  Make that an
9362          error, no matter how generous we're being.  */
9363       int old_flag_pedantic_errors = flag_pedantic_errors;
9364       int old_pedantic = pedantic;
9365       pedantic = flag_pedantic_errors = 1;
9366       constant_expression_warning (size);
9367       pedantic = old_pedantic;
9368       flag_pedantic_errors = old_flag_pedantic_errors;
9369
9370       /* An array must have a positive number of elements.  */
9371       if (INT_CST_LT (size, integer_zero_node))
9372         {
9373           if (name)
9374             cp_error ("size of array `%D' is negative", name);
9375           else
9376             cp_error ("size of array is negative");
9377           size = integer_one_node;
9378         }
9379       /* Except that an extension we allow zero-sized arrays.  We
9380          always allow them in system headers because glibc uses
9381          them.  */
9382       else if (integer_zerop (size) && pedantic && !in_system_header)
9383         {
9384           if (name)
9385             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9386           else
9387             cp_pedwarn ("ISO C++ forbids zero-size array");
9388         }
9389     }
9390   else if (TREE_CONSTANT (size))
9391     {
9392       /* `(int) &fn' is not a valid array bound.  */
9393       if (name)
9394         cp_error ("size of array `%D' is not an integral constant-expression",
9395                   name);
9396       else
9397         cp_error ("size of array is not an integral constant-expression");
9398     }
9399
9400   /* Compute the index of the largest element in the array.  It is
9401      one less than the number of elements in the array.  */
9402   itype
9403     = fold (cp_build_binary_op (MINUS_EXPR,
9404                                 cp_convert (ssizetype, size),
9405                                 cp_convert (ssizetype,
9406                                             integer_one_node)));
9407
9408   /* Check for variable-sized arrays.  We allow such things as an
9409      extension, even though they are not allowed in ANSI/ISO C++.  */
9410   if (!TREE_CONSTANT (itype))
9411     {
9412       if (pedantic)
9413         {
9414           if (name)
9415             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9416                         name);
9417           else
9418             cp_pedwarn ("ISO C++ forbids variable-size array");
9419         }
9420
9421       /* Create a variable-sized array index type.  */
9422       itype = variable_size (itype);
9423     }
9424   /* Make sure that there was no overflow when creating to a signed
9425      index type.  (For example, on a 32-bit machine, an array with
9426      size 2^32 - 1 is too big.)  */
9427   else if (TREE_OVERFLOW (itype))
9428     {
9429       error ("overflow in array dimension");
9430       TREE_OVERFLOW (itype) = 0;
9431     }
9432
9433   /* Create and return the appropriate index type.  */
9434   return build_index_type (itype);
9435 }
9436
9437 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9438    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9439    with this type.  */
9440
9441 static tree
9442 create_array_type_for_decl (name, type, size)
9443      tree name;
9444      tree type;
9445      tree size;
9446 {
9447   tree itype = NULL_TREE;
9448   const char* error_msg;
9449
9450   /* If things have already gone awry, bail now.  */
9451   if (type == error_mark_node || size == error_mark_node)
9452     return error_mark_node;
9453
9454   /* Assume that everything will go OK.  */
9455   error_msg = NULL;
9456
9457   /* There are some types which cannot be array elements.  */
9458   switch (TREE_CODE (type))
9459     {
9460     case VOID_TYPE:
9461       error_msg = "array of void";
9462       break;
9463
9464     case FUNCTION_TYPE:
9465       error_msg = "array of functions";
9466       break;
9467
9468     case REFERENCE_TYPE:
9469       error_msg = "array of references";
9470       break;
9471
9472     case OFFSET_TYPE:
9473       error_msg = "array of data members";
9474       break;
9475
9476     case METHOD_TYPE:
9477       error_msg = "array of function members";
9478       break;
9479
9480     default:
9481       break;
9482     }
9483
9484   /* If something went wrong, issue an error-message and return.  */
9485   if (error_msg)
9486     {
9487       if (name)
9488         cp_error ("declaration of `%D' as %s", name, error_msg);
9489       else
9490         cp_error ("creating %s", error_msg);
9491
9492       return error_mark_node;
9493     }
9494
9495   /* [dcl.array]
9496
9497      The constant expressions that specify the bounds of the arrays
9498      can be omitted only for the first member of the sequence.  */
9499   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9500     {
9501       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9502                 name);
9503
9504       return error_mark_node;
9505     }
9506
9507   /* Figure out the index type for the array.  */
9508   if (size)
9509     itype = compute_array_index_type (name, size);
9510
9511   return build_cplus_array_type (type, itype);
9512 }
9513
9514 /* Check that it's OK to declare a function with the indicated TYPE.
9515    SFK indicates the kind of special function (if any) that this
9516    function is.  CTYPE is the class of which this function is a
9517    member.  OPTYPE is the type given in a conversion operator
9518    declaration.  Returns the actual return type of the function; that
9519    may be different than TYPE if an error occurs, or for certain
9520    special functions.  */
9521
9522 static tree
9523 check_special_function_return_type (sfk, type, ctype, optype)
9524      special_function_kind sfk;
9525      tree type;
9526      tree ctype;
9527      tree optype;
9528 {
9529   switch (sfk)
9530     {
9531     case sfk_constructor:
9532       if (type)
9533         cp_error ("return type specification for constructor invalid");
9534
9535       /* In the old ABI, we return `this'; in the new ABI we don't
9536          bother.  */
9537       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9538       break;
9539
9540     case sfk_destructor:
9541       if (type)
9542         cp_error ("return type specification for destructor invalid");
9543       type = void_type_node;
9544       break;
9545
9546     case sfk_conversion:
9547       if (type && !same_type_p (type, optype))
9548         cp_error ("operator `%T' declared to return `%T'", optype, type);
9549       else if (type)
9550         cp_pedwarn ("return type specified for `operator %T'",  optype);
9551       type = optype;
9552       break;
9553
9554     default:
9555       my_friendly_abort (20000408);
9556       break;
9557     }
9558
9559   return type;
9560 }
9561
9562 /* Given declspecs and a declarator,
9563    determine the name and type of the object declared
9564    and construct a ..._DECL node for it.
9565    (In one case we can return a ..._TYPE node instead.
9566     For invalid input we sometimes return 0.)
9567
9568    DECLSPECS is a chain of tree_list nodes whose value fields
9569     are the storage classes and type specifiers.
9570
9571    DECL_CONTEXT says which syntactic context this declaration is in:
9572      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9573      FUNCDEF for a function definition.  Like NORMAL but a few different
9574       error messages in each case.  Return value may be zero meaning
9575       this definition is too screwy to try to parse.
9576      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9577       handle member functions (which have FIELD context).
9578       Return value may be zero meaning this definition is too screwy to
9579       try to parse.
9580      PARM for a parameter declaration (either within a function prototype
9581       or before a function body).  Make a PARM_DECL, or return void_type_node.
9582      CATCHPARM for a parameter declaration before a catch clause.
9583      TYPENAME if for a typename (in a cast or sizeof).
9584       Don't make a DECL node; just return the ..._TYPE node.
9585      FIELD for a struct or union field; make a FIELD_DECL.
9586      BITFIELD for a field with specified width.
9587    INITIALIZED is 1 if the decl has an initializer.
9588
9589    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9590    normal attributes in TREE_PURPOSE, or NULL_TREE.
9591
9592    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9593    It may also be so in the PARM case, for a prototype where the
9594    argument type is specified but not the name.
9595
9596    This function is where the complicated C meanings of `static'
9597    and `extern' are interpreted.
9598
9599    For C++, if there is any monkey business to do, the function which
9600    calls this one must do it, i.e., prepending instance variables,
9601    renaming overloaded function names, etc.
9602
9603    Note that for this C++, it is an error to define a method within a class
9604    which does not belong to that class.
9605
9606    Except in the case where SCOPE_REFs are implicitly known (such as
9607    methods within a class being redundantly qualified),
9608    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9609    (class_name::decl_name).  The caller must also deal with this.
9610
9611    If a constructor or destructor is seen, and the context is FIELD,
9612    then the type gains the attribute TREE_HAS_x.  If such a declaration
9613    is erroneous, NULL_TREE is returned.
9614
9615    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9616    function, these are the qualifiers to give to the `this' pointer. We
9617    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9618
9619    May return void_type_node if the declarator turned out to be a friend.
9620    See grokfield for details.  */
9621
9622 tree
9623 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9624      tree declspecs;
9625      tree declarator;
9626      enum decl_context decl_context;
9627      int initialized;
9628      tree attrlist;
9629 {
9630   RID_BIT_TYPE specbits;
9631   int nclasses = 0;
9632   tree spec;
9633   tree type = NULL_TREE;
9634   int longlong = 0;
9635   int constp;
9636   int restrictp;
9637   int volatilep;
9638   int type_quals;
9639   int virtualp, explicitp, friendp, inlinep, staticp;
9640   int explicit_int = 0;
9641   int explicit_char = 0;
9642   int defaulted_int = 0;
9643   tree typedef_decl = NULL_TREE;
9644   const char *name;
9645   tree typedef_type = NULL_TREE;
9646   int funcdef_flag = 0;
9647   enum tree_code innermost_code = ERROR_MARK;
9648   int bitfield = 0;
9649 #if 0
9650   /* See the code below that used this.  */
9651   tree decl_machine_attr = NULL_TREE;
9652 #endif
9653   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9654      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9655   tree init = NULL_TREE;
9656
9657   /* Keep track of what sort of function is being processed
9658      so that we can warn about default return values, or explicit
9659      return values which do not match prescribed defaults.  */
9660   special_function_kind sfk = sfk_none;
9661
9662   tree dname = NULL_TREE;
9663   tree ctype = current_class_type;
9664   tree ctor_return_type = NULL_TREE;
9665   enum overload_flags flags = NO_SPECIAL;
9666   tree quals = NULL_TREE;
9667   tree raises = NULL_TREE;
9668   int template_count = 0;
9669   tree in_namespace = NULL_TREE;
9670   tree inner_attrs;
9671   int ignore_attrs;
9672
9673   RIDBIT_RESET_ALL (specbits);
9674   if (decl_context == FUNCDEF)
9675     funcdef_flag = 1, decl_context = NORMAL;
9676   else if (decl_context == MEMFUNCDEF)
9677     funcdef_flag = -1, decl_context = FIELD;
9678   else if (decl_context == BITFIELD)
9679     bitfield = 1, decl_context = FIELD;
9680
9681   /* Look inside a declarator for the name being declared
9682      and get it as a string, for an error message.  */
9683   {
9684     tree *next = &declarator;
9685     register tree decl;
9686     name = NULL;
9687
9688     while (next && *next)
9689       {
9690         decl = *next;
9691         switch (TREE_CODE (decl))
9692           {
9693           case TREE_LIST:
9694             /* For attributes.  */
9695             next = &TREE_VALUE (decl);
9696             break;
9697
9698           case COND_EXPR:
9699             ctype = NULL_TREE;
9700             next = &TREE_OPERAND (decl, 0);
9701             break;
9702
9703           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9704             {
9705               tree name = TREE_OPERAND (decl, 0);
9706               tree rename = NULL_TREE;
9707
9708               my_friendly_assert (flags == NO_SPECIAL, 152);
9709               flags = DTOR_FLAG;
9710               sfk = sfk_destructor;
9711               if (TREE_CODE (name) == TYPE_DECL)
9712                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9713               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9714               if (ctype == NULL_TREE)
9715                 {
9716                   if (current_class_type == NULL_TREE)
9717                     {
9718                       error ("destructors must be member functions");
9719                       flags = NO_SPECIAL;
9720                     }
9721                   else
9722                     {
9723                       tree t = constructor_name (current_class_name);
9724                       if (t != name)
9725                         rename = t;
9726                     }
9727                 }
9728               else
9729                 {
9730                   tree t = constructor_name (ctype);
9731                   if (t != name)
9732                     rename = t;
9733                 }
9734
9735               if (rename)
9736                 {
9737                   cp_error ("destructor `%T' must match class name `%T'",
9738                             name, rename);
9739                   TREE_OPERAND (decl, 0) = rename;
9740                 }
9741               next = &name;
9742             }
9743             break;
9744
9745           case ADDR_EXPR:       /* C++ reference declaration */
9746             /* Fall through. */
9747           case ARRAY_REF:
9748           case INDIRECT_REF:
9749             ctype = NULL_TREE;
9750             innermost_code = TREE_CODE (decl);
9751             next = &TREE_OPERAND (decl, 0);
9752             break;
9753
9754           case CALL_EXPR:
9755             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9756               {
9757                 /* This is actually a variable declaration using
9758                    constructor syntax.  We need to call start_decl and
9759                    cp_finish_decl so we can get the variable
9760                    initialized...  */
9761
9762                 tree attributes, prefix_attributes;
9763
9764                 *next = TREE_OPERAND (decl, 0);
9765                 init = CALL_DECLARATOR_PARMS (decl);
9766
9767                 if (attrlist)
9768                   {
9769                     attributes = TREE_PURPOSE (attrlist);
9770                     prefix_attributes = TREE_VALUE (attrlist);
9771                   }
9772                 else
9773                   {
9774                     attributes = NULL_TREE;
9775                     prefix_attributes = NULL_TREE;
9776                   }
9777
9778                 decl = start_decl (declarator, declspecs, 1,
9779                                    attributes, prefix_attributes);
9780                 decl_type_access_control (decl);
9781                 if (decl)
9782                   {
9783                     /* Look for __unused__ attribute */
9784                     if (TREE_USED (TREE_TYPE (decl)))
9785                       TREE_USED (decl) = 1;
9786                     finish_decl (decl, init, NULL_TREE);
9787                   }
9788                 else
9789                   cp_error ("invalid declarator");
9790                 return 0;
9791               }
9792             innermost_code = TREE_CODE (decl);
9793             if (decl_context == FIELD && ctype == NULL_TREE)
9794               ctype = current_class_type;
9795             if (ctype
9796                 && TREE_OPERAND (decl, 0)
9797                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9798                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9799                          == constructor_name_full (ctype))
9800                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9801                             == constructor_name (ctype)))))
9802               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9803             next = &TREE_OPERAND (decl, 0);
9804             decl = *next;
9805             if (ctype != NULL_TREE
9806                 && decl != NULL_TREE && flags != DTOR_FLAG
9807                 && decl == constructor_name (ctype))
9808               {
9809                 sfk = sfk_constructor;
9810                 ctor_return_type = ctype;
9811               }
9812             ctype = NULL_TREE;
9813             break;
9814
9815           case TEMPLATE_ID_EXPR:
9816               {
9817                 tree fns = TREE_OPERAND (decl, 0);
9818
9819                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9820                   fns = TREE_OPERAND (fns, 0);
9821
9822                 dname = fns;
9823                 if (TREE_CODE (dname) == COMPONENT_REF)
9824                   dname = TREE_OPERAND (dname, 1);
9825                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9826                   {
9827                     my_friendly_assert (is_overloaded_fn (dname),
9828                                         19990331);
9829                     dname = DECL_NAME (get_first_fn (dname));
9830                   }
9831               }
9832           /* Fall through. */
9833
9834           case IDENTIFIER_NODE:
9835             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9836               dname = decl;
9837
9838             next = 0;
9839
9840             if (C_IS_RESERVED_WORD (dname))
9841               {
9842                 cp_error ("declarator-id missing; using reserved word `%D'",
9843                           dname);
9844                 name = IDENTIFIER_POINTER (dname);
9845               }
9846             else if (!IDENTIFIER_TYPENAME_P (dname))
9847               name = IDENTIFIER_POINTER (dname);
9848             else
9849               {
9850                 my_friendly_assert (flags == NO_SPECIAL, 154);
9851                 flags = TYPENAME_FLAG;
9852                 ctor_return_type = TREE_TYPE (dname);
9853                 sfk = sfk_conversion;
9854                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9855                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9856                         == TYPE_DECL))
9857                   name = IDENTIFIER_POINTER (dname);
9858                 else
9859                   name = "<invalid operator>";
9860               }
9861             break;
9862
9863             /* C++ extension */
9864           case SCOPE_REF:
9865             {
9866               /* Perform error checking, and decide on a ctype.  */
9867               tree cname = TREE_OPERAND (decl, 0);
9868               if (cname == NULL_TREE)
9869                 ctype = NULL_TREE;
9870               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9871                 {
9872                   ctype = NULL_TREE;
9873                   in_namespace = TREE_OPERAND (decl, 0);
9874                   TREE_OPERAND (decl, 0) = NULL_TREE;
9875                 }
9876               else if (! is_aggr_type (cname, 1))
9877                 TREE_OPERAND (decl, 0) = NULL_TREE;
9878               /* Must test TREE_OPERAND (decl, 1), in case user gives
9879                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9880               else if (TREE_OPERAND (decl, 1)
9881                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9882                 ctype = cname;
9883               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9884                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9885                 {
9886                   cp_error ("`%T::%D' is not a valid declarator", cname,
9887                             TREE_OPERAND (decl, 1));
9888                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9889                             cname, TREE_OPERAND (decl, 1));
9890                   return void_type_node;
9891                 }
9892               else if (ctype == NULL_TREE)
9893                 ctype = cname;
9894               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9895                 TREE_OPERAND (decl, 0) = ctype;
9896               else
9897                 {
9898                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9899                     {
9900                       cp_error ("type `%T' is not derived from type `%T'",
9901                                 cname, ctype);
9902                       TREE_OPERAND (decl, 0) = NULL_TREE;
9903                     }
9904                   else
9905                     ctype = cname;
9906                 }
9907
9908               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9909                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9910                        == constructor_name_full (ctype))
9911                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9912                           == constructor_name (ctype))))
9913                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9914               next = &TREE_OPERAND (decl, 1);
9915               decl = *next;
9916               if (ctype)
9917                 {
9918                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9919                       && constructor_name (ctype) == decl)
9920                     {
9921                       sfk = sfk_constructor;
9922                       ctor_return_type = ctype;
9923                     }
9924                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9925                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9926                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9927                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9928                     {
9929                       sfk = sfk_destructor;
9930                       ctor_return_type = ctype;
9931                       flags = DTOR_FLAG;
9932                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9933                       next = &TREE_OPERAND (decl, 0);
9934                     }
9935                 }
9936             }
9937             break;
9938
9939           case ERROR_MARK:
9940             next = 0;
9941             break;
9942
9943           case TYPE_DECL:
9944             /* Parse error puts this typespec where
9945                a declarator should go.  */
9946             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9947             if (TREE_TYPE (decl) == current_class_type)
9948               cp_error ("  perhaps you want `%T' for a constructor",
9949                         current_class_name);
9950             dname = DECL_NAME (decl);
9951             name = IDENTIFIER_POINTER (dname);
9952
9953             /* Avoid giving two errors for this.  */
9954             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9955
9956             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9957             *next = dname;
9958             next = 0;
9959             break;
9960
9961           default:
9962             cp_compiler_error ("`%D' as declarator", decl);
9963             return 0; /* We used to do a 155 abort here.  */
9964           }
9965       }
9966   }
9967
9968   /* A function definition's declarator must have the form of
9969      a function declarator.  */
9970
9971   if (funcdef_flag && innermost_code != CALL_EXPR)
9972     return 0;
9973
9974   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9975       && innermost_code != CALL_EXPR
9976       && ! (ctype && declspecs == NULL_TREE))
9977     {
9978       cp_error ("declaration of `%D' as non-function", dname);
9979       return void_type_node;
9980     }
9981
9982   /* Anything declared one level down from the top level
9983      must be one of the parameters of a function
9984      (because the body is at least two levels down).  */
9985
9986   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9987      by not allowing C++ class definitions to specify their parameters
9988      with xdecls (must be spec.d in the parmlist).
9989
9990      Since we now wait to push a class scope until we are sure that
9991      we are in a legitimate method context, we must set oldcname
9992      explicitly (since current_class_name is not yet alive).
9993
9994      We also want to avoid calling this a PARM if it is in a namespace.  */
9995
9996   if (decl_context == NORMAL && !toplevel_bindings_p ())
9997     {
9998       struct binding_level *b = current_binding_level;
9999       current_binding_level = b->level_chain;
10000       if (current_binding_level != 0 && toplevel_bindings_p ())
10001         decl_context = PARM;
10002       current_binding_level = b;
10003     }
10004
10005   if (name == NULL)
10006     name = decl_context == PARM ? "parameter" : "type name";
10007
10008   /* Look through the decl specs and record which ones appear.
10009      Some typespecs are defined as built-in typenames.
10010      Others, the ones that are modifiers of other types,
10011      are represented by bits in SPECBITS: set the bits for
10012      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10013
10014      If there is a typedef name or a type, store the type in TYPE.
10015      This includes builtin typedefs such as `int'.
10016
10017      Set EXPLICIT_INT if the type is `int' or `char' and did not
10018      come from a user typedef.
10019
10020      Set LONGLONG if `long' is mentioned twice.
10021
10022      For C++, constructors and destructors have their own fast treatment.  */
10023
10024   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10025     {
10026       register int i;
10027       register tree id;
10028
10029       /* Certain parse errors slip through.  For example,
10030          `int class;' is not caught by the parser. Try
10031          weakly to recover here.  */
10032       if (TREE_CODE (spec) != TREE_LIST)
10033         return 0;
10034
10035       id = TREE_VALUE (spec);
10036
10037       if (TREE_CODE (id) == IDENTIFIER_NODE)
10038         {
10039           if (id == ridpointers[(int) RID_INT]
10040               || id == ridpointers[(int) RID_CHAR]
10041               || id == ridpointers[(int) RID_BOOL]
10042               || id == ridpointers[(int) RID_WCHAR])
10043             {
10044               if (type)
10045                 {
10046                   if (id == ridpointers[(int) RID_BOOL])
10047                     error ("`bool' is now a keyword");
10048                   else
10049                     cp_error ("extraneous `%T' ignored", id);
10050                 }
10051               else
10052                 {
10053                   if (id == ridpointers[(int) RID_INT])
10054                     explicit_int = 1;
10055                   else if (id == ridpointers[(int) RID_CHAR])
10056                     explicit_char = 1;
10057                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10058                 }
10059               goto found;
10060             }
10061           /* C++ aggregate types.  */
10062           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10063             {
10064               if (type)
10065                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10066               else
10067                 type = IDENTIFIER_TYPE_VALUE (id);
10068               goto found;
10069             }
10070
10071           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10072             {
10073               if (ridpointers[i] == id)
10074                 {
10075                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10076                     {
10077                       if (pedantic && ! in_system_header && warn_long_long)
10078                         pedwarn ("ISO C++ does not support `long long'");
10079                       if (longlong)
10080                         error ("`long long long' is too long for GCC");
10081                       else
10082                         longlong = 1;
10083                     }
10084                   else if (RIDBIT_SETP (i, specbits))
10085                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10086                   RIDBIT_SET (i, specbits);
10087                   goto found;
10088                 }
10089             }
10090         }
10091       /* C++ aggregate types.  */
10092       else if (TREE_CODE (id) == TYPE_DECL)
10093         {
10094           if (type)
10095             cp_error ("multiple declarations `%T' and `%T'", type,
10096                       TREE_TYPE (id));
10097           else
10098             {
10099               type = TREE_TYPE (id);
10100               TREE_VALUE (spec) = type;
10101             }
10102           goto found;
10103         }
10104       if (type)
10105         error ("two or more data types in declaration of `%s'", name);
10106       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10107         {
10108           register tree t = lookup_name (id, 1);
10109           if (!t || TREE_CODE (t) != TYPE_DECL)
10110             error ("`%s' fails to be a typedef or built in type",
10111                    IDENTIFIER_POINTER (id));
10112           else
10113             {
10114               type = TREE_TYPE (t);
10115 #if 0
10116               /* See the code below that used this.  */
10117               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10118 #endif
10119               typedef_decl = t;
10120             }
10121         }
10122       else if (id != error_mark_node)
10123         /* Can't change CLASS nodes into RECORD nodes here!  */
10124         type = id;
10125
10126     found: ;
10127     }
10128
10129   typedef_type = type;
10130
10131   /* No type at all: default to `int', and set DEFAULTED_INT
10132      because it was not a user-defined typedef.  */
10133
10134   if (type == NULL_TREE
10135       && (RIDBIT_SETP (RID_SIGNED, specbits)
10136           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10137           || RIDBIT_SETP (RID_LONG, specbits)
10138           || RIDBIT_SETP (RID_SHORT, specbits)))
10139     {
10140       /* These imply 'int'.  */
10141       type = integer_type_node;
10142       defaulted_int = 1;
10143     }
10144
10145   if (sfk != sfk_none)
10146     type = check_special_function_return_type (sfk, type,
10147                                                ctor_return_type,
10148                                                ctor_return_type);
10149   else if (type == NULL_TREE)
10150     {
10151       int is_main;
10152
10153       explicit_int = -1;
10154
10155           /* We handle `main' specially here, because 'main () { }' is so
10156              common.  With no options, it is allowed.  With -Wreturn-type,
10157              it is a warning.  It is only an error with -pedantic-errors.  */
10158       is_main = (funcdef_flag
10159                  && MAIN_NAME_P (dname)
10160                  && ctype == NULL_TREE
10161                  && in_namespace == NULL_TREE
10162                  && current_namespace == global_namespace);
10163
10164       if (in_system_header || flag_ms_extensions)
10165         /* Allow it, sigh.  */;
10166       else if (pedantic || ! is_main)
10167         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10168                     name);
10169       else if (warn_return_type)
10170         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10171                     name);
10172
10173       type = integer_type_node;
10174     }
10175
10176   ctype = NULL_TREE;
10177
10178   /* Now process the modifiers that were specified
10179      and check for invalid combinations.  */
10180
10181   /* Long double is a special combination.  */
10182
10183   if (RIDBIT_SETP (RID_LONG, specbits)
10184       && TYPE_MAIN_VARIANT (type) == double_type_node)
10185     {
10186       RIDBIT_RESET (RID_LONG, specbits);
10187       type = build_qualified_type (long_double_type_node,
10188                                    CP_TYPE_QUALS (type));
10189     }
10190
10191   /* Check all other uses of type modifiers.  */
10192
10193   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10194       || RIDBIT_SETP (RID_SIGNED, specbits)
10195       || RIDBIT_SETP (RID_LONG, specbits)
10196       || RIDBIT_SETP (RID_SHORT, specbits))
10197     {
10198       int ok = 0;
10199
10200       if (TREE_CODE (type) == REAL_TYPE)
10201         error ("short, signed or unsigned invalid for `%s'", name);
10202       else if (TREE_CODE (type) != INTEGER_TYPE)
10203         error ("long, short, signed or unsigned invalid for `%s'", name);
10204       else if (RIDBIT_SETP (RID_LONG, specbits)
10205                && RIDBIT_SETP (RID_SHORT, specbits))
10206         error ("long and short specified together for `%s'", name);
10207       else if ((RIDBIT_SETP (RID_LONG, specbits)
10208                 || RIDBIT_SETP (RID_SHORT, specbits))
10209                && explicit_char)
10210         error ("long or short specified with char for `%s'", name);
10211       else if ((RIDBIT_SETP (RID_LONG, specbits)
10212                 || RIDBIT_SETP (RID_SHORT, specbits))
10213                && TREE_CODE (type) == REAL_TYPE)
10214         error ("long or short specified with floating type for `%s'", name);
10215       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10216                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10217         error ("signed and unsigned given together for `%s'", name);
10218       else
10219         {
10220           ok = 1;
10221           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10222             {
10223               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10224                        name);
10225               if (flag_pedantic_errors)
10226                 ok = 0;
10227             }
10228         }
10229
10230       /* Discard the type modifiers if they are invalid.  */
10231       if (! ok)
10232         {
10233           RIDBIT_RESET (RID_UNSIGNED, specbits);
10234           RIDBIT_RESET (RID_SIGNED, specbits);
10235           RIDBIT_RESET (RID_LONG, specbits);
10236           RIDBIT_RESET (RID_SHORT, specbits);
10237           longlong = 0;
10238         }
10239     }
10240
10241   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10242       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10243     {
10244       error ("complex invalid for `%s'", name);
10245       RIDBIT_RESET (RID_COMPLEX, specbits);
10246     }
10247
10248   /* Decide whether an integer type is signed or not.
10249      Optionally treat bitfields as signed by default.  */
10250   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10251       /* [class.bit]
10252
10253          It is implementation-defined whether a plain (neither
10254          explicitly signed or unsigned) char, short, int, or long
10255          bit-field is signed or unsigned.
10256
10257          Naturally, we extend this to long long as well.  Note that
10258          this does not include wchar_t.  */
10259       || (bitfield && !flag_signed_bitfields
10260           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10261           /* A typedef for plain `int' without `signed' can be
10262              controlled just like plain `int', but a typedef for
10263              `signed int' cannot be so controlled.  */
10264           && !(typedef_decl
10265                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10266           && (TREE_CODE (type) == INTEGER_TYPE
10267               || TREE_CODE (type) == CHAR_TYPE)
10268           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10269     {
10270       if (longlong)
10271         type = long_long_unsigned_type_node;
10272       else if (RIDBIT_SETP (RID_LONG, specbits))
10273         type = long_unsigned_type_node;
10274       else if (RIDBIT_SETP (RID_SHORT, specbits))
10275         type = short_unsigned_type_node;
10276       else if (type == char_type_node)
10277         type = unsigned_char_type_node;
10278       else if (typedef_decl)
10279         type = unsigned_type (type);
10280       else
10281         type = unsigned_type_node;
10282     }
10283   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10284            && type == char_type_node)
10285     type = signed_char_type_node;
10286   else if (longlong)
10287     type = long_long_integer_type_node;
10288   else if (RIDBIT_SETP (RID_LONG, specbits))
10289     type = long_integer_type_node;
10290   else if (RIDBIT_SETP (RID_SHORT, specbits))
10291     type = short_integer_type_node;
10292
10293   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10294     {
10295       /* If we just have "complex", it is equivalent to
10296          "complex double", but if any modifiers at all are specified it is
10297          the complex form of TYPE.  E.g, "complex short" is
10298          "complex short int".  */
10299
10300       if (defaulted_int && ! longlong
10301           && ! (RIDBIT_SETP (RID_LONG, specbits)
10302                 || RIDBIT_SETP (RID_SHORT, specbits)
10303                 || RIDBIT_SETP (RID_SIGNED, specbits)
10304                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10305         type = complex_double_type_node;
10306       else if (type == integer_type_node)
10307         type = complex_integer_type_node;
10308       else if (type == float_type_node)
10309         type = complex_float_type_node;
10310       else if (type == double_type_node)
10311         type = complex_double_type_node;
10312       else if (type == long_double_type_node)
10313         type = complex_long_double_type_node;
10314       else
10315         type = build_complex_type (type);
10316     }
10317
10318   if (sfk == sfk_conversion
10319       && (RIDBIT_SETP (RID_CONST, specbits)
10320           || RIDBIT_SETP (RID_VOLATILE, specbits)
10321           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10322     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10323               ctor_return_type);
10324
10325   /* Set CONSTP if this declaration is `const', whether by
10326      explicit specification or via a typedef.
10327      Likewise for VOLATILEP.  */
10328
10329   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10330   restrictp =
10331     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10332   volatilep =
10333     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10334   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10335                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10336                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10337   type = cp_build_qualified_type (type, type_quals);
10338   staticp = 0;
10339   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10340   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10341   RIDBIT_RESET (RID_VIRTUAL, specbits);
10342   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10343   RIDBIT_RESET (RID_EXPLICIT, specbits);
10344
10345   if (RIDBIT_SETP (RID_STATIC, specbits))
10346     staticp = 1 + (decl_context == FIELD);
10347
10348   if (virtualp && staticp == 2)
10349     {
10350       cp_error ("member `%D' cannot be declared both virtual and static",
10351                 dname);
10352       staticp = 0;
10353     }
10354   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10355   RIDBIT_RESET (RID_FRIEND, specbits);
10356
10357   /* Warn if two storage classes are given. Default to `auto'.  */
10358
10359   if (RIDBIT_ANY_SET (specbits))
10360     {
10361       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10362       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10363       if (decl_context == PARM && nclasses > 0)
10364         error ("storage class specifiers invalid in parameter declarations");
10365       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10366         {
10367           if (decl_context == PARM)
10368             error ("typedef declaration invalid in parameter declaration");
10369           nclasses++;
10370         }
10371       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10372       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10373     }
10374
10375   /* Give error if `virtual' is used outside of class declaration.  */
10376   if (virtualp
10377       && (current_class_name == NULL_TREE || decl_context != FIELD))
10378     {
10379       error ("virtual outside class declaration");
10380       virtualp = 0;
10381     }
10382
10383   /* Static anonymous unions are dealt with here.  */
10384   if (staticp && decl_context == TYPENAME
10385       && TREE_CODE (declspecs) == TREE_LIST
10386       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10387     decl_context = FIELD;
10388
10389   /* Warn about storage classes that are invalid for certain
10390      kinds of declarations (parameters, typenames, etc.).  */
10391
10392   if (nclasses > 1)
10393     error ("multiple storage classes in declaration of `%s'", name);
10394   else if (decl_context != NORMAL && nclasses > 0)
10395     {
10396       if ((decl_context == PARM || decl_context == CATCHPARM)
10397           && (RIDBIT_SETP (RID_REGISTER, specbits)
10398               || RIDBIT_SETP (RID_AUTO, specbits)))
10399         ;
10400       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10401         ;
10402       else if (decl_context == FIELD
10403                /* C++ allows static class elements  */
10404                && RIDBIT_SETP (RID_STATIC, specbits))
10405         /* C++ also allows inlines and signed and unsigned elements,
10406            but in those cases we don't come in here.  */
10407         ;
10408       else
10409         {
10410           if (decl_context == FIELD)
10411             {
10412               tree tmp = NULL_TREE;
10413               register int op = 0;
10414
10415               if (declarator)
10416                 {
10417                   /* Avoid trying to get an operand off an identifier node.  */
10418                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10419                     tmp = declarator;
10420                   else
10421                     tmp = TREE_OPERAND (declarator, 0);
10422                   op = IDENTIFIER_OPNAME_P (tmp);
10423                   if (IDENTIFIER_TYPENAME_P (tmp))
10424                     {
10425                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10426                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10427                               == TYPE_DECL))
10428                         name = IDENTIFIER_POINTER (tmp);
10429                       else
10430                         name = "<invalid operator>";
10431                     }
10432                 }
10433               error ("storage class specified for %s `%s'",
10434                      op ? "member operator" : "field",
10435                      name);
10436             }
10437           else
10438             {
10439               if (decl_context == PARM || decl_context == CATCHPARM)
10440                 error ("storage class specified for parameter `%s'", name);
10441               else
10442                 error ("storage class specified for typename");
10443             }
10444           RIDBIT_RESET (RID_REGISTER, specbits);
10445           RIDBIT_RESET (RID_AUTO, specbits);
10446           RIDBIT_RESET (RID_EXTERN, specbits);
10447         }
10448     }
10449   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10450     {
10451       if (toplevel_bindings_p ())
10452         {
10453           /* It's common practice (and completely valid) to have a const
10454              be initialized and declared extern.  */
10455           if (!(type_quals & TYPE_QUAL_CONST))
10456             warning ("`%s' initialized and declared `extern'", name);
10457         }
10458       else
10459         error ("`%s' has both `extern' and initializer", name);
10460     }
10461   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10462            && ! toplevel_bindings_p ())
10463     error ("nested function `%s' declared `extern'", name);
10464   else if (toplevel_bindings_p ())
10465     {
10466       if (RIDBIT_SETP (RID_AUTO, specbits))
10467         error ("top-level declaration of `%s' specifies `auto'", name);
10468     }
10469
10470   if (nclasses > 0 && friendp)
10471     error ("storage class specifiers invalid in friend function declarations");
10472
10473   /* Now figure out the structure of the declarator proper.
10474      Descend through it, creating more complex types, until we reach
10475      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10476
10477   inner_attrs = NULL_TREE;
10478   ignore_attrs = 0;
10479
10480   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10481          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10482     {
10483       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10484          an INDIRECT_REF (for *...),
10485          a CALL_EXPR (for ...(...)),
10486          an identifier (for the name being declared)
10487          or a null pointer (for the place in an absolute declarator
10488          where the name was omitted).
10489          For the last two cases, we have just exited the loop.
10490
10491          For C++ it could also be
10492          a SCOPE_REF (for class :: ...).  In this case, we have converted
10493          sensible names to types, and those are the values we use to
10494          qualify the member name.
10495          an ADDR_EXPR (for &...),
10496          a BIT_NOT_EXPR (for destructors)
10497
10498          At this point, TYPE is the type of elements of an array,
10499          or for a function to return, or for a pointer to point to.
10500          After this sequence of ifs, TYPE is the type of the
10501          array or function or pointer, and DECLARATOR has had its
10502          outermost layer removed.  */
10503
10504       if (type == error_mark_node)
10505         {
10506           if (TREE_CODE (declarator) == SCOPE_REF)
10507             declarator = TREE_OPERAND (declarator, 1);
10508           else
10509             declarator = TREE_OPERAND (declarator, 0);
10510           continue;
10511         }
10512       if (quals != NULL_TREE
10513           && (declarator == NULL_TREE
10514               || TREE_CODE (declarator) != SCOPE_REF))
10515         {
10516           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10517             ctype = TYPE_METHOD_BASETYPE (type);
10518           if (ctype != NULL_TREE)
10519             {
10520               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10521               grok_method_quals (ctype, dummy, quals);
10522               type = TREE_TYPE (dummy);
10523               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10524               quals = NULL_TREE;
10525             }
10526         }
10527
10528       /* See the comment for the TREE_LIST case, below.  */
10529       if (ignore_attrs)
10530         ignore_attrs = 0;
10531       else if (inner_attrs)
10532         {
10533           decl_attributes (type, inner_attrs, NULL_TREE);
10534           inner_attrs = NULL_TREE;
10535         }
10536
10537       switch (TREE_CODE (declarator))
10538         {
10539         case TREE_LIST:
10540           {
10541             /* We encode a declarator with embedded attributes using
10542                a TREE_LIST.  The attributes apply to the declarator
10543                directly inside them, so we have to skip an iteration
10544                before applying them to the type.  If the declarator just
10545                inside is the declarator-id, we apply the attrs to the
10546                decl itself.  */
10547             inner_attrs = TREE_PURPOSE (declarator);
10548             ignore_attrs = 1;
10549             declarator = TREE_VALUE (declarator);
10550           }
10551           break;
10552
10553         case ARRAY_REF:
10554           {
10555             register tree size;
10556
10557             size = TREE_OPERAND (declarator, 1);
10558
10559             /* VC++ spells a zero-sized array with [].  */
10560             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10561                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10562               size = integer_zero_node;
10563
10564             declarator = TREE_OPERAND (declarator, 0);
10565
10566             type = create_array_type_for_decl (dname, type, size);
10567
10568             /* VLAs never work as fields. */
10569             if (decl_context == FIELD && !processing_template_decl
10570                 && TREE_CODE (type) == ARRAY_TYPE
10571                 && TYPE_DOMAIN (type) != NULL_TREE
10572                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10573               {
10574                 cp_error ("size of member `%D' is not constant", dname);
10575                 /* Proceed with arbitrary constant size, so that offset
10576                    computations don't get confused. */
10577                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10578                                                    integer_one_node);
10579               }
10580
10581             ctype = NULL_TREE;
10582           }
10583           break;
10584
10585         case CALL_EXPR:
10586           {
10587             tree arg_types;
10588             int funcdecl_p;
10589             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10590             tree inner_decl = TREE_OPERAND (declarator, 0);
10591
10592             /* Declaring a function type.
10593                Make sure we have a valid type for the function to return.  */
10594
10595             /* We now know that the TYPE_QUALS don't apply to the
10596                decl, but to its return type.  */
10597             type_quals = TYPE_UNQUALIFIED;
10598
10599             /* Warn about some types functions can't return.  */
10600
10601             if (TREE_CODE (type) == FUNCTION_TYPE)
10602               {
10603                 error ("`%s' declared as function returning a function", name);
10604                 type = integer_type_node;
10605               }
10606             if (TREE_CODE (type) == ARRAY_TYPE)
10607               {
10608                 error ("`%s' declared as function returning an array", name);
10609                 type = integer_type_node;
10610               }
10611
10612             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10613               inner_decl = TREE_OPERAND (inner_decl, 1);
10614
10615             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10616               inner_decl = dname;
10617
10618             /* Pick up type qualifiers which should be applied to `this'.  */
10619             quals = CALL_DECLARATOR_QUALS (declarator);
10620
10621             /* Pick up the exception specifications.  */
10622             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10623
10624             /* Say it's a definition only for the CALL_EXPR
10625                closest to the identifier.  */
10626             funcdecl_p
10627               = inner_decl
10628               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10629                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10630                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10631
10632             if (ctype == NULL_TREE
10633                 && decl_context == FIELD
10634                 && funcdecl_p
10635                 && (friendp == 0 || dname == current_class_name))
10636               ctype = current_class_type;
10637
10638             if (ctype && sfk == sfk_conversion)
10639               TYPE_HAS_CONVERSION (ctype) = 1;
10640             if (ctype && constructor_name (ctype) == dname)
10641               {
10642                 /* We are within a class's scope. If our declarator name
10643                    is the same as the class name, and we are defining
10644                    a function, then it is a constructor/destructor, and
10645                    therefore returns a void type.  */
10646
10647                 if (flags == DTOR_FLAG)
10648                   {
10649                     /* ISO C++ 12.4/2.  A destructor may not be
10650                        declared const or volatile.  A destructor may
10651                        not be static.  */
10652                     if (staticp == 2)
10653                       error ("destructor cannot be static member function");
10654                     if (quals)
10655                       {
10656                         cp_error ("destructors may not be `%s'",
10657                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10658                         quals = NULL_TREE;
10659                       }
10660                     if (decl_context == FIELD)
10661                       {
10662                         if (! member_function_or_else (ctype,
10663                                                        current_class_type,
10664                                                        flags))
10665                           return void_type_node;
10666                       }
10667                   }
10668                 else            /* It's a constructor.  */
10669                   {
10670                     if (explicitp == 1)
10671                       explicitp = 2;
10672                     /* ISO C++ 12.1.  A constructor may not be
10673                        declared const or volatile.  A constructor may
10674                        not be virtual.  A constructor may not be
10675                        static.  */
10676                     if (staticp == 2)
10677                       error ("constructor cannot be static member function");
10678                     if (virtualp)
10679                       {
10680                         pedwarn ("constructors cannot be declared virtual");
10681                         virtualp = 0;
10682                       }
10683                     if (quals)
10684                       {
10685                         cp_error ("constructors may not be `%s'",
10686                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10687                         quals = NULL_TREE;
10688                       }
10689                     {
10690                       RID_BIT_TYPE tmp_bits;
10691                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10692                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10693                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10694                       if (RIDBIT_ANY_SET (tmp_bits))
10695                         error ("return value type specifier for constructor ignored");
10696                     }
10697                     if (decl_context == FIELD)
10698                       {
10699                         if (! member_function_or_else (ctype,
10700                                                        current_class_type,
10701                                                        flags))
10702                           return void_type_node;
10703                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10704                         if (sfk != sfk_constructor)
10705                           return NULL_TREE;
10706                       }
10707                   }
10708                 if (decl_context == FIELD)
10709                   staticp = 0;
10710               }
10711             else if (friendp)
10712               {
10713                 if (initialized)
10714                   error ("can't initialize friend function `%s'", name);
10715                 if (virtualp)
10716                   {
10717                     /* Cannot be both friend and virtual.  */
10718                     error ("virtual functions cannot be friends");
10719                     RIDBIT_RESET (RID_FRIEND, specbits);
10720                     friendp = 0;
10721                   }
10722                 if (decl_context == NORMAL)
10723                   error ("friend declaration not in class definition");
10724                 if (current_function_decl && funcdef_flag)
10725                   cp_error ("can't define friend function `%s' in a local class definition",
10726                             name);
10727               }
10728
10729             /* Construct the function type and go to the next
10730                inner layer of declarator.  */
10731
10732             declarator = TREE_OPERAND (declarator, 0);
10733
10734             /* FIXME: This is where default args should be fully
10735                processed.  */
10736
10737             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10738
10739             if (declarator && flags == DTOR_FLAG)
10740               {
10741                 /* A destructor declared in the body of a class will
10742                    be represented as a BIT_NOT_EXPR.  But, we just
10743                    want the underlying IDENTIFIER.  */
10744                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10745                   declarator = TREE_OPERAND (declarator, 0);
10746
10747                 if (arg_types != void_list_node)
10748                   {
10749                     cp_error ("destructors may not have parameters");
10750                     arg_types = void_list_node;
10751                     last_function_parms = NULL_TREE;
10752                   }
10753               }
10754
10755             /* ANSI says that `const int foo ();'
10756                does not make the function foo const.  */
10757             type = build_function_type (type, arg_types);
10758
10759             {
10760               tree t;
10761               for (t = arg_types; t; t = TREE_CHAIN (t))
10762                 if (TREE_PURPOSE (t)
10763                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10764                   {
10765                     add_defarg_fn (type);
10766                     break;
10767                   }
10768             }
10769           }
10770           break;
10771
10772         case ADDR_EXPR:
10773         case INDIRECT_REF:
10774           /* Filter out pointers-to-references and references-to-references.
10775              We can get these if a TYPE_DECL is used.  */
10776
10777           if (TREE_CODE (type) == REFERENCE_TYPE)
10778             {
10779               error ("cannot declare %s to references",
10780                      TREE_CODE (declarator) == ADDR_EXPR
10781                      ? "references" : "pointers");
10782               declarator = TREE_OPERAND (declarator, 0);
10783               continue;
10784             }
10785
10786           if (TREE_CODE (type) == OFFSET_TYPE
10787               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10788                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10789             {
10790               cp_error ("cannot declare pointer to `%#T' member",
10791                         TREE_TYPE (type));
10792               type = TREE_TYPE (type);
10793             }
10794
10795           /* Merge any constancy or volatility into the target type
10796              for the pointer.  */
10797
10798           /* We now know that the TYPE_QUALS don't apply to the decl,
10799              but to the target of the pointer.  */
10800           type_quals = TYPE_UNQUALIFIED;
10801
10802           if (TREE_CODE (declarator) == ADDR_EXPR)
10803             {
10804               if (TREE_CODE (type) == VOID_TYPE)
10805                 error ("invalid type: `void &'");
10806               else
10807                 type = build_reference_type (type);
10808             }
10809           else if (TREE_CODE (type) == METHOD_TYPE)
10810             type = build_ptrmemfunc_type (build_pointer_type (type));
10811           else
10812             type = build_pointer_type (type);
10813
10814           /* Process a list of type modifier keywords (such as
10815              const or volatile) that were given inside the `*' or `&'.  */
10816
10817           if (TREE_TYPE (declarator))
10818             {
10819               register tree typemodlist;
10820               int erred = 0;
10821
10822               constp = 0;
10823               volatilep = 0;
10824               restrictp = 0;
10825               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10826                    typemodlist = TREE_CHAIN (typemodlist))
10827                 {
10828                   tree qualifier = TREE_VALUE (typemodlist);
10829
10830                   if (qualifier == ridpointers[(int) RID_CONST])
10831                     constp++;
10832                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10833                     volatilep++;
10834                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10835                     restrictp++;
10836                   else if (!erred)
10837                     {
10838                       erred = 1;
10839                       error ("invalid type modifier within pointer declarator");
10840                     }
10841                 }
10842               if (constp > 1)
10843                 pedwarn ("duplicate `const'");
10844               if (volatilep > 1)
10845                 pedwarn ("duplicate `volatile'");
10846               if (restrictp > 1)
10847                 pedwarn ("duplicate `restrict'");
10848
10849               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10850                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10851                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10852               if (TREE_CODE (declarator) == ADDR_EXPR
10853                   && (constp || volatilep))
10854                 {
10855                   if (constp)
10856                     pedwarn ("discarding `const' applied to a reference");
10857                   if (volatilep)
10858                     pedwarn ("discarding `volatile' applied to a reference");
10859                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10860                 }
10861               type = cp_build_qualified_type (type, type_quals);
10862             }
10863           declarator = TREE_OPERAND (declarator, 0);
10864           ctype = NULL_TREE;
10865           break;
10866
10867         case SCOPE_REF:
10868           {
10869             /* We have converted type names to NULL_TREE if the
10870                name was bogus, or to a _TYPE node, if not.
10871
10872                The variable CTYPE holds the type we will ultimately
10873                resolve to.  The code here just needs to build
10874                up appropriate member types.  */
10875             tree sname = TREE_OPERAND (declarator, 1);
10876             tree t;
10877
10878             /* Destructors can have their visibilities changed as well.  */
10879             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10880               sname = TREE_OPERAND (sname, 0);
10881
10882             if (TREE_COMPLEXITY (declarator) == 0)
10883               /* This needs to be here, in case we are called
10884                  multiple times.  */ ;
10885             else if (TREE_COMPLEXITY (declarator) == -1)
10886               /* Namespace member. */
10887               pop_decl_namespace ();
10888             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10889               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10890             else if (! IS_AGGR_TYPE_CODE
10891                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10892               ;
10893             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10894               {
10895                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10896                    that refer to ctype.  They couldn't be resolved earlier
10897                    because we hadn't pushed into the class yet.
10898                    Example: resolve 'B<T>::type' in
10899                    'B<typename B<T>::type> B<T>::f () { }'.  */
10900                 if (current_template_parms
10901                     && uses_template_parms (type)
10902                     && uses_template_parms (current_class_type))
10903                   {
10904                     tree args = current_template_args ();
10905                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10906                   }
10907
10908                 /* This pop_nested_class corresponds to the
10909                    push_nested_class used to push into class scope for
10910                    parsing the argument list of a function decl, in
10911                    qualified_id.  */
10912                 pop_nested_class ();
10913                 TREE_COMPLEXITY (declarator) = current_class_depth;
10914               }
10915             else
10916               my_friendly_abort (16);
10917
10918             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10919               {
10920                 /* We had a reference to a global decl, or
10921                    perhaps we were given a non-aggregate typedef,
10922                    in which case we cleared this out, and should just
10923                    keep going as though it wasn't there.  */
10924                 declarator = sname;
10925                 continue;
10926               }
10927             ctype = TREE_OPERAND (declarator, 0);
10928
10929             t = ctype;
10930             while (t != NULL_TREE && CLASS_TYPE_P (t))
10931               {
10932                 /* You're supposed to have one `template <...>'
10933                    for every template class, but you don't need one
10934                    for a full specialization.  For example:
10935
10936                      template <class T> struct S{};
10937                      template <> struct S<int> { void f(); };
10938                      void S<int>::f () {}
10939
10940                    is correct; there shouldn't be a `template <>' for
10941                    the definition of `S<int>::f'.  */
10942                 if (CLASSTYPE_TEMPLATE_INFO (t)
10943                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10944                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10945                   template_count += 1;
10946
10947                 t = TYPE_MAIN_DECL (t);
10948                 if (DECL_LANG_SPECIFIC (t))
10949                   t = DECL_CONTEXT (t);
10950                 else
10951                   t = NULL_TREE;
10952               }
10953
10954             if (sname == NULL_TREE)
10955               goto done_scoping;
10956
10957             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10958               {
10959                 /* This is the `standard' use of the scoping operator:
10960                    basetype :: member .  */
10961
10962                 if (ctype == current_class_type)
10963                   {
10964                     /* class A {
10965                          void A::f ();
10966                        };
10967
10968                        Is this ill-formed?  */
10969
10970                     if (pedantic)
10971                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10972                                   ctype, name);
10973                   }
10974                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10975                   {
10976                     if (current_class_type == NULL_TREE
10977                         || friendp)
10978                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10979                                                       TYPE_ARG_TYPES (type));
10980                     else
10981                       {
10982                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10983                                   ctype, name, current_class_type);
10984                         return void_type_node;
10985                       }
10986                   }
10987                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10988                          || COMPLETE_TYPE_P (complete_type (ctype)))
10989                   {
10990                     /* Have to move this code elsewhere in this function.
10991                        this code is used for i.e., typedef int A::M; M *pm;
10992
10993                        It is?  How? jason 10/2/94 */
10994
10995                     if (current_class_type)
10996                       {
10997                         cp_error ("cannot declare member `%T::%s' within `%T'",
10998                                   ctype, name, current_class_type);
10999                         return void_type_node;
11000                       }
11001                     type = build_offset_type (ctype, type);
11002                   }
11003                 else if (uses_template_parms (ctype))
11004                   {
11005                     if (TREE_CODE (type) == FUNCTION_TYPE)
11006                       type
11007                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11008                                                    TYPE_ARG_TYPES (type));
11009                   }
11010                 else
11011                   {
11012                     cp_error ("structure `%T' not yet defined", ctype);
11013                     return error_mark_node;
11014                   }
11015
11016                 declarator = sname;
11017               }
11018             else if (TREE_CODE (sname) == SCOPE_REF)
11019               my_friendly_abort (17);
11020             else
11021               {
11022               done_scoping:
11023                 declarator = TREE_OPERAND (declarator, 1);
11024                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11025                   /* In this case, we will deal with it later.  */
11026                   ;
11027                 else
11028                   {
11029                     if (TREE_CODE (type) == FUNCTION_TYPE)
11030                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11031                                                       TYPE_ARG_TYPES (type));
11032                     else
11033                       type = build_offset_type (ctype, type);
11034                   }
11035               }
11036           }
11037           break;
11038
11039         case BIT_NOT_EXPR:
11040           declarator = TREE_OPERAND (declarator, 0);
11041           break;
11042
11043         case RECORD_TYPE:
11044         case UNION_TYPE:
11045         case ENUMERAL_TYPE:
11046           declarator = NULL_TREE;
11047           break;
11048
11049         case ERROR_MARK:
11050           declarator = NULL_TREE;
11051           break;
11052
11053         default:
11054           my_friendly_abort (158);
11055         }
11056     }
11057
11058   /* See the comment for the TREE_LIST case, above.  */
11059   if (inner_attrs)
11060     {
11061       if (! ignore_attrs)
11062         decl_attributes (type, inner_attrs, NULL_TREE);
11063       else if (attrlist)
11064         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11065       else
11066         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11067     }
11068
11069   /* Now TYPE has the actual type.  */
11070
11071   if (explicitp == 1 || (explicitp && friendp))
11072     {
11073       /* [dcl.fct.spec] The explicit specifier shall only be used in
11074          declarations of constructors within a class definition.  */
11075       error ("only declarations of constructors can be `explicit'");
11076       explicitp = 0;
11077     }
11078
11079   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11080     {
11081       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11082         {
11083           error ("non-member `%s' cannot be declared `mutable'", name);
11084           RIDBIT_RESET (RID_MUTABLE, specbits);
11085         }
11086       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11087         {
11088           error ("non-object member `%s' cannot be declared `mutable'", name);
11089           RIDBIT_RESET (RID_MUTABLE, specbits);
11090         }
11091       else if (TREE_CODE (type) == FUNCTION_TYPE
11092                || TREE_CODE (type) == METHOD_TYPE)
11093         {
11094           error ("function `%s' cannot be declared `mutable'", name);
11095           RIDBIT_RESET (RID_MUTABLE, specbits);
11096         }
11097       else if (staticp)
11098         {
11099           error ("static `%s' cannot be declared `mutable'", name);
11100           RIDBIT_RESET (RID_MUTABLE, specbits);
11101         }
11102       else if (type_quals & TYPE_QUAL_CONST)
11103         {
11104           error ("const `%s' cannot be declared `mutable'", name);
11105           RIDBIT_RESET (RID_MUTABLE, specbits);
11106         }
11107     }
11108
11109   if (declarator == NULL_TREE
11110       || TREE_CODE (declarator) == IDENTIFIER_NODE
11111       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11112           && (TREE_CODE (type) == FUNCTION_TYPE
11113               || TREE_CODE (type) == METHOD_TYPE)))
11114     /* OK */;
11115   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11116     {
11117       cp_error ("template-id `%D' used as a declarator", declarator);
11118       declarator = dname;
11119     }
11120   else
11121     /* Unexpected declarator format.  */
11122     my_friendly_abort (990210);
11123
11124   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11125
11126   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11127     {
11128       tree decl;
11129
11130       /* Note that the grammar rejects storage classes
11131          in typenames, fields or parameters.  */
11132       if (current_lang_name == lang_name_java)
11133         TYPE_FOR_JAVA (type) = 1;
11134
11135       if (decl_context == FIELD)
11136         {
11137           if (declarator == constructor_name (current_class_type))
11138             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11139                         declarator);
11140           decl = build_lang_decl (TYPE_DECL, declarator, type);
11141         }
11142       else
11143         decl = build_decl (TYPE_DECL, declarator, type);
11144
11145       /* If the user declares "typedef struct {...} foo" then the
11146          struct will have an anonymous name.  Fill that name in now.
11147          Nothing can refer to it, so nothing needs know about the name
11148          change.  */
11149       if (type != error_mark_node
11150           && declarator
11151           && TYPE_NAME (type)
11152           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11153           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11154           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11155         {
11156           tree oldname = TYPE_NAME (type);
11157           tree t;
11158
11159           /* Replace the anonymous name with the real name everywhere.  */
11160           lookup_tag_reverse (type, declarator);
11161           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11162             if (TYPE_NAME (t) == oldname)
11163               TYPE_NAME (t) = decl;
11164
11165           if (TYPE_LANG_SPECIFIC (type))
11166             TYPE_WAS_ANONYMOUS (type) = 1;
11167
11168           /* If this is a typedef within a template class, the nested
11169              type is a (non-primary) template.  The name for the
11170              template needs updating as well.  */
11171           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11172             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11173               = TYPE_IDENTIFIER (type);
11174
11175           if (flag_new_abi)
11176             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11177           else
11178             {
11179               /* XXX Temporarily set the scope.
11180                  When returning, start_decl expects it as NULL_TREE,
11181                  and will then then set it using pushdecl. */
11182               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11183               if (current_class_type)
11184                 DECL_CONTEXT (decl) = current_class_type;
11185               else
11186                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11187
11188               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11189               DECL_ASSEMBLER_NAME (decl)
11190                 = get_identifier (build_overload_name (type, 1, 1));
11191               DECL_CONTEXT (decl) = NULL_TREE;
11192             }
11193
11194           /* FIXME remangle member functions; member functions of a
11195              type with external linkage have external linkage.  */
11196         }
11197
11198       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11199         {
11200           cp_error_at ("typedef name may not be class-qualified", decl);
11201           return NULL_TREE;
11202         }
11203       else if (quals)
11204         {
11205           if (ctype == NULL_TREE)
11206             {
11207               if (TREE_CODE (type) != METHOD_TYPE)
11208                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11209               else
11210                 ctype = TYPE_METHOD_BASETYPE (type);
11211             }
11212           if (ctype != NULL_TREE)
11213             grok_method_quals (ctype, decl, quals);
11214         }
11215
11216       if (RIDBIT_SETP (RID_SIGNED, specbits)
11217           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11218         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11219
11220       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11221                       inlinep, friendp, raises != NULL_TREE);
11222
11223       if (initialized)
11224         error ("typedef declaration includes an initializer");
11225
11226       return decl;
11227     }
11228
11229   /* Detect the case of an array type of unspecified size
11230      which came, as such, direct from a typedef name.
11231      We must copy the type, so that each identifier gets
11232      a distinct type, so that each identifier's size can be
11233      controlled separately by its own initializer.  */
11234
11235   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11236       && TYPE_DOMAIN (type) == NULL_TREE)
11237     {
11238       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11239     }
11240
11241   /* If this is a type name (such as, in a cast or sizeof),
11242      compute the type and return it now.  */
11243
11244   if (decl_context == TYPENAME)
11245     {
11246       /* Note that the grammar rejects storage classes
11247          in typenames, fields or parameters.  */
11248       if (type_quals != TYPE_UNQUALIFIED)
11249         type_quals = TYPE_UNQUALIFIED;
11250
11251       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11252       if (friendp)
11253         {
11254           if (type_quals != TYPE_UNQUALIFIED)
11255             {
11256               cp_error ("type qualifiers specified for friend class declaration");
11257               type_quals = TYPE_UNQUALIFIED;
11258             }
11259           if (inlinep)
11260             {
11261               cp_error ("`inline' specified for friend class declaration");
11262               inlinep = 0;
11263             }
11264
11265           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11266              But don't allow implicit typenames.  */
11267           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11268                                 || IMPLICIT_TYPENAME_P (type)))
11269             {
11270               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11271                 cp_pedwarn ("template parameters cannot be friends");
11272               else if (TREE_CODE (type) == TYPENAME_TYPE)
11273                 cp_pedwarn ("\
11274 friend declaration requires class-key, i.e. `friend class %T::%T'",
11275                             constructor_name (current_class_type),
11276                             TYPE_IDENTIFIER (type));
11277               else
11278                 cp_pedwarn ("\
11279 friend declaration requires class-key, i.e. `friend %#T'",
11280                             type);
11281             }
11282
11283           /* Only try to do this stuff if we didn't already give up.  */
11284           if (type != integer_type_node)
11285             {
11286               /* A friendly class?  */
11287               if (current_class_type)
11288                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11289               else
11290                 cp_error ("trying to make class `%T' a friend of global scope",
11291                           type);
11292               type = void_type_node;
11293             }
11294         }
11295       else if (quals)
11296         {
11297           if (ctype == NULL_TREE)
11298             {
11299               if (TREE_CODE (type) != METHOD_TYPE)
11300                 cp_error ("invalid qualifiers on non-member function type");
11301               else
11302                 ctype = TYPE_METHOD_BASETYPE (type);
11303             }
11304           if (ctype)
11305             {
11306               tree dummy = build_decl (TYPE_DECL, declarator, type);
11307               grok_method_quals (ctype, dummy, quals);
11308               type = TREE_TYPE (dummy);
11309             }
11310         }
11311
11312       return type;
11313     }
11314   else if (declarator == NULL_TREE && decl_context != PARM
11315            && decl_context != CATCHPARM
11316            && TREE_CODE (type) != UNION_TYPE
11317            && ! bitfield)
11318     {
11319       cp_error ("abstract declarator `%T' used as declaration", type);
11320       declarator = make_anon_name ();
11321     }
11322
11323   /* `void' at top level (not within pointer)
11324      is allowed only in typedefs or type names.
11325      We don't complain about parms either, but that is because
11326      a better error message can be made later.  */
11327
11328   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11329     {
11330       if (! declarator)
11331         error ("unnamed variable or field declared void");
11332       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11333         {
11334           if (IDENTIFIER_OPNAME_P (declarator))
11335             my_friendly_abort (356);
11336           else
11337             error ("variable or field `%s' declared void", name);
11338         }
11339       else
11340         error ("variable or field declared void");
11341       type = integer_type_node;
11342     }
11343
11344   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11345      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11346
11347   if (decl_context == PARM || decl_context == CATCHPARM)
11348     {
11349       if (ctype || in_namespace)
11350         error ("cannot use `::' in parameter declaration");
11351
11352       /* A parameter declared as an array of T is really a pointer to T.
11353          One declared as a function is really a pointer to a function.
11354          One declared as a member is really a pointer to member.  */
11355
11356       if (TREE_CODE (type) == ARRAY_TYPE)
11357         {
11358           /* Transfer const-ness of array into that of type pointed to.  */
11359           type = build_pointer_type (TREE_TYPE (type));
11360           type_quals = TYPE_UNQUALIFIED;
11361         }
11362       else if (TREE_CODE (type) == FUNCTION_TYPE)
11363         type = build_pointer_type (type);
11364       else if (TREE_CODE (type) == OFFSET_TYPE)
11365         type = build_pointer_type (type);
11366       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11367         {
11368           error ("declaration of `%s' as void", name);
11369           return NULL_TREE;
11370         }
11371     }
11372
11373   {
11374     register tree decl;
11375
11376     if (decl_context == PARM)
11377       {
11378         decl = build_decl (PARM_DECL, declarator, type);
11379
11380         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11381                         inlinep, friendp, raises != NULL_TREE);
11382
11383         /* Compute the type actually passed in the parmlist,
11384            for the case where there is no prototype.
11385            (For example, shorts and chars are passed as ints.)
11386            When there is a prototype, this is overridden later.  */
11387
11388         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11389       }
11390     else if (decl_context == FIELD)
11391       {
11392         if (type == error_mark_node)
11393           {
11394             /* Happens when declaring arrays of sizes which
11395                are error_mark_node, for example.  */
11396             decl = NULL_TREE;
11397           }
11398         else if (in_namespace && !friendp)
11399           {
11400             /* Something like struct S { int N::j; };  */
11401             cp_error ("invalid use of `::'");
11402             decl = NULL_TREE;
11403           }
11404         else if (TREE_CODE (type) == FUNCTION_TYPE)
11405           {
11406             int publicp = 0;
11407             tree function_context;
11408
11409             /* We catch the others as conflicts with the builtin
11410                typedefs.  */
11411             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11412               {
11413                 cp_error ("function `%D' cannot be declared friend",
11414                           declarator);
11415                 friendp = 0;
11416               }
11417
11418             if (friendp == 0)
11419               {
11420                 if (ctype == NULL_TREE)
11421                   ctype = current_class_type;
11422
11423                 if (ctype == NULL_TREE)
11424                   {
11425                     cp_error ("can't make `%D' into a method -- not in a class",
11426                               declarator);
11427                     return void_type_node;
11428                   }
11429
11430                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11431                    ARM 9.5 */
11432                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11433                   {
11434                     cp_error ("function `%D' declared virtual inside a union",
11435                               declarator);
11436                     return void_type_node;
11437                   }
11438
11439                 if (declarator == ansi_opname (NEW_EXPR)
11440                     || declarator == ansi_opname (VEC_NEW_EXPR)
11441                     || declarator == ansi_opname (DELETE_EXPR)
11442                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11443                   {
11444                     if (virtualp)
11445                       {
11446                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11447                                   declarator);
11448                         virtualp = 0;
11449                       }
11450                   }
11451                 else if (staticp < 2)
11452                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11453                                                   TYPE_ARG_TYPES (type));
11454               }
11455
11456             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11457             function_context = (ctype != NULL_TREE) ?
11458               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11459             publicp = (! friendp || ! staticp)
11460               && function_context == NULL_TREE;
11461             decl = grokfndecl (ctype, type,
11462                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11463                                ? declarator : dname,
11464                                declarator,
11465                                virtualp, flags, quals, raises,
11466                                friendp ? -1 : 0, friendp, publicp, inlinep,
11467                                funcdef_flag, template_count, in_namespace);
11468             if (decl == NULL_TREE)
11469               return decl;
11470 #if 0
11471             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11472             /* The decl and setting of decl_machine_attr is also turned off.  */
11473             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11474 #endif
11475
11476             /* [class.conv.ctor]
11477
11478                A constructor declared without the function-specifier
11479                explicit that can be called with a single parameter
11480                specifies a conversion from the type of its first
11481                parameter to the type of its class.  Such a constructor
11482                is called a converting constructor.  */
11483             if (explicitp == 2)
11484               DECL_NONCONVERTING_P (decl) = 1;
11485             else if (DECL_CONSTRUCTOR_P (decl))
11486               {
11487                 /* The constructor can be called with exactly one
11488                    parameter if there is at least one parameter, and
11489                    any subsequent parameters have default arguments.
11490                    We don't look at the first parameter, which is
11491                    really just the `this' parameter for the new
11492                    object.  */
11493                 tree arg_types =
11494                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11495
11496                 /* Skip the `in_chrg' argument too, if present.  */
11497                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11498                   arg_types = TREE_CHAIN (arg_types);
11499
11500                 if (arg_types == void_list_node
11501                     || (arg_types
11502                         && TREE_CHAIN (arg_types)
11503                         && TREE_CHAIN (arg_types) != void_list_node
11504                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11505                   DECL_NONCONVERTING_P (decl) = 1;
11506               }
11507           }
11508         else if (TREE_CODE (type) == METHOD_TYPE)
11509           {
11510             /* We only get here for friend declarations of
11511                members of other classes.  */
11512             /* All method decls are public, so tell grokfndecl to set
11513                TREE_PUBLIC, also.  */
11514             decl = grokfndecl (ctype, type, declarator, declarator,
11515                                virtualp, flags, quals, raises,
11516                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11517                                template_count, in_namespace);
11518             if (decl == NULL_TREE)
11519               return NULL_TREE;
11520           }
11521         else if (!staticp && ! processing_template_decl
11522                  && !COMPLETE_TYPE_P (complete_type (type))
11523                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11524           {
11525             if (declarator)
11526               cp_error ("field `%D' has incomplete type", declarator);
11527             else
11528               cp_error ("name `%T' has incomplete type", type);
11529
11530             /* If we're instantiating a template, tell them which
11531                instantiation made the field's type be incomplete.  */
11532             if (current_class_type
11533                 && TYPE_NAME (current_class_type)
11534                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11535                 && declspecs && TREE_VALUE (declspecs)
11536                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11537               cp_error ("  in instantiation of template `%T'",
11538                         current_class_type);
11539
11540             type = error_mark_node;
11541             decl = NULL_TREE;
11542           }
11543         else
11544           {
11545             if (friendp)
11546               {
11547                 error ("`%s' is neither function nor member function; cannot be declared friend",
11548                        IDENTIFIER_POINTER (declarator));
11549                 friendp = 0;
11550               }
11551             decl = NULL_TREE;
11552           }
11553
11554         if (friendp)
11555           {
11556             /* Friends are treated specially.  */
11557             if (ctype == current_class_type)
11558               warning ("member functions are implicitly friends of their class");
11559             else
11560               {
11561                 tree t = NULL_TREE;
11562                 if (decl && DECL_NAME (decl))
11563                   {
11564                     if (template_class_depth (current_class_type) == 0)
11565                       {
11566                         decl
11567                           = check_explicit_specialization
11568                           (declarator, decl,
11569                            template_count, 2 * (funcdef_flag != 0) + 4);
11570                         if (decl == error_mark_node)
11571                           return error_mark_node;
11572                       }
11573
11574                     t = do_friend (ctype, declarator, decl,
11575                                    last_function_parms, attrlist, flags, quals,
11576                                    funcdef_flag);
11577                   }
11578                 if (t && funcdef_flag)
11579                   return t;
11580
11581                 return void_type_node;
11582               }
11583           }
11584
11585         /* Structure field.  It may not be a function, except for C++ */
11586
11587         if (decl == NULL_TREE)
11588           {
11589             if (initialized)
11590               {
11591                 if (!staticp)
11592                   {
11593                     /* An attempt is being made to initialize a non-static
11594                        member.  But, from [class.mem]:
11595
11596                        4 A member-declarator can contain a
11597                        constant-initializer only if it declares a static
11598                        member (_class.static_) of integral or enumeration
11599                        type, see _class.static.data_.
11600
11601                        This used to be relatively common practice, but
11602                        the rest of the compiler does not correctly
11603                        handle the initialization unless the member is
11604                        static so we make it static below.  */
11605                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11606                                 declarator);
11607                     cp_pedwarn ("making `%D' static", declarator);
11608                     staticp = 1;
11609                   }
11610
11611                 if (uses_template_parms (type))
11612                   /* We'll check at instantiation time.  */
11613                   ;
11614                 else if (check_static_variable_definition (declarator,
11615                                                            type))
11616                   /* If we just return the declaration, crashes
11617                      will sometimes occur.  We therefore return
11618                      void_type_node, as if this was a friend
11619                      declaration, to cause callers to completely
11620                      ignore this declaration.  */
11621                   return void_type_node;
11622               }
11623
11624             /* 9.2p13 [class.mem] */
11625             if (declarator == constructor_name (current_class_type)
11626                 /* The standard does not allow non-static data members
11627                    here either, but we agreed at the 10/99 meeting
11628                    to change that in TC 1 so that they are allowed in
11629                    classes with no user-defined constructors.  */
11630                 && staticp)
11631               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11632                           declarator);
11633
11634             if (staticp)
11635               {
11636                 /* C++ allows static class members.  All other work
11637                    for this is done by grokfield.  */
11638                 decl = build_lang_decl (VAR_DECL, declarator, type);
11639                 TREE_STATIC (decl) = 1;
11640                 /* In class context, 'static' means public access.  */
11641                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11642               }
11643             else
11644               {
11645                 decl = build_decl (FIELD_DECL, declarator, type);
11646                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11647                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11648                   {
11649                     DECL_MUTABLE_P (decl) = 1;
11650                     RIDBIT_RESET (RID_MUTABLE, specbits);
11651                   }
11652               }
11653
11654             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11655                             inlinep, friendp, raises != NULL_TREE);
11656           }
11657       }
11658     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11659       {
11660         tree original_name;
11661         int publicp = 0;
11662
11663         if (! declarator)
11664           return NULL_TREE;
11665
11666         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11667           original_name = dname;
11668         else
11669           original_name = declarator;
11670
11671         if (RIDBIT_SETP (RID_AUTO, specbits))
11672           error ("storage class `auto' invalid for function `%s'", name);
11673         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11674           error ("storage class `register' invalid for function `%s'", name);
11675
11676         /* Function declaration not at top level.
11677            Storage classes other than `extern' are not allowed
11678            and `extern' makes no difference.  */
11679         if (! toplevel_bindings_p ()
11680             && (RIDBIT_SETP (RID_STATIC, specbits)
11681                 || RIDBIT_SETP (RID_INLINE, specbits))
11682             && pedantic)
11683           {
11684             if (RIDBIT_SETP (RID_STATIC, specbits))
11685               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11686             else
11687               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11688           }
11689
11690         if (ctype == NULL_TREE)
11691           {
11692             if (virtualp)
11693               {
11694                 error ("virtual non-class function `%s'", name);
11695                 virtualp = 0;
11696               }
11697           }
11698         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11699           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11700                                           TYPE_ARG_TYPES (type));
11701
11702         /* Record presence of `static'.  */
11703         publicp = (ctype != NULL_TREE
11704                    || RIDBIT_SETP (RID_EXTERN, specbits)
11705                    || !RIDBIT_SETP (RID_STATIC, specbits));
11706
11707         decl = grokfndecl (ctype, type, original_name, declarator,
11708                            virtualp, flags, quals, raises,
11709                            1, friendp,
11710                            publicp, inlinep, funcdef_flag,
11711                            template_count, in_namespace);
11712         if (decl == NULL_TREE)
11713           return NULL_TREE;
11714
11715         if (staticp == 1)
11716           {
11717             int illegal_static = 0;
11718
11719             /* Don't allow a static member function in a class, and forbid
11720                declaring main to be static.  */
11721             if (TREE_CODE (type) == METHOD_TYPE)
11722               {
11723                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11724                 illegal_static = 1;
11725               }
11726             else if (current_function_decl)
11727               {
11728                 /* FIXME need arm citation */
11729                 error ("cannot declare static function inside another function");
11730                 illegal_static = 1;
11731               }
11732
11733             if (illegal_static)
11734               {
11735                 staticp = 0;
11736                 RIDBIT_RESET (RID_STATIC, specbits);
11737               }
11738           }
11739       }
11740     else
11741       {
11742         /* It's a variable.  */
11743
11744         /* An uninitialized decl with `extern' is a reference.  */
11745         decl = grokvardecl (type, declarator, &specbits,
11746                             initialized,
11747                             (type_quals & TYPE_QUAL_CONST) != 0,
11748                             in_namespace);
11749         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11750                         inlinep, friendp, raises != NULL_TREE);
11751
11752         if (ctype)
11753           {
11754             DECL_CONTEXT (decl) = ctype;
11755             if (staticp == 1)
11756               {
11757                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11758                 staticp = 0;
11759                 RIDBIT_RESET (RID_STATIC, specbits);
11760               }
11761             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11762               {
11763                 cp_error ("static member `%D' declared `register'", decl);
11764                 RIDBIT_RESET (RID_REGISTER, specbits);
11765               }
11766             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11767               {
11768                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11769                             decl);
11770                 RIDBIT_RESET (RID_EXTERN, specbits);
11771               }
11772           }
11773       }
11774
11775     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11776
11777     /* Record `register' declaration for warnings on &
11778        and in case doing stupid register allocation.  */
11779
11780     if (RIDBIT_SETP (RID_REGISTER, specbits))
11781       DECL_REGISTER (decl) = 1;
11782
11783     if (RIDBIT_SETP (RID_EXTERN, specbits))
11784       DECL_THIS_EXTERN (decl) = 1;
11785
11786     if (RIDBIT_SETP (RID_STATIC, specbits))
11787       DECL_THIS_STATIC (decl) = 1;
11788
11789     /* Record constancy and volatility.  There's no need to do this
11790        when processing a template; we'll do this for the instantiated
11791        declaration based on the type of DECL.  */
11792     if (!processing_template_decl)
11793       c_apply_type_quals_to_decl (type_quals, decl);
11794
11795     return decl;
11796   }
11797 }
11798 \f
11799 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11800    An empty exprlist is a parmlist.  An exprlist which
11801    contains only identifiers at the global level
11802    is a parmlist.  Otherwise, it is an exprlist.  */
11803
11804 int
11805 parmlist_is_exprlist (exprs)
11806      tree exprs;
11807 {
11808   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11809     return 0;
11810
11811   if (toplevel_bindings_p ())
11812     {
11813       /* At the global level, if these are all identifiers,
11814          then it is a parmlist.  */
11815       while (exprs)
11816         {
11817           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11818             return 1;
11819           exprs = TREE_CHAIN (exprs);
11820         }
11821       return 0;
11822     }
11823   return 1;
11824 }
11825
11826 /* Subroutine of start_function.  Ensure that each of the parameter
11827    types (as listed in PARMS) is complete, as is required for a
11828    function definition.  */
11829
11830 static void
11831 require_complete_types_for_parms (parms)
11832      tree parms;
11833 {
11834   for (; parms; parms = TREE_CHAIN (parms))
11835     {
11836       tree type = TREE_TYPE (parms);
11837
11838       /* Try to complete the TYPE.  */
11839       type = complete_type (type);
11840
11841       if (type == error_mark_node)
11842         continue;
11843
11844       if (!COMPLETE_TYPE_P (type))
11845         {
11846           if (DECL_NAME (parms))
11847             error ("parameter `%s' has incomplete type",
11848                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11849           else
11850             error ("parameter has incomplete type");
11851           TREE_TYPE (parms) = error_mark_node;
11852         }
11853       else
11854         layout_decl (parms, 0);
11855     }
11856 }
11857
11858 /* Returns non-zero if T is a local variable.  */
11859
11860 int
11861 local_variable_p (t)
11862      tree t;
11863 {
11864   if ((TREE_CODE (t) == VAR_DECL
11865        /* A VAR_DECL with a context that is a _TYPE is a static data
11866           member.  */
11867        && !TYPE_P (CP_DECL_CONTEXT (t))
11868        /* Any other non-local variable must be at namespace scope.  */
11869        && !DECL_NAMESPACE_SCOPE_P (t))
11870       || (TREE_CODE (t) == PARM_DECL))
11871     return 1;
11872
11873   return 0;
11874 }
11875
11876 /* Returns non-zero if T is an automatic local variable or a label.
11877    (These are the declarations that need to be remapped when the code
11878    containing them is duplicated.)  */
11879
11880 int
11881 nonstatic_local_decl_p (t)
11882      tree t;
11883 {
11884   return ((local_variable_p (t) && !TREE_STATIC (t))
11885           || TREE_CODE (t) == LABEL_DECL
11886           || TREE_CODE (t) == RESULT_DECL);
11887 }
11888
11889 /* Like local_variable_p, but suitable for use as a tree-walking
11890    function.  */
11891
11892 static tree
11893 local_variable_p_walkfn (tp, walk_subtrees, data)
11894      tree *tp;
11895      int *walk_subtrees ATTRIBUTE_UNUSED;
11896      void *data ATTRIBUTE_UNUSED;
11897 {
11898   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11899           ? *tp : NULL_TREE);
11900 }
11901
11902 /* Check that ARG, which is a default-argument expression for a
11903    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11904    something goes wrong.  DECL may also be a _TYPE node, rather than a
11905    DECL, if there is no DECL available.  */
11906
11907 tree
11908 check_default_argument (decl, arg)
11909      tree decl;
11910      tree arg;
11911 {
11912   tree var;
11913   tree decl_type;
11914
11915   if (TREE_CODE (arg) == DEFAULT_ARG)
11916     /* We get a DEFAULT_ARG when looking at an in-class declaration
11917        with a default argument.  Ignore the argument for now; we'll
11918        deal with it after the class is complete.  */
11919     return arg;
11920
11921   if (processing_template_decl || uses_template_parms (arg))
11922     /* We don't do anything checking until instantiation-time.  Note
11923        that there may be uninstantiated arguments even for an
11924        instantiated function, since default arguments are not
11925        instantiated until they are needed.  */
11926     return arg;
11927
11928   if (TYPE_P (decl))
11929     {
11930       decl_type = decl;
11931       decl = NULL_TREE;
11932     }
11933   else
11934     decl_type = TREE_TYPE (decl);
11935
11936   if (arg == error_mark_node
11937       || decl == error_mark_node
11938       || TREE_TYPE (arg) == error_mark_node
11939       || decl_type == error_mark_node)
11940     /* Something already went wrong.  There's no need to check
11941        further.  */
11942     return error_mark_node;
11943
11944   /* [dcl.fct.default]
11945
11946      A default argument expression is implicitly converted to the
11947      parameter type.  */
11948   if (!TREE_TYPE (arg)
11949       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11950     {
11951       if (decl)
11952         cp_error ("default argument for `%#D' has type `%T'",
11953                   decl, TREE_TYPE (arg));
11954       else
11955         cp_error ("default argument for parameter of type `%T' has type `%T'",
11956                   decl_type, TREE_TYPE (arg));
11957
11958       return error_mark_node;
11959     }
11960
11961   /* [dcl.fct.default]
11962
11963      Local variables shall not be used in default argument
11964      expressions.
11965
11966      The keyword `this' shall not be used in a default argument of a
11967      member function.  */
11968   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11969                                       NULL);
11970   if (var)
11971     {
11972       cp_error ("default argument `%E' uses local variable `%D'",
11973                 arg, var);
11974       return error_mark_node;
11975     }
11976
11977   /* All is well.  */
11978   return arg;
11979 }
11980
11981 /* Decode the list of parameter types for a function type.
11982    Given the list of things declared inside the parens,
11983    return a list of types.
11984
11985    The list we receive can have three kinds of elements:
11986    an IDENTIFIER_NODE for names given without types,
11987    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11988    or void_type_node, to mark the end of an argument list
11989    when additional arguments are not permitted (... was not used).
11990
11991    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11992    a mere declaration.  A nonempty identifier-list gets an error message
11993    when FUNCDEF_FLAG is zero.
11994    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11995    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11996
11997    If all elements of the input list contain types,
11998    we return a list of the types.
11999    If all elements contain no type (except perhaps a void_type_node
12000    at the end), we return a null list.
12001    If some have types and some do not, it is an error, and we
12002    return a null list.
12003
12004    Also set last_function_parms to either
12005    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12006    A list of names is converted to a chain of PARM_DECLs
12007    by store_parm_decls so that ultimately it is always a chain of decls.
12008
12009    Note that in C++, parameters can take default values.  These default
12010    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12011    an error to specify default values which are followed by parameters
12012    that have no default values, or an ELLIPSES.  For simplicities sake,
12013    only parameters which are specified with their types can take on
12014    default values.  */
12015
12016 static tree
12017 grokparms (first_parm, funcdef_flag)
12018      tree first_parm;
12019      int funcdef_flag;
12020 {
12021   tree result = NULL_TREE;
12022   tree decls = NULL_TREE;
12023
12024   if (first_parm != NULL_TREE
12025       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12026     {
12027       if (! funcdef_flag)
12028         pedwarn ("parameter names (without types) in function declaration");
12029       last_function_parms = first_parm;
12030       return NULL_TREE;
12031     }
12032   else if (first_parm != NULL_TREE
12033            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12034            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12035     my_friendly_abort (145);
12036   else
12037     {
12038       /* Types were specified.  This is a list of declarators
12039          each represented as a TREE_LIST node.  */
12040       register tree parm, chain;
12041       int any_init = 0, any_error = 0;
12042
12043       if (first_parm != NULL_TREE)
12044         {
12045           tree last_result = NULL_TREE;
12046           tree last_decl = NULL_TREE;
12047
12048           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12049             {
12050               tree type = NULL_TREE, list_node = parm;
12051               register tree decl = TREE_VALUE (parm);
12052               tree init = TREE_PURPOSE (parm);
12053
12054               chain = TREE_CHAIN (parm);
12055               /* @@ weak defense against parse errors.  */
12056               if (TREE_CODE (decl) != VOID_TYPE
12057                   && TREE_CODE (decl) != TREE_LIST)
12058                 {
12059                   /* Give various messages as the need arises.  */
12060                   if (TREE_CODE (decl) == STRING_CST)
12061                     cp_error ("invalid string constant `%E'", decl);
12062                   else if (TREE_CODE (decl) == INTEGER_CST)
12063                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12064                   continue;
12065                 }
12066
12067               if (TREE_CODE (decl) != VOID_TYPE)
12068                 {
12069                   decl = grokdeclarator (TREE_VALUE (decl),
12070                                          TREE_PURPOSE (decl),
12071                                          PARM, init != NULL_TREE,
12072                                          NULL_TREE);
12073                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12074                     continue;
12075
12076                   /* Top-level qualifiers on the parameters are
12077                      ignored for function types.  */
12078                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12079
12080                   if (TREE_CODE (type) == VOID_TYPE)
12081                     decl = void_type_node;
12082                   else if (TREE_CODE (type) == METHOD_TYPE)
12083                     {
12084                       if (DECL_NAME (decl))
12085                         /* Cannot use the decl here because
12086                            we don't have DECL_CONTEXT set up yet.  */
12087                         cp_error ("parameter `%D' invalidly declared method type",
12088                                   DECL_NAME (decl));
12089                       else
12090                         error ("parameter invalidly declared method type");
12091                       type = build_pointer_type (type);
12092                       TREE_TYPE (decl) = type;
12093                     }
12094                   else if (TREE_CODE (type) == OFFSET_TYPE)
12095                     {
12096                       if (DECL_NAME (decl))
12097                         cp_error ("parameter `%D' invalidly declared offset type",
12098                                   DECL_NAME (decl));
12099                       else
12100                         error ("parameter invalidly declared offset type");
12101                       type = build_pointer_type (type);
12102                       TREE_TYPE (decl) = type;
12103                     }
12104                   else if (abstract_virtuals_error (decl, type))
12105                     any_error = 1;  /* Seems like a good idea. */
12106                   else if (POINTER_TYPE_P (type))
12107                     {
12108                       tree t = type;
12109                       while (POINTER_TYPE_P (t)
12110                              || (TREE_CODE (t) == ARRAY_TYPE
12111                                  && TYPE_DOMAIN (t) != NULL_TREE))
12112                         t = TREE_TYPE (t);
12113                       if (TREE_CODE (t) == ARRAY_TYPE)
12114                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12115                                   type,
12116                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12117                     }
12118                 }
12119
12120               if (TREE_CODE (decl) == VOID_TYPE)
12121                 {
12122                   if (result == NULL_TREE)
12123                     {
12124                       result = void_list_node;
12125                       last_result = result;
12126                     }
12127                   else
12128                     {
12129                       TREE_CHAIN (last_result) = void_list_node;
12130                       last_result = void_list_node;
12131                     }
12132                   if (chain
12133                       && (chain != void_list_node || TREE_CHAIN (chain)))
12134                     error ("`void' in parameter list must be entire list");
12135                   break;
12136                 }
12137
12138               /* Since there is a prototype, args are passed in their own types.  */
12139               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12140               if (PROMOTE_PROTOTYPES
12141                   && (TREE_CODE (type) == INTEGER_TYPE
12142                       || TREE_CODE (type) == ENUMERAL_TYPE)
12143                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12144                 DECL_ARG_TYPE (decl) = integer_type_node;
12145               if (!any_error && init)
12146                 {
12147                   any_init++;
12148                   init = check_default_argument (decl, init);
12149                 }
12150               else
12151                 init = NULL_TREE;
12152
12153               if (decls == NULL_TREE)
12154                 {
12155                   decls = decl;
12156                   last_decl = decls;
12157                 }
12158               else
12159                 {
12160                   TREE_CHAIN (last_decl) = decl;
12161                   last_decl = decl;
12162                 }
12163               list_node = tree_cons (init, type, NULL_TREE);
12164               if (result == NULL_TREE)
12165                 {
12166                   result = list_node;
12167                   last_result = result;
12168                 }
12169               else
12170                 {
12171                   TREE_CHAIN (last_result) = list_node;
12172                   last_result = list_node;
12173                 }
12174             }
12175           if (last_result)
12176             TREE_CHAIN (last_result) = NULL_TREE;
12177           /* If there are no parameters, and the function does not end
12178              with `...', then last_decl will be NULL_TREE.  */
12179           if (last_decl != NULL_TREE)
12180             TREE_CHAIN (last_decl) = NULL_TREE;
12181         }
12182     }
12183
12184   last_function_parms = decls;
12185
12186   return result;
12187 }
12188
12189 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12190    FUNCTION_TYPE with the newly parsed version of its default argument, which
12191    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12192
12193 void
12194 replace_defarg (arg, init)
12195      tree arg, init;
12196 {
12197   if (! processing_template_decl
12198       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12199     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12200                 TREE_TYPE (init), TREE_VALUE (arg));
12201   TREE_PURPOSE (arg) = init;
12202 }
12203 \f
12204 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12205    D's arguments allow it to be a copy constructor, or copy assignment
12206    operator.  */
12207
12208 int
12209 copy_args_p (d)
12210      tree d;
12211 {
12212   tree t;
12213
12214   if (!DECL_FUNCTION_MEMBER_P (d))
12215     return 0;
12216
12217   t = FUNCTION_ARG_CHAIN (d);
12218   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12219     t = TREE_CHAIN (t);
12220   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12221       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12222           == DECL_CONTEXT (d))
12223       && (TREE_CHAIN (t) == NULL_TREE
12224           || TREE_CHAIN (t) == void_list_node
12225           || TREE_PURPOSE (TREE_CHAIN (t))))
12226     return 1;
12227   return 0;
12228 }
12229
12230 /* These memoizing functions keep track of special properties which
12231    a class may have.  `grok_ctor_properties' notices whether a class
12232    has a constructor of the form X(X&), and also complains
12233    if the class has a constructor of the form X(X).
12234    `grok_op_properties' takes notice of the various forms of
12235    operator= which are defined, as well as what sorts of type conversion
12236    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12237
12238 int
12239 grok_ctor_properties (ctype, decl)
12240      tree ctype, decl;
12241 {
12242   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12243   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12244
12245   /* When a type has virtual baseclasses, a magical first int argument is
12246      added to any ctor so we can tell if the class has been initialized
12247      yet.  This could screw things up in this function, so we deliberately
12248      ignore the leading int if we're in that situation.  */
12249   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12250     {
12251       my_friendly_assert (parmtypes
12252                           && TREE_VALUE (parmtypes) == integer_type_node,
12253                           980529);
12254       parmtypes = TREE_CHAIN (parmtypes);
12255       parmtype = TREE_VALUE (parmtypes);
12256     }
12257
12258   /* [class.copy]
12259
12260      A non-template constructor for class X is a copy constructor if
12261      its first parameter is of type X&, const X&, volatile X& or const
12262      volatile X&, and either there are no other parameters or else all
12263      other parameters have default arguments.  */
12264   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12265       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12266       && (TREE_CHAIN (parmtypes) == NULL_TREE
12267           || TREE_CHAIN (parmtypes) == void_list_node
12268           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12269       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12270            && is_member_template (DECL_TI_TEMPLATE (decl))))
12271     {
12272       TYPE_HAS_INIT_REF (ctype) = 1;
12273       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12274         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12275     }
12276   /* [class.copy]
12277
12278      A declaration of a constructor for a class X is ill-formed if its
12279      first parameter is of type (optionally cv-qualified) X and either
12280      there are no other parameters or else all other parameters have
12281      default arguments.
12282
12283      We *don't* complain about member template instantiations that
12284      have this form, though; they can occur as we try to decide what
12285      constructor to use during overload resolution.  Since overload
12286      resolution will never prefer such a constructor to the
12287      non-template copy constructor (which is either explicitly or
12288      implicitly defined), there's no need to worry about their
12289      existence.  Theoretically, they should never even be
12290      instantiated, but that's hard to forestall.  */
12291   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12292            && (TREE_CHAIN (parmtypes) == NULL_TREE
12293                || TREE_CHAIN (parmtypes) == void_list_node
12294                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12295            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12296                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12297     {
12298       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12299                 ctype, ctype);
12300       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12301       return 0;
12302     }
12303   else if (TREE_CODE (parmtype) == VOID_TYPE
12304            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12305     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12306
12307   return 1;
12308 }
12309
12310 /* An operator with this code is unary, but can also be binary.  */
12311
12312 static int
12313 ambi_op_p (code)
12314      enum tree_code code;
12315 {
12316   return (code == INDIRECT_REF
12317           || code == ADDR_EXPR
12318           || code == CONVERT_EXPR
12319           || code == NEGATE_EXPR
12320           || code == PREINCREMENT_EXPR
12321           || code == PREDECREMENT_EXPR);
12322 }
12323
12324 /* An operator with this name can only be unary.  */
12325
12326 static int
12327 unary_op_p (code)
12328      enum tree_code code;
12329 {
12330   return (code == TRUTH_NOT_EXPR
12331           || code == BIT_NOT_EXPR
12332           || code == COMPONENT_REF
12333           || code == TYPE_EXPR);
12334 }
12335
12336 /* Do a little sanity-checking on how they declared their operator.  */
12337
12338 void
12339 grok_op_properties (decl, virtualp, friendp)
12340      tree decl;
12341      int virtualp, friendp;
12342 {
12343   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12344   tree argtype;
12345   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12346   tree name = DECL_NAME (decl);
12347   enum tree_code operator_code;
12348   int arity;
12349
12350   /* Count the number of arguments.  */
12351   for (argtype = argtypes, arity = 0;
12352        argtype && argtype != void_list_node;
12353        argtype = TREE_CHAIN (argtype))
12354     ++arity;
12355
12356   if (current_class_type == NULL_TREE)
12357     friendp = 1;
12358
12359   if (DECL_CONV_FN_P (decl))
12360     operator_code = TYPE_EXPR;
12361   else
12362     do
12363       {
12364 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12365         if (ansi_opname (CODE) == name)                                     \
12366           {                                                                 \
12367             operator_code = CODE;                                           \
12368             break;                                                          \
12369           }                                                                 \
12370         else if (ansi_assopname (CODE) == name)                             \
12371           {                                                                 \
12372             operator_code = CODE;                                           \
12373             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12374             break;                                                          \
12375           }
12376
12377 #include "operators.def"
12378 #undef DEF_OPERATOR
12379
12380         my_friendly_abort (20000527);
12381       }
12382     while (0);
12383   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12384   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12385
12386   if (! friendp)
12387     {
12388       switch (operator_code)
12389         {
12390         case CALL_EXPR:
12391           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12392           break;
12393
12394         case ARRAY_REF:
12395           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12396           break;
12397
12398         case COMPONENT_REF:
12399         case MEMBER_REF:
12400           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12401           break;
12402
12403         case NEW_EXPR:
12404           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12405           break;
12406
12407         case DELETE_EXPR:
12408           TYPE_GETS_DELETE (current_class_type) |= 1;
12409           break;
12410
12411         case VEC_NEW_EXPR:
12412           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12413           break;
12414
12415         case VEC_DELETE_EXPR:
12416           TYPE_GETS_DELETE (current_class_type) |= 2;
12417           break;
12418
12419         default:
12420           break;
12421         }
12422     }
12423
12424   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12425     {
12426       /* When the compiler encounters the definition of A::operator new, it
12427          doesn't look at the class declaration to find out if it's static.  */
12428       if (methodp)
12429         revert_static_member_fn (decl);
12430
12431       /* Take care of function decl if we had syntax errors.  */
12432       if (argtypes == NULL_TREE)
12433         TREE_TYPE (decl)
12434           = build_function_type (ptr_type_node,
12435                                  hash_tree_chain (integer_type_node,
12436                                                   void_list_node));
12437       else
12438         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12439     }
12440   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12441     {
12442       if (methodp)
12443         revert_static_member_fn (decl);
12444
12445       if (argtypes == NULL_TREE)
12446         TREE_TYPE (decl)
12447           = build_function_type (void_type_node,
12448                                  hash_tree_chain (ptr_type_node,
12449                                                   void_list_node));
12450       else
12451         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12452     }
12453   else
12454     {
12455       /* An operator function must either be a non-static member function
12456          or have at least one parameter of a class, a reference to a class,
12457          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12458       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12459         {
12460           if (operator_code == TYPE_EXPR
12461               || operator_code == CALL_EXPR
12462               || operator_code == COMPONENT_REF
12463               || operator_code == ARRAY_REF
12464               || operator_code == NOP_EXPR)
12465             cp_error ("`%D' must be a nonstatic member function", decl);
12466           else
12467             {
12468               tree p = argtypes;
12469
12470               if (DECL_STATIC_FUNCTION_P (decl))
12471                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12472
12473               if (p)
12474                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12475                   {
12476                     tree arg = TREE_VALUE (p);
12477                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12478                       arg = TREE_TYPE (arg);
12479
12480                     /* This lets bad template code slip through.  */
12481                     if (IS_AGGR_TYPE (arg)
12482                         || TREE_CODE (arg) == ENUMERAL_TYPE
12483                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12484                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12485                       goto foundaggr;
12486                   }
12487               cp_error
12488                 ("`%D' must have an argument of class or enumerated type",
12489                  decl);
12490             foundaggr:
12491               ;
12492             }
12493         }
12494
12495       if (operator_code == CALL_EXPR)
12496         return;                 /* No restrictions on args. */
12497
12498       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12499         {
12500           tree t = TREE_TYPE (name);
12501           if (! friendp)
12502             {
12503               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12504               const char *what = 0;
12505
12506               if (ref)
12507                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12508
12509               if (TREE_CODE (t) == VOID_TYPE)
12510                 what = "void";
12511               else if (t == current_class_type)
12512                 what = "the same type";
12513               /* Don't force t to be complete here.  */
12514               else if (IS_AGGR_TYPE (t)
12515                        && COMPLETE_TYPE_P (t)
12516                        && DERIVED_FROM_P (t, current_class_type))
12517                 what = "a base class";
12518
12519               if (what)
12520                 warning ("conversion to %s%s will never use a type conversion operator",
12521                          ref ? "a reference to " : "", what);
12522             }
12523         }
12524
12525       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12526           && operator_code == NOP_EXPR)
12527         {
12528           tree parmtype;
12529
12530           if (arity != 2 && methodp)
12531             {
12532               cp_error ("`%D' must take exactly one argument", decl);
12533               return;
12534             }
12535           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12536
12537           /* [class.copy]
12538
12539              A user-declared copy assignment operator X::operator= is
12540              a non-static non-template member function of class X with
12541              exactly one parameter of type X, X&, const X&, volatile
12542              X& or const volatile X&.  */
12543           if (copy_assignment_arg_p (parmtype, virtualp)
12544               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12545                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12546               && ! friendp)
12547             {
12548               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12549               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12550                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12551                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12552             }
12553         }
12554       else if (operator_code == COND_EXPR)
12555         {
12556           /* 13.4.0.3 */
12557           cp_error ("ISO C++ prohibits overloading operator ?:");
12558         }
12559       else if (ambi_op_p (operator_code))
12560         {
12561           if (arity == 1)
12562             /* We pick the one-argument operator codes by default, so
12563                we don't have to change anything.  */
12564             ;
12565           else if (arity == 2)
12566             {
12567               /* If we thought this was a unary operator, we now know
12568                  it to be a binary operator.  */
12569               switch (operator_code)
12570                 {
12571                 case INDIRECT_REF:
12572                   operator_code = MULT_EXPR;
12573                   break;
12574
12575                 case ADDR_EXPR:
12576                   operator_code = BIT_AND_EXPR;
12577                   break;
12578
12579                 case CONVERT_EXPR:
12580                   operator_code = PLUS_EXPR;
12581                   break;
12582
12583                 case NEGATE_EXPR:
12584                   operator_code = MINUS_EXPR;
12585                   break;
12586
12587                 case PREINCREMENT_EXPR:
12588                   operator_code = POSTINCREMENT_EXPR;
12589                   break;
12590
12591                 case PREDECREMENT_EXPR:
12592                   operator_code = POSTDECREMENT_EXPR;
12593                   break;
12594
12595                 default:
12596                   my_friendly_abort (20000527);
12597                 }
12598
12599               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12600
12601               if ((operator_code == POSTINCREMENT_EXPR
12602                    || operator_code == POSTDECREMENT_EXPR)
12603                   && ! processing_template_decl
12604                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12605                 {
12606                   if (methodp)
12607                     cp_error ("postfix `%D' must take `int' as its argument",
12608                               decl);
12609                   else
12610                     cp_error
12611                       ("postfix `%D' must take `int' as its second argument",
12612                        decl);
12613                 }
12614             }
12615           else
12616             {
12617               if (methodp)
12618                 cp_error ("`%D' must take either zero or one argument", decl);
12619               else
12620                 cp_error ("`%D' must take either one or two arguments", decl);
12621             }
12622
12623           /* More Effective C++ rule 6.  */
12624           if (warn_ecpp
12625               && (operator_code == POSTINCREMENT_EXPR
12626                   || operator_code == POSTDECREMENT_EXPR
12627                   || operator_code == PREINCREMENT_EXPR
12628                   || operator_code == PREDECREMENT_EXPR))
12629             {
12630               tree arg = TREE_VALUE (argtypes);
12631               tree ret = TREE_TYPE (TREE_TYPE (decl));
12632               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12633                 arg = TREE_TYPE (arg);
12634               arg = TYPE_MAIN_VARIANT (arg);
12635               if (operator_code == PREINCREMENT_EXPR
12636                   || operator_code == PREDECREMENT_EXPR)
12637                 {
12638                   if (TREE_CODE (ret) != REFERENCE_TYPE
12639                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12640                                        arg))
12641                     cp_warning ("prefix `%D' should return `%T'", decl,
12642                                 build_reference_type (arg));
12643                 }
12644               else
12645                 {
12646                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12647                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12648                 }
12649             }
12650         }
12651       else if (unary_op_p (operator_code))
12652         {
12653           if (arity != 1)
12654             {
12655               if (methodp)
12656                 cp_error ("`%D' must take `void'", decl);
12657               else
12658                 cp_error ("`%D' must take exactly one argument", decl);
12659             }
12660         }
12661       else /* if (binary_op_p (operator_code)) */
12662         {
12663           if (arity != 2)
12664             {
12665               if (methodp)
12666                 cp_error ("`%D' must take exactly one argument", decl);
12667               else
12668                 cp_error ("`%D' must take exactly two arguments", decl);
12669             }
12670
12671           /* More Effective C++ rule 7.  */
12672           if (warn_ecpp
12673               && (operator_code == TRUTH_ANDIF_EXPR
12674                   || operator_code == TRUTH_ORIF_EXPR
12675                   || operator_code == COMPOUND_EXPR))
12676             cp_warning ("user-defined `%D' always evaluates both arguments",
12677                         decl);
12678         }
12679
12680       /* Effective C++ rule 23.  */
12681       if (warn_ecpp
12682           && arity == 2
12683           && (operator_code == PLUS_EXPR
12684               || operator_code == MINUS_EXPR
12685               || operator_code == TRUNC_DIV_EXPR
12686               || operator_code == MULT_EXPR)
12687           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12688         cp_warning ("`%D' should return by value", decl);
12689
12690       /* 13.4.0.8 */
12691       for (; argtypes && argtypes != void_list_node;
12692           argtypes = TREE_CHAIN (argtypes))
12693         if (TREE_PURPOSE (argtypes))
12694           {
12695             TREE_PURPOSE (argtypes) = NULL_TREE;
12696             if (operator_code == POSTINCREMENT_EXPR
12697                 || operator_code == POSTDECREMENT_EXPR)
12698               {
12699                 if (pedantic)
12700                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12701               }
12702             else
12703               cp_error ("`%D' cannot have default arguments", decl);
12704           }
12705
12706     }
12707 }
12708 \f
12709 static const char *
12710 tag_name (code)
12711      enum tag_types code;
12712 {
12713   switch (code)
12714     {
12715     case record_type:
12716       return "struct";
12717     case class_type:
12718       return "class";
12719     case union_type:
12720       return "union ";
12721     case enum_type:
12722       return "enum";
12723     default:
12724       my_friendly_abort (981122);
12725     }
12726 }
12727
12728 /* Get the struct, enum or union (CODE says which) with tag NAME.
12729    Define the tag as a forward-reference if it is not defined.
12730
12731    C++: If a class derivation is given, process it here, and report
12732    an error if multiple derivation declarations are not identical.
12733
12734    If this is a definition, come in through xref_tag and only look in
12735    the current frame for the name (since C++ allows new names in any
12736    scope.)  */
12737
12738 tree
12739 xref_tag (code_type_node, name, globalize)
12740      tree code_type_node;
12741      tree name;
12742      int globalize;
12743 {
12744   enum tag_types tag_code;
12745   enum tree_code code;
12746   register tree ref, t;
12747   struct binding_level *b = current_binding_level;
12748   int got_type = 0;
12749   tree attributes = NULL_TREE;
12750   tree context = NULL_TREE;
12751
12752   /* If we are called from the parser, code_type_node will sometimes be a
12753      TREE_LIST.  This indicates that the user wrote
12754      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12755      use them later.  */
12756   if (TREE_CODE (code_type_node) == TREE_LIST)
12757     {
12758       attributes = TREE_PURPOSE (code_type_node);
12759       code_type_node = TREE_VALUE (code_type_node);
12760     }
12761
12762   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12763   switch (tag_code)
12764     {
12765     case record_type:
12766     case class_type:
12767       code = RECORD_TYPE;
12768       break;
12769     case union_type:
12770       code = UNION_TYPE;
12771       break;
12772     case enum_type:
12773       code = ENUMERAL_TYPE;
12774       break;
12775     default:
12776       my_friendly_abort (18);
12777     }
12778
12779   /* If a cross reference is requested, look up the type
12780      already defined for this tag and return it.  */
12781   if (TYPE_P (name))
12782     {
12783       t = name;
12784       name = TYPE_IDENTIFIER (t);
12785       got_type = 1;
12786     }
12787   else
12788     t = IDENTIFIER_TYPE_VALUE (name);
12789
12790   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12791   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12792     {
12793       static int explained;
12794
12795       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12796 to refer to the inherited type, say `%s %T::%T'%s",
12797                   tag_name (tag_code), name, tag_name (tag_code),
12798                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12799                   (!explained ? "\n\
12800 (names from dependent base classes are not visible to unqualified name lookup)"
12801                    : ""));
12802
12803       explained = 1;
12804     }
12805
12806   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12807       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12808     t = NULL_TREE;
12809
12810   if (! globalize)
12811     {
12812       /* If we know we are defining this tag, only look it up in
12813          this scope and don't try to find it as a type.  */
12814       ref = lookup_tag (code, name, b, 1);
12815     }
12816   else
12817     {
12818       if (t)
12819         {
12820           /* [dcl.type.elab] If the identifier resolves to a
12821              typedef-name or a template type-parameter, the
12822              elaborated-type-specifier is ill-formed.  */
12823           if (t != TYPE_MAIN_VARIANT (t)
12824               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12825             cp_pedwarn ("using typedef-name `%D' after `%s'",
12826                         TYPE_NAME (t), tag_name (tag_code));
12827           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12828             cp_error ("using template type parameter `%T' after `%s'",
12829                       t, tag_name (tag_code));
12830
12831           ref = t;
12832         }
12833       else
12834         ref = lookup_tag (code, name, b, 0);
12835
12836       if (! ref)
12837         {
12838           /* Try finding it as a type declaration.  If that wins,
12839              use it.  */
12840           ref = lookup_name (name, 1);
12841
12842           if (ref != NULL_TREE
12843               && processing_template_decl
12844               && DECL_CLASS_TEMPLATE_P (ref)
12845               && template_class_depth (current_class_type) == 0)
12846             /* Since GLOBALIZE is true, we're declaring a global
12847                template, so we want this type.  */
12848             ref = DECL_TEMPLATE_RESULT (ref);
12849
12850           if (ref && TREE_CODE (ref) == TYPE_DECL
12851               && TREE_CODE (TREE_TYPE (ref)) == code)
12852             ref = TREE_TYPE (ref);
12853           else
12854             ref = NULL_TREE;
12855         }
12856
12857       if (ref && current_class_type
12858           && template_class_depth (current_class_type)
12859           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12860         {
12861           /* Since GLOBALIZE is non-zero, we are not looking at a
12862              definition of this tag.  Since, in addition, we are currently
12863              processing a (member) template declaration of a template
12864              class, we must be very careful; consider:
12865
12866                template <class X>
12867                struct S1
12868
12869                template <class U>
12870                struct S2
12871                { template <class V>
12872                friend struct S1; };
12873
12874              Here, the S2::S1 declaration should not be confused with the
12875              outer declaration.  In particular, the inner version should
12876              have a template parameter of level 2, not level 1.  This
12877              would be particularly important if the member declaration
12878              were instead:
12879
12880                template <class V = U> friend struct S1;
12881
12882              say, when we should tsubst into `U' when instantiating
12883              S2.  On the other hand, when presented with:
12884
12885                  template <class T>
12886                  struct S1 {
12887                    template <class U>
12888                    struct S2 {};
12889                    template <class U>
12890                    friend struct S2;
12891                  };
12892
12893               we must find the inner binding eventually.  We
12894               accomplish this by making sure that the new type we
12895               create to represent this declaration has the right
12896               TYPE_CONTEXT.  */
12897           context = TYPE_CONTEXT (ref);
12898           ref = NULL_TREE;
12899         }
12900     }
12901
12902   if (! ref)
12903     {
12904       /* If no such tag is yet defined, create a forward-reference node
12905          and record it as the "definition".
12906          When a real declaration of this type is found,
12907          the forward-reference will be altered into a real type.  */
12908       if (code == ENUMERAL_TYPE)
12909         {
12910           cp_error ("use of enum `%#D' without previous declaration", name);
12911
12912           ref = make_node (ENUMERAL_TYPE);
12913
12914           /* Give the type a default layout like unsigned int
12915              to avoid crashing if it does not get defined.  */
12916           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12917           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12918           TYPE_USER_ALIGN (ref) = 0;
12919           TREE_UNSIGNED (ref) = 1;
12920           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12921           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12922           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12923
12924           /* Enable us to recognize when a type is created in class context.
12925              To do nested classes correctly, this should probably be cleared
12926              out when we leave this classes scope.  Currently this in only
12927              done in `start_enum'.  */
12928
12929           pushtag (name, ref, globalize);
12930         }
12931       else
12932         {
12933           struct binding_level *old_b = class_binding_level;
12934
12935           ref = make_aggr_type (code);
12936           TYPE_CONTEXT (ref) = context;
12937
12938 #ifdef NONNESTED_CLASSES
12939           /* Class types don't nest the way enums do.  */
12940           class_binding_level = (struct binding_level *)0;
12941 #endif
12942           pushtag (name, ref, globalize);
12943           class_binding_level = old_b;
12944         }
12945     }
12946   else
12947     {
12948       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12949         redeclare_class_template (ref, current_template_parms);
12950     }
12951
12952   /* Until the type is defined, tentatively accept whatever
12953      structure tag the user hands us.  */
12954   if (!COMPLETE_TYPE_P (ref)
12955       && ref != current_class_type
12956       /* Have to check this, in case we have contradictory tag info.  */
12957       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12958     {
12959       if (tag_code == class_type)
12960         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12961       else if (tag_code == record_type)
12962         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12963     }
12964
12965   TREE_TYPE (ref) = attributes;
12966
12967   return ref;
12968 }
12969
12970 tree
12971 xref_tag_from_type (old, id, globalize)
12972      tree old, id;
12973      int globalize;
12974 {
12975   tree code_type_node;
12976
12977   if (TREE_CODE (old) == RECORD_TYPE)
12978     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12979                       ? class_type_node : record_type_node);
12980   else
12981     code_type_node = union_type_node;
12982
12983   if (id == NULL_TREE)
12984     id = TYPE_IDENTIFIER (old);
12985
12986   return xref_tag (code_type_node, id, globalize);
12987 }
12988
12989 /* REF is a type (named NAME), for which we have just seen some
12990    baseclasses.  BINFO is a list of those baseclasses; the
12991    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12992    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12993    struct, or union.  */
12994
12995 void
12996 xref_basetypes (code_type_node, name, ref, binfo)
12997      tree code_type_node;
12998      tree name, ref;
12999      tree binfo;
13000 {
13001   /* In the declaration `A : X, Y, ... Z' we mark all the types
13002      (A, X, Y, ..., Z) so we can check for duplicates.  */
13003   tree binfos;
13004   tree base;
13005
13006   int i, len;
13007   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13008
13009   if (tag_code == union_type)
13010     {
13011       cp_error ("derived union `%T' invalid", ref);
13012       return;
13013     }
13014
13015   len = list_length (binfo);
13016
13017   /* First, make sure that any templates in base-classes are
13018      instantiated.  This ensures that if we call ourselves recursively
13019      we do not get confused about which classes are marked and which
13020      are not.  */
13021   for (base = binfo; base; base = TREE_CHAIN (base))
13022     complete_type (TREE_VALUE (base));
13023
13024   SET_CLASSTYPE_MARKED (ref);
13025   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13026
13027   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13028     {
13029       /* The base of a derived struct is public by default.  */
13030       int via_public
13031         = (TREE_PURPOSE (binfo) == access_public_node
13032            || TREE_PURPOSE (binfo) == access_public_virtual_node
13033            || (tag_code != class_type
13034                && (TREE_PURPOSE (binfo) == access_default_node
13035                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13036       int via_protected
13037         = (TREE_PURPOSE (binfo) == access_protected_node
13038            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13039       int via_virtual
13040         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13041            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13042            || TREE_PURPOSE (binfo) == access_public_virtual_node
13043            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13044       tree basetype = TREE_VALUE (binfo);
13045       tree base_binfo;
13046
13047       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13048         basetype = TREE_TYPE (basetype);
13049       if (!basetype
13050           || (TREE_CODE (basetype) != RECORD_TYPE
13051               && TREE_CODE (basetype) != TYPENAME_TYPE
13052               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13053               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13054         {
13055           cp_error ("base type `%T' fails to be a struct or class type",
13056                     TREE_VALUE (binfo));
13057           continue;
13058         }
13059
13060       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13061
13062       /* This code replaces similar code in layout_basetypes.
13063          We put the complete_type first for implicit `typename'.  */
13064       if (!COMPLETE_TYPE_P (basetype)
13065           && ! (current_template_parms && uses_template_parms (basetype)))
13066         {
13067           cp_error ("base class `%T' has incomplete type", basetype);
13068           continue;
13069         }
13070       else
13071         {
13072           if (CLASSTYPE_MARKED (basetype))
13073             {
13074               if (basetype == ref)
13075                 cp_error ("recursive type `%T' undefined", basetype);
13076               else
13077                 cp_error ("duplicate base type `%T' invalid", basetype);
13078               continue;
13079             }
13080
13081           if (TYPE_FOR_JAVA (basetype)
13082               && (current_lang_stack
13083                   == &VARRAY_TREE (current_lang_base, 0)))
13084             TYPE_FOR_JAVA (ref) = 1;
13085
13086           /* Note that the BINFO records which describe individual
13087              inheritances are *not* shared in the lattice!  They
13088              cannot be shared because a given baseclass may be
13089              inherited with different `accessibility' by different
13090              derived classes.  (Each BINFO record describing an
13091              individual inheritance contains flags which say what
13092              the `accessibility' of that particular inheritance is.)  */
13093
13094           base_binfo
13095             = make_binfo (size_zero_node, basetype,
13096                           CLASS_TYPE_P (basetype)
13097                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13098                           CLASS_TYPE_P (basetype)
13099                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13100
13101           TREE_VEC_ELT (binfos, i) = base_binfo;
13102           TREE_VIA_PUBLIC (base_binfo) = via_public;
13103           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13104           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13105           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13106
13107           /* We need to unshare the binfos now so that lookups during class
13108              definition work.  */
13109           unshare_base_binfos (base_binfo);
13110
13111           SET_CLASSTYPE_MARKED (basetype);
13112
13113           /* We are free to modify these bits because they are meaningless
13114              at top level, and BASETYPE is a top-level type.  */
13115           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13116             {
13117               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13118               /* Converting to a virtual base class requires looking
13119                  up the offset of the virtual base.  */
13120               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13121             }
13122
13123           if (CLASS_TYPE_P (basetype))
13124             {
13125               TYPE_HAS_NEW_OPERATOR (ref)
13126                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13127               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13128                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13129               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13130               /* If the base-class uses multiple inheritance, so do we.  */
13131               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13132                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13133               /* Likewise, if converting to a base of the base may require
13134                  code, then we may need to generate code to convert to a
13135                  base as well.  */
13136               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13137                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13138             }
13139
13140           i += 1;
13141         }
13142     }
13143   if (i)
13144     TREE_VEC_LENGTH (binfos) = i;
13145   else
13146     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13147
13148   if (i > 1)
13149     {
13150       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13151       /* If there is more than one non-empty they cannot be at the same
13152          address.  */
13153       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13154     }
13155
13156   /* Unmark all the types.  */
13157   while (--i >= 0)
13158     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13159   CLEAR_CLASSTYPE_MARKED (ref);
13160
13161   /* Now that we know all the base-classes, set up the list of virtual
13162      bases.  */
13163   get_vbase_types (ref);
13164 }
13165
13166 \f
13167 /* Begin compiling the definition of an enumeration type.
13168    NAME is its name (or null if anonymous).
13169    Returns the type object, as yet incomplete.
13170    Also records info about it so that build_enumerator
13171    may be used to declare the individual values as they are read.  */
13172
13173 tree
13174 start_enum (name)
13175      tree name;
13176 {
13177   register tree enumtype = NULL_TREE;
13178   struct binding_level *b = current_binding_level;
13179
13180   /* If this is the real definition for a previous forward reference,
13181      fill in the contents in the same object that used to be the
13182      forward reference.  */
13183
13184   if (name != NULL_TREE)
13185     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13186
13187   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13188     {
13189       cp_error ("multiple definition of `%#T'", enumtype);
13190       cp_error_at ("previous definition here", enumtype);
13191       /* Clear out TYPE_VALUES, and start again.  */
13192       TYPE_VALUES (enumtype) = NULL_TREE;
13193     }
13194   else
13195     {
13196       enumtype = make_node (ENUMERAL_TYPE);
13197       pushtag (name, enumtype, 0);
13198     }
13199
13200   if (current_class_type)
13201     TREE_ADDRESSABLE (b->tags) = 1;
13202
13203   GNU_xref_decl (current_function_decl, enumtype);
13204   return enumtype;
13205 }
13206
13207 /* After processing and defining all the values of an enumeration type,
13208    install their decls in the enumeration type and finish it off.
13209    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13210    Returns ENUMTYPE.  */
13211
13212 tree
13213 finish_enum (enumtype)
13214      tree enumtype;
13215 {
13216   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13217   /* Calculate the maximum value of any enumerator in this type.  */
13218
13219   tree values = TYPE_VALUES (enumtype);
13220   if (values)
13221     {
13222       tree pair;
13223
13224       for (pair = values; pair; pair = TREE_CHAIN (pair))
13225         {
13226           tree decl;
13227           tree value;
13228
13229           /* The TREE_VALUE is a CONST_DECL for this enumeration
13230              constant.  */
13231           decl = TREE_VALUE (pair);
13232
13233           /* [dcl.enum]
13234
13235              Following the closing brace of an enum-specifier, each
13236              enumerator has the type of its enumeration.  Prior to the
13237              closing brace, the type of each enumerator is the type of
13238              its initializing value.  */
13239           TREE_TYPE (decl) = enumtype;
13240
13241           /* The DECL_INITIAL will be NULL if we are processing a
13242              template declaration and this enumeration constant had no
13243              explicit initializer.  */
13244           value = DECL_INITIAL (decl);
13245           if (value && !processing_template_decl)
13246             {
13247               /* Set the TREE_TYPE for the VALUE as well.  That's so
13248                  that when we call decl_constant_value we get an
13249                  entity of the right type (but with the constant
13250                  value).  Since we shouldn't ever call
13251                  decl_constant_value on a template type, there's no
13252                  reason to do that when processing_template_decl.
13253                  And, if the expression is something like a
13254                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13255                  wreak havoc on the intended type of the expression.
13256
13257                  Of course, there's also no point in trying to compute
13258                  minimum or maximum values if we're in a template.  */
13259               TREE_TYPE (value) = enumtype;
13260
13261               if (!minnode)
13262                 minnode = maxnode = value;
13263               else if (tree_int_cst_lt (maxnode, value))
13264                 maxnode = value;
13265               else if (tree_int_cst_lt (value, minnode))
13266                 minnode = value;
13267             }
13268
13269           if (processing_template_decl)
13270             /* If this is just a template, leave the CONST_DECL
13271                alone.  That way tsubst_copy will find CONST_DECLs for
13272                CONST_DECLs, and not INTEGER_CSTs.  */
13273             ;
13274           else
13275             /* In the list we're building up, we want the enumeration
13276                values, not the CONST_DECLs.  */
13277             TREE_VALUE (pair) = value;
13278         }
13279     }
13280   else
13281     maxnode = minnode = integer_zero_node;
13282
13283   TYPE_VALUES (enumtype) = nreverse (values);
13284
13285   if (processing_template_decl)
13286     {
13287       tree scope = current_scope ();
13288       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13289         add_stmt (build_min (TAG_DEFN, enumtype));
13290     }
13291   else
13292     {
13293       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13294       int lowprec = min_precision (minnode, unsignedp);
13295       int highprec = min_precision (maxnode, unsignedp);
13296       int precision = MAX (lowprec, highprec);
13297       tree tem;
13298
13299       TYPE_SIZE (enumtype) = NULL_TREE;
13300
13301       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13302
13303       TYPE_PRECISION (enumtype) = precision;
13304       if (unsignedp)
13305         fixup_unsigned_type (enumtype);
13306       else
13307         fixup_signed_type (enumtype);
13308
13309       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13310         /* Use the width of the narrowest normal C type which is wide
13311            enough.  */
13312         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13313                                                     (precision, 1));
13314       else
13315         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13316
13317       TYPE_SIZE (enumtype) = 0;
13318       layout_type (enumtype);
13319
13320       /* Fix up all variant types of this enum type.  */
13321       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13322            tem = TYPE_NEXT_VARIANT (tem))
13323         {
13324           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13325           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13326           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13327           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13328           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13329           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13330           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13331           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13332           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13333           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13334         }
13335
13336       /* Finish debugging output for this type.  */
13337       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13338     }
13339
13340   return enumtype;
13341 }
13342
13343 /* Build and install a CONST_DECL for an enumeration constant of the
13344    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13345    Assignment of sequential values by default is handled here.  */
13346
13347 void
13348 build_enumerator (name, value, enumtype)
13349      tree name;
13350      tree value;
13351      tree enumtype;
13352 {
13353   tree decl;
13354   tree context;
13355   tree type;
13356   tree values;
13357
13358   /* Remove no-op casts from the value.  */
13359   if (value)
13360     STRIP_TYPE_NOPS (value);
13361
13362   if (! processing_template_decl)
13363     {
13364       /* Validate and default VALUE.  */
13365       if (value != NULL_TREE)
13366         {
13367           value = decl_constant_value (value);
13368
13369           if (TREE_CODE (value) == INTEGER_CST)
13370             {
13371               value = default_conversion (value);
13372               constant_expression_warning (value);
13373             }
13374           else
13375             {
13376               cp_error ("enumerator value for `%D' not integer constant", name);
13377               value = NULL_TREE;
13378             }
13379         }
13380
13381       /* Default based on previous value.  */
13382       if (value == NULL_TREE && ! processing_template_decl)
13383         {
13384           tree prev_value;
13385
13386           if (TYPE_VALUES (enumtype))
13387             {
13388               /* The next value is the previous value ... */
13389               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13390               /* ... plus one.  */
13391               value = cp_build_binary_op (PLUS_EXPR,
13392                                           prev_value,
13393                                           integer_one_node);
13394
13395               if (tree_int_cst_lt (value, prev_value))
13396                 cp_error ("overflow in enumeration values at `%D'", name);
13397             }
13398           else
13399             value = integer_zero_node;
13400         }
13401
13402       /* Remove no-op casts from the value.  */
13403       if (value)
13404         STRIP_TYPE_NOPS (value);
13405 #if 0
13406       /* To fix MAX_VAL enum consts. (bkoz)  */
13407       TREE_TYPE (value) = integer_type_node;
13408 #endif
13409     }
13410
13411   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13412      Even in other cases, we will later (in finish_enum) be setting
13413      the type of VALUE.  But, we don't need to make a copy if this
13414      VALUE is one of the enumeration constants for this same
13415      enumeration type.  */
13416   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13417     if (TREE_VALUE (values) == value)
13418       break;
13419   /* If we didn't break out of the loop, then we do need a copy.  */
13420   if (!values && value)
13421     value = copy_node (value);
13422
13423   /* C++ associates enums with global, function, or class declarations.  */
13424   context = current_scope ();
13425
13426   /* Build the actual enumeration constant.  Note that the enumeration
13427     constants have the type of their initializers until the
13428     enumeration is complete:
13429
13430       [ dcl.enum ]
13431
13432       Following the closing brace of an enum-specifier, each enumer-
13433       ator has the type of its enumeration.  Prior to the closing
13434       brace, the type of each enumerator is the type of its
13435       initializing value.
13436
13437     In finish_enum we will reset the type.  Of course, if we're
13438     processing a template, there may be no value.   */
13439   type = value ? TREE_TYPE (value) : NULL_TREE;
13440
13441   if (context && context == current_class_type)
13442     /* This enum declaration is local to the class.  We need the full
13443        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13444     decl = build_lang_decl (CONST_DECL, name, type);
13445   else
13446     /* It's a global enum, or it's local to a function.  (Note local to
13447       a function could mean local to a class method.  */
13448     decl = build_decl (CONST_DECL, name, type);
13449
13450   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13451   DECL_INITIAL (decl) = value;
13452   TREE_READONLY (decl) = 1;
13453
13454   if (context && context == current_class_type)
13455     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13456       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13457       things like `S::i' later.)  */
13458     finish_member_declaration (decl);
13459   else
13460     {
13461       pushdecl (decl);
13462       GNU_xref_decl (current_function_decl, decl);
13463     }
13464
13465   /* Add this enumeration constant to the list for this type.  */
13466   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13467 }
13468
13469 \f
13470 /* We're defining DECL.  Make sure that it's type is OK.  */
13471
13472 static void
13473 check_function_type (decl, current_function_parms)
13474      tree decl;
13475      tree current_function_parms;
13476 {
13477   tree fntype = TREE_TYPE (decl);
13478   tree return_type = complete_type (TREE_TYPE (fntype));
13479
13480   /* In a function definition, arg types must be complete.  */
13481   require_complete_types_for_parms (current_function_parms);
13482
13483   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13484     {
13485       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13486
13487       /* Make it return void instead, but don't change the
13488          type of the DECL_RESULT, in case we have a named return value.  */
13489       if (TREE_CODE (fntype) == METHOD_TYPE)
13490         {
13491           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13492           TREE_TYPE (decl)
13493             = build_cplus_method_type (ctype,
13494                                        void_type_node,
13495                                        FUNCTION_ARG_CHAIN (decl));
13496         }
13497       else
13498         TREE_TYPE (decl)
13499           = build_function_type (void_type_node,
13500                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13501       TREE_TYPE (decl)
13502         = build_exception_variant (fntype,
13503                                    TYPE_RAISES_EXCEPTIONS (fntype));
13504     }
13505   else
13506     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13507 }
13508
13509 /* Create the FUNCTION_DECL for a function definition.
13510    DECLSPECS and DECLARATOR are the parts of the declaration;
13511    they describe the function's name and the type it returns,
13512    but twisted together in a fashion that parallels the syntax of C.
13513
13514    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13515    DECLARATOR is really the DECL for the function we are about to
13516    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13517    indicating that the function is an inline defined in-class.
13518
13519    This function creates a binding context for the function body
13520    as well as setting up the FUNCTION_DECL in current_function_decl.
13521
13522    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13523    (it defines a datum instead), we return 0, which tells
13524    yyparse to report a parse error.
13525
13526    For C++, we must first check whether that datum makes any sense.
13527    For example, "class A local_a(1,2);" means that variable local_a
13528    is an aggregate of type A, which should have a constructor
13529    applied to it with the argument list [1, 2].  */
13530
13531 int
13532 start_function (declspecs, declarator, attrs, flags)
13533      tree declspecs, declarator, attrs;
13534      int flags;
13535 {
13536   tree decl1;
13537   tree ctype = NULL_TREE;
13538   tree fntype;
13539   tree restype;
13540   extern int have_extern_spec;
13541   extern int used_extern_spec;
13542   int doing_friend = 0;
13543   struct binding_level *bl;
13544   tree current_function_parms;
13545
13546   /* Sanity check.  */
13547   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13548   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13549
13550   /* This should only be done once on the top most decl.  */
13551   if (have_extern_spec && !used_extern_spec)
13552     {
13553       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13554       used_extern_spec = 1;
13555     }
13556
13557   if (flags & SF_PRE_PARSED)
13558     {
13559       decl1 = declarator;
13560
13561       fntype = TREE_TYPE (decl1);
13562       if (TREE_CODE (fntype) == METHOD_TYPE)
13563         ctype = TYPE_METHOD_BASETYPE (fntype);
13564
13565       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13566          the (lexical) scope of the class in which it is defined.  */
13567       if (!ctype && DECL_FRIEND_P (decl1))
13568         {
13569           ctype = DECL_FRIEND_CONTEXT (decl1);
13570
13571           /* CTYPE could be null here if we're dealing with a template;
13572              for example, `inline friend float foo()' inside a template
13573              will have no CTYPE set.  */
13574           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13575             ctype = NULL_TREE;
13576           else
13577             doing_friend = 1;
13578         }
13579
13580       last_function_parms = DECL_ARGUMENTS (decl1);
13581       last_function_parm_tags = NULL_TREE;
13582     }
13583   else
13584     {
13585       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13586       /* If the declarator is not suitable for a function definition,
13587          cause a syntax error.  */
13588       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13589
13590       fntype = TREE_TYPE (decl1);
13591
13592       restype = TREE_TYPE (fntype);
13593       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13594         {
13595           cp_error ("semicolon missing after declaration of `%#T'", restype);
13596           shadow_tag (build_tree_list (NULL_TREE, restype));
13597           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13598           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13599             fntype = build_function_type (integer_type_node,
13600                                           TYPE_ARG_TYPES (fntype));
13601           else
13602             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13603                                               integer_type_node,
13604                                               TYPE_ARG_TYPES (fntype));
13605           TREE_TYPE (decl1) = fntype;
13606         }
13607
13608       if (TREE_CODE (fntype) == METHOD_TYPE)
13609         ctype = TYPE_METHOD_BASETYPE (fntype);
13610       else if (DECL_MAIN_P (decl1))
13611         {
13612           /* If this doesn't return integer_type, complain.  */
13613           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13614             {
13615               if (pedantic || warn_return_type)
13616                 pedwarn ("return type for `main' changed to `int'");
13617               TREE_TYPE (decl1) = fntype = default_function_type;
13618             }
13619         }
13620     }
13621
13622   /* Sometimes we don't notice that a function is a static member, and
13623      build a METHOD_TYPE for it.  Fix that up now.  */
13624   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13625       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13626     {
13627       revert_static_member_fn (decl1);
13628       last_function_parms = TREE_CHAIN (last_function_parms);
13629       ctype = NULL_TREE;
13630     }
13631
13632   /* Warn if function was previously implicitly declared
13633      (but not if we warned then).  */
13634   if (! warn_implicit
13635       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13636     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13637
13638   /* Set up current_class_type, and enter the scope of the class, if
13639      appropriate.  */
13640   if (ctype)
13641     push_nested_class (ctype, 1);
13642   else if (DECL_STATIC_FUNCTION_P (decl1))
13643     push_nested_class (DECL_CONTEXT (decl1), 2);
13644
13645   /* Now that we have entered the scope of the class, we must restore
13646      the bindings for any template parameters surrounding DECL1, if it
13647      is an inline member template.  (Order is important; consider the
13648      case where a template parameter has the same name as a field of
13649      the class.)  It is not until after this point that
13650      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13651   if (flags & SF_INCLASS_INLINE)
13652     maybe_begin_member_template_processing (decl1);
13653
13654   /* Effective C++ rule 15.  */
13655   if (warn_ecpp
13656       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13657       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13658     cp_warning ("`operator=' should return a reference to `*this'");
13659
13660   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13661      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13662   if (!DECL_INITIAL (decl1))
13663     DECL_INITIAL (decl1) = error_mark_node;
13664
13665 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13666   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13667 #endif
13668
13669   /* This function exists in static storage.
13670      (This does not mean `static' in the C sense!)  */
13671   TREE_STATIC (decl1) = 1;
13672
13673   /* We must call push_template_decl after current_class_type is set
13674      up.  (If we are processing inline definitions after exiting a
13675      class scope, current_class_type will be NULL_TREE until set above
13676      by push_nested_class.)  */
13677   if (processing_template_decl)
13678     decl1 = push_template_decl (decl1);
13679
13680   /* We are now in the scope of the function being defined.  */
13681   current_function_decl = decl1;
13682
13683   /* Save the parm names or decls from this function's declarator
13684      where store_parm_decls will find them.  */
13685   current_function_parms = last_function_parms;
13686   current_function_parm_tags = last_function_parm_tags;
13687
13688   /* Make sure the parameter and return types are reasonable.  When
13689      you declare a function, these types can be incomplete, but they
13690      must be complete when you define the function.  */
13691   if (! processing_template_decl)
13692     check_function_type (decl1, current_function_parms);
13693
13694   /* Build the return declaration for the function.  */
13695   restype = TREE_TYPE (fntype);
13696   if (!processing_template_decl)
13697     {
13698       if (!DECL_RESULT (decl1))
13699         {
13700           DECL_RESULT (decl1)
13701             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13702           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13703                                       DECL_RESULT (decl1));
13704         }
13705     }
13706   else
13707     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13708     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13709
13710   /* Initialize RTL machinery.  We cannot do this until
13711      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13712      even when processing a template; this is how we get
13713      CFUN set up, and our per-function variables initialized.  */
13714   bl = current_binding_level;
13715   init_function_start (decl1, input_filename, lineno);
13716   current_binding_level = bl;
13717
13718   /* Even though we're inside a function body, we still don't want to
13719      call expand_expr to calculate the size of a variable-sized array.
13720      We haven't necessarily assigned RTL to all variables yet, so it's
13721      not safe to try to expand expressions involving them.  */
13722   immediate_size_expand = 0;
13723   cfun->x_dont_save_pending_sizes_p = 1;
13724
13725   /* Start the statement-tree, start the tree now.  */
13726   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13727
13728   /* Let the user know we're compiling this function.  */
13729   announce_function (decl1);
13730
13731   /* Record the decl so that the function name is defined.
13732      If we already have a decl for this name, and it is a FUNCTION_DECL,
13733      use the old decl.  */
13734   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13735     {
13736       /* A specialization is not used to guide overload resolution.  */
13737       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13738           && ! DECL_FUNCTION_MEMBER_P (decl1))
13739         decl1 = pushdecl (decl1);
13740       else
13741         {
13742           /* We need to set the DECL_CONTEXT. */
13743           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13744             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13745           /* And make sure we have enough default args.  */
13746           check_default_args (decl1);
13747         }
13748       fntype = TREE_TYPE (decl1);
13749     }
13750
13751   /* Reset these in case the call to pushdecl changed them.  */
13752   current_function_decl = decl1;
13753   cfun->decl = decl1;
13754
13755   /* If we are (erroneously) defining a function that we have already
13756      defined before, wipe out what we knew before.  */
13757   if (!DECL_PENDING_INLINE_P (decl1)
13758       && DECL_SAVED_FUNCTION_DATA (decl1))
13759     {
13760       free (DECL_SAVED_FUNCTION_DATA (decl1));
13761       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13762     }
13763
13764   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13765     {
13766       /* We know that this was set up by `grokclassfn'.  We do not
13767          wait until `store_parm_decls', since evil parse errors may
13768          never get us to that point.  Here we keep the consistency
13769          between `current_class_type' and `current_class_ptr'.  */
13770       tree t = DECL_ARGUMENTS (decl1);
13771
13772       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13773                           162);
13774       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13775                           19990811);
13776
13777       cp_function_chain->x_current_class_ref
13778         = build_indirect_ref (t, NULL_PTR);
13779       cp_function_chain->x_current_class_ptr = t;
13780
13781       /* Constructors and destructors need to know whether they're "in
13782          charge" of initializing virtual base classes.  */
13783       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13784         current_in_charge_parm = TREE_CHAIN (t);
13785     }
13786
13787   if (DECL_INTERFACE_KNOWN (decl1))
13788     {
13789       tree ctx = decl_function_context (decl1);
13790
13791       if (DECL_NOT_REALLY_EXTERN (decl1))
13792         DECL_EXTERNAL (decl1) = 0;
13793
13794       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13795           && TREE_PUBLIC (ctx))
13796         /* This is a function in a local class in an extern inline
13797            function.  */
13798         comdat_linkage (decl1);
13799     }
13800   /* If this function belongs to an interface, it is public.
13801      If it belongs to someone else's interface, it is also external.
13802      This only affects inlines and template instantiations.  */
13803   else if (interface_unknown == 0
13804            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13805                || flag_alt_external_templates))
13806     {
13807       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13808           || processing_template_decl)
13809         {
13810           DECL_EXTERNAL (decl1)
13811             = (interface_only
13812                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13813                    && !DECL_VINDEX (decl1)));
13814
13815           /* For WIN32 we also want to put these in linkonce sections.  */
13816           maybe_make_one_only (decl1);
13817         }
13818       else
13819         DECL_EXTERNAL (decl1) = 0;
13820       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13821       DECL_INTERFACE_KNOWN (decl1) = 1;
13822     }
13823   else if (interface_unknown && interface_only
13824            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13825                || flag_alt_external_templates))
13826     {
13827       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13828          interface, we will have interface_only set but not
13829          interface_known.  In that case, we don't want to use the normal
13830          heuristics because someone will supply a #pragma implementation
13831          elsewhere, and deducing it here would produce a conflict.  */
13832       comdat_linkage (decl1);
13833       DECL_EXTERNAL (decl1) = 0;
13834       DECL_INTERFACE_KNOWN (decl1) = 1;
13835       DECL_DEFER_OUTPUT (decl1) = 1;
13836     }
13837   else
13838     {
13839       /* This is a definition, not a reference.
13840          So clear DECL_EXTERNAL.  */
13841       DECL_EXTERNAL (decl1) = 0;
13842
13843       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13844           && ! DECL_INTERFACE_KNOWN (decl1)
13845           /* Don't try to defer nested functions for now.  */
13846           && ! decl_function_context (decl1))
13847         DECL_DEFER_OUTPUT (decl1) = 1;
13848       else
13849         DECL_INTERFACE_KNOWN (decl1) = 1;
13850     }
13851
13852   pushlevel (0);
13853   current_binding_level->parm_flag = 1;
13854
13855   if (attrs)
13856     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13857
13858   /* We need to do this even if we aren't expanding yet so that
13859      assemble_external works.  */
13860   make_function_rtl (decl1);
13861
13862   /* Promote the value to int before returning it.  */
13863   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13864     restype = type_promotes_to (restype);
13865
13866   /* If this fcn was already referenced via a block-scope `extern' decl
13867      (or an implicit decl), propagate certain information about the usage.  */
13868   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13869     TREE_ADDRESSABLE (decl1) = 1;
13870
13871   if (DECL_RESULT (decl1) == NULL_TREE)
13872     {
13873       DECL_RESULT (decl1)
13874         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13875       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13876       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13877     }
13878
13879   ++function_depth;
13880
13881   if (DECL_DESTRUCTOR_P (decl1))
13882     {
13883       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13884       DECL_CONTEXT (dtor_label) = current_function_decl;
13885     }
13886   /* Under the old ABI we return `this' from constructors, so we make
13887      ordinary `return' statements in constructors jump to CTOR_LABEL;
13888      from there we return `this'.  Under the new ABI, we don't bother
13889      with any of this.  By not setting CTOR_LABEL the remainder of the
13890      machinery is automatically disabled.  */
13891   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13892     {
13893       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13894       DECL_CONTEXT (ctor_label) = current_function_decl;
13895     }
13896
13897   store_parm_decls (current_function_parms);
13898
13899   return 1;
13900 }
13901 \f
13902 /* Store the parameter declarations into the current function declaration.
13903    This is called after parsing the parameter declarations, before
13904    digesting the body of the function.
13905
13906    Also install to binding contour return value identifier, if any.  */
13907
13908 static void
13909 store_parm_decls (current_function_parms)
13910      tree current_function_parms;
13911 {
13912   register tree fndecl = current_function_decl;
13913   register tree parm;
13914   int parms_have_cleanups = 0;
13915   tree cleanups = NULL_TREE;
13916
13917   /* This is a list of types declared among parms in a prototype.  */
13918   tree parmtags = current_function_parm_tags;
13919
13920   /* This is a chain of any other decls that came in among the parm
13921      declarations.  If a parm is declared with  enum {foo, bar} x;
13922      then CONST_DECLs for foo and bar are put here.  */
13923   tree nonparms = NULL_TREE;
13924
13925   if (current_function_parms)
13926     {
13927       /* This case is when the function was defined with an ANSI prototype.
13928          The parms already have decls, so we need not do anything here
13929          except record them as in effect
13930          and complain if any redundant old-style parm decls were written.  */
13931
13932       tree specparms = current_function_parms;
13933       tree next;
13934
13935       /* Must clear this because it might contain TYPE_DECLs declared
13936              at class level.  */
13937       storedecls (NULL_TREE);
13938
13939       /* If we're doing semantic analysis, then we'll call pushdecl
13940              for each of these.  We must do them in reverse order so that
13941              they end in the correct forward order.  */
13942       specparms = nreverse (specparms);
13943
13944       for (parm = specparms; parm; parm = next)
13945         {
13946           next = TREE_CHAIN (parm);
13947           if (TREE_CODE (parm) == PARM_DECL)
13948             {
13949               tree cleanup;
13950
13951               if (DECL_NAME (parm) == NULL_TREE
13952                   || TREE_CODE (parm) != VOID_TYPE)
13953                 pushdecl (parm);
13954               else
13955                 cp_error ("parameter `%D' declared void", parm);
13956
13957               cleanup = (processing_template_decl
13958                          ? NULL_TREE
13959                          : maybe_build_cleanup (parm));
13960
13961               if (cleanup)
13962                 cleanups = tree_cons (parm, cleanup, cleanups);
13963             }
13964           else
13965             {
13966               /* If we find an enum constant or a type tag,
13967                  put it aside for the moment.  */
13968               TREE_CHAIN (parm) = NULL_TREE;
13969               nonparms = chainon (nonparms, parm);
13970             }
13971         }
13972
13973       /* Get the decls in their original chain order and record in the
13974          function.  This is all and only the PARM_DECLs that were
13975          pushed into scope by the loop above.  */
13976       DECL_ARGUMENTS (fndecl) = getdecls ();
13977       storetags (chainon (parmtags, gettags ()));
13978     }
13979   else
13980     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13981
13982   /* Now store the final chain of decls for the arguments
13983      as the decl-chain of the current lexical scope.
13984      Put the enumerators in as well, at the front so that
13985      DECL_ARGUMENTS is not modified.  */
13986   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13987
13988   /* Now that we have initialized the parms, we can start their
13989      cleanups.  We cannot do this before, since expand_decl_cleanup
13990      should not be called before the parm can be used.  */
13991   while (cleanups)
13992     {
13993       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13994                            TREE_VALUE (cleanups));
13995       cleanups = TREE_CHAIN (cleanups);
13996     }
13997
13998   /* Create a binding contour which can be used to catch
13999      cleanup-generated temporaries.  */
14000   if (parms_have_cleanups)
14001     pushlevel (0);
14002
14003   /* Do the starting of the exception specifications, if we have any.  */
14004   if (flag_exceptions && !processing_template_decl
14005       && flag_enforce_eh_specs
14006       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14007     current_eh_spec_try_block = expand_start_eh_spec ();
14008 }
14009
14010 \f
14011 /* We have finished doing semantic analysis on DECL, but have not yet
14012    generated RTL for its body.  Save away our current state, so that
14013    when we want to generate RTL later we know what to do.  */
14014
14015 static void
14016 save_function_data (decl)
14017      tree decl;
14018 {
14019   struct cp_language_function *f;
14020
14021   /* Save the language-specific per-function data so that we can
14022      get it back when we really expand this function.  */
14023   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14024                       19990908);
14025
14026   /* Make a copy.  */
14027   f = ((struct cp_language_function *)
14028        xmalloc (sizeof (struct cp_language_function)));
14029   bcopy ((char *) cp_function_chain, (char *) f,
14030          sizeof (struct cp_language_function));
14031   DECL_SAVED_FUNCTION_DATA (decl) = f;
14032
14033   /* Clear out the bits we don't need.  */
14034   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14035   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14036   f->x_named_label_uses = NULL;
14037   f->bindings = NULL;
14038
14039   /* When we get back here again, we will be expanding.  */
14040   f->x_expanding_p = 1;
14041
14042   /* If we've already decided that we cannot inline this function, we
14043      must remember that fact when we actually go to expand the
14044      function.  */
14045   f->cannot_inline = current_function_cannot_inline;
14046 }
14047
14048 /* At the end of every constructor we generate to code to return
14049    `this'.  Do that now.  */
14050
14051 static void
14052 finish_constructor_body ()
14053 {
14054   /* Any return from a constructor will end up here.  */
14055   if (ctor_label)
14056     add_stmt (build_stmt (LABEL_STMT, ctor_label));
14057
14058   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14059      generate the return, rather than a goto to CTOR_LABEL.  */
14060   ctor_label = NULL_TREE;
14061   /* In check_return_expr we translate an empty return from a
14062      constructor to a return of `this'.  */
14063   finish_return_stmt (NULL_TREE);
14064   /* Mark the end of the constructor.  */
14065   add_stmt (build_stmt (CTOR_STMT));
14066 }
14067
14068 /* At the end of every destructor we generate code to restore virtual
14069    function tables to the values desired by base classes and to call
14070    to base class destructors.  Do that now.  */
14071
14072 static void
14073 finish_destructor_body ()
14074 {
14075   tree compound_stmt;
14076   tree virtual_size;
14077   tree exprstmt;
14078   tree if_stmt;
14079
14080   /* Create a block to contain all the extra code.  */
14081   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14082
14083   /* Any return from a destructor will end up here.  */
14084   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14085
14086   /* Generate the code to call destructor on base class.  If this
14087      destructor belongs to a class with virtual functions, then set
14088      the virtual function table pointer to represent the type of our
14089      base class.  */
14090
14091   /* This side-effect makes call to `build_delete' generate the code
14092      we have to have at the end of this destructor.  `build_delete'
14093      will set the flag again.  */
14094   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14095
14096   exprstmt = build_delete (current_class_type,
14097                            current_class_ref,
14098                            sfk_base_destructor,
14099                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14100                            0);
14101
14102   if (exprstmt != error_mark_node
14103       && (TREE_CODE (exprstmt) != NOP_EXPR
14104           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14105           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14106     {
14107       if (exprstmt != void_zero_node)
14108         /* Don't call `expand_expr_stmt' if we're not going to do
14109            anything, since -Wall will give a diagnostic.  */
14110         finish_expr_stmt (exprstmt);
14111
14112       /* Run destructors for all virtual baseclasses.  */
14113       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14114         {
14115           tree vbases;
14116           tree if_stmt;
14117
14118           if_stmt = begin_if_stmt ();
14119           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14120                                       current_in_charge_parm,
14121                                       integer_two_node),
14122                                if_stmt);
14123
14124           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14125           /* The CLASSTYPE_VBASECLASSES list is in initialization
14126              order, so we have to march through it in reverse order.  */
14127           for (vbases = nreverse (copy_list (vbases));
14128                vbases;
14129                vbases = TREE_CHAIN (vbases))
14130             {
14131               tree vbase = TREE_VALUE (vbases);
14132
14133               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14134                 {
14135                   tree vb = get_vbase
14136                     (BINFO_TYPE (vbase),
14137                      TYPE_BINFO (current_class_type));
14138                   finish_expr_stmt
14139                     (build_scoped_method_call
14140                      (current_class_ref, vb, base_dtor_identifier,
14141                       NULL_TREE));
14142                 }
14143             }
14144
14145           finish_then_clause (if_stmt);
14146           finish_if_stmt ();
14147         }
14148     }
14149
14150   virtual_size = c_sizeof (current_class_type);
14151
14152   /* At the end, call delete if that's what's requested.  */
14153
14154   /* FDIS sez: At the point of definition of a virtual destructor
14155      (including an implicit definition), non-placement operator delete
14156      shall be looked up in the scope of the destructor's class and if
14157      found shall be accessible and unambiguous.
14158
14159      This is somewhat unclear, but I take it to mean that if the class
14160      only defines placement deletes we don't do anything here.  So we
14161      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14162      they ever try to delete one of these.  */
14163   exprstmt = build_op_delete_call
14164     (DELETE_EXPR, current_class_ptr, virtual_size,
14165      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14166
14167   if_stmt = begin_if_stmt ();
14168   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14169                               current_in_charge_parm,
14170                               integer_one_node),
14171                        if_stmt);
14172   finish_expr_stmt (exprstmt);
14173   finish_then_clause (if_stmt);
14174   finish_if_stmt ();
14175
14176   /* Close the block we started above.  */
14177   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14178 }
14179
14180 /* Finish up a function declaration and compile that function
14181    all the way to assembler language output.  The free the storage
14182    for the function definition.
14183
14184    FLAGS is a bitwise or of the following values:
14185      1 - CALL_POPLEVEL
14186        An extra call to poplevel (and expand_end_bindings) must be
14187        made to take care of the binding contour for the base
14188        initializers.  This is only relevant for constructors.
14189      2 - INCLASS_INLINE
14190        We just finished processing the body of an in-class inline
14191        function definition.  (This processing will have taken place
14192        after the class definition is complete.)  */
14193
14194 tree
14195 finish_function (flags)
14196      int flags;
14197 {
14198   register tree fndecl = current_function_decl;
14199   tree fntype, ctype = NULL_TREE;
14200   int call_poplevel = (flags & 1) != 0;
14201   int inclass_inline = (flags & 2) != 0;
14202   int nested;
14203
14204   /* When we get some parse errors, we can end up without a
14205      current_function_decl, so cope.  */
14206   if (fndecl == NULL_TREE)
14207     return error_mark_node;
14208
14209   nested = function_depth > 1;
14210   fntype = TREE_TYPE (fndecl);
14211
14212   /*  TREE_READONLY (fndecl) = 1;
14213       This caused &foo to be of type ptr-to-const-function
14214       which then got a warning when stored in a ptr-to-function variable.  */
14215
14216   my_friendly_assert (building_stmt_tree (), 20000911);
14217
14218   /* For a cloned function, we've already got all the code we need;
14219      there's no need to add any extra bits.  */
14220   if (!DECL_CLONED_FUNCTION_P (fndecl))
14221     {
14222       if (DECL_CONSTRUCTOR_P (fndecl))
14223         {
14224           finish_constructor_body ();
14225           if (call_poplevel)
14226             do_poplevel ();
14227         }
14228       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14229         finish_destructor_body ();
14230       else if (DECL_MAIN_P (fndecl))
14231         {
14232           /* Make it so that `main' always returns 0 by default.  */
14233 #ifdef VMS
14234           finish_return_stmt (integer_one_node);
14235 #else
14236           finish_return_stmt (integer_zero_node);
14237 #endif
14238         }
14239
14240       /* Finish dealing with exception specifiers.  */
14241       if (flag_exceptions && !processing_template_decl
14242           && flag_enforce_eh_specs
14243           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14244         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14245                             (TREE_TYPE (current_function_decl)),
14246                             current_eh_spec_try_block);
14247     }
14248
14249   /* If we're saving up tree structure, tie off the function now.  */
14250   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14251
14252   /* This must come after expand_function_end because cleanups might
14253      have declarations (from inline functions) that need to go into
14254      this function's blocks.  */
14255   if (current_binding_level->parm_flag != 1)
14256     my_friendly_abort (122);
14257   poplevel (1, 0, 1);
14258
14259   /* Remember that we were in class scope.  */
14260   if (current_class_name)
14261     ctype = current_class_type;
14262
14263   /* Must mark the RESULT_DECL as being in this function.  */
14264   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14265
14266   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14267      to the FUNCTION_DECL node itself.  */
14268   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14269
14270   /* Save away current state, if appropriate.  */
14271   if (!processing_template_decl)
14272     save_function_data (fndecl);
14273
14274   /* If this function calls `setjmp' it cannot be inlined.  When
14275      `longjmp' is called it is not guaranteed to restore the value of
14276      local variables that have been modified since the call to
14277      `setjmp'.  So, if were to inline this function into some caller
14278      `c', then when we `longjmp', we might not restore all variables
14279      in `c'.  (It might seem, at first blush, that there's no way for
14280      this function to modify local variables in `c', but their
14281      addresses may have been stored somewhere accessible to this
14282      function.)  */
14283   if (!processing_template_decl && calls_setjmp_p (fndecl))
14284     DECL_UNINLINABLE (fndecl) = 1;
14285
14286   /* Clear out memory we no longer need.  */
14287   free_after_parsing (cfun);
14288   /* Since we never call rest_of_compilation, we never clear
14289      CFUN.  Do so explicitly.  */
14290   free_after_compilation (cfun);
14291   cfun = NULL;
14292
14293   /* If this is a in-class inline definition, we may have to pop the
14294      bindings for the template parameters that we added in
14295      maybe_begin_member_template_processing when start_function was
14296      called.  */
14297   if (inclass_inline)
14298     maybe_end_member_template_processing ();
14299
14300   /* Leave the scope of the class.  */
14301   if (ctype)
14302     pop_nested_class ();
14303
14304   --function_depth;
14305
14306   /* Clean up.  */
14307   if (! nested)
14308     /* Let the error reporting routines know that we're outside a
14309        function.  For a nested function, this value is used in
14310        pop_cp_function_context and then reset via pop_function_context.  */
14311     current_function_decl = NULL_TREE;
14312
14313   return fndecl;
14314 }
14315 \f
14316 /* Create the FUNCTION_DECL for a function definition.
14317    DECLSPECS and DECLARATOR are the parts of the declaration;
14318    they describe the return type and the name of the function,
14319    but twisted together in a fashion that parallels the syntax of C.
14320
14321    This function creates a binding context for the function body
14322    as well as setting up the FUNCTION_DECL in current_function_decl.
14323
14324    Returns a FUNCTION_DECL on success.
14325
14326    If the DECLARATOR is not suitable for a function (it defines a datum
14327    instead), we return 0, which tells yyparse to report a parse error.
14328
14329    May return void_type_node indicating that this method is actually
14330    a friend.  See grokfield for more details.
14331
14332    Came here with a `.pushlevel' .
14333
14334    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14335    CHANGES TO CODE IN `grokfield'.  */
14336
14337 tree
14338 start_method (declspecs, declarator, attrlist)
14339      tree declarator, declspecs, attrlist;
14340 {
14341   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14342                                 attrlist);
14343
14344   /* Something too ugly to handle.  */
14345   if (fndecl == NULL_TREE)
14346     return NULL_TREE;
14347
14348   /* Pass friends other than inline friend functions back.  */
14349   if (fndecl == void_type_node)
14350     return fndecl;
14351
14352   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14353     /* Not a function, tell parser to report parse error.  */
14354     return NULL_TREE;
14355
14356   if (DECL_IN_AGGR_P (fndecl))
14357     {
14358       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14359         {
14360           if (DECL_CONTEXT (fndecl)
14361               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14362             cp_error ("`%D' is already defined in class `%T'", fndecl,
14363                       DECL_CONTEXT (fndecl));
14364         }
14365       return void_type_node;
14366     }
14367
14368   check_template_shadow (fndecl);
14369
14370   DECL_THIS_INLINE (fndecl) = 1;
14371
14372   if (flag_default_inline)
14373     DECL_INLINE (fndecl) = 1;
14374
14375   /* We process method specializations in finish_struct_1.  */
14376   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14377     fndecl = push_template_decl (fndecl);
14378
14379   if (! DECL_FRIEND_P (fndecl))
14380     {
14381       if (TREE_CHAIN (fndecl))
14382         {
14383           fndecl = copy_node (fndecl);
14384           TREE_CHAIN (fndecl) = NULL_TREE;
14385         }
14386
14387       if (DECL_CONSTRUCTOR_P (fndecl))
14388         {
14389           if (! grok_ctor_properties (current_class_type, fndecl))
14390             return void_type_node;
14391         }
14392       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14393         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14394     }
14395
14396   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14397
14398   /* Make a place for the parms */
14399   pushlevel (0);
14400   current_binding_level->parm_flag = 1;
14401
14402   DECL_IN_AGGR_P (fndecl) = 1;
14403   return fndecl;
14404 }
14405
14406 /* Go through the motions of finishing a function definition.
14407    We don't compile this method until after the whole class has
14408    been processed.
14409
14410    FINISH_METHOD must return something that looks as though it
14411    came from GROKFIELD (since we are defining a method, after all).
14412
14413    This is called after parsing the body of the function definition.
14414    STMTS is the chain of statements that makes up the function body.
14415
14416    DECL is the ..._DECL that `start_method' provided.  */
14417
14418 tree
14419 finish_method (decl)
14420      tree decl;
14421 {
14422   register tree fndecl = decl;
14423   tree old_initial;
14424
14425   register tree link;
14426
14427   if (decl == void_type_node)
14428     return decl;
14429
14430   old_initial = DECL_INITIAL (fndecl);
14431
14432   /* Undo the level for the parms (from start_method).
14433      This is like poplevel, but it causes nothing to be
14434      saved.  Saving information here confuses symbol-table
14435      output routines.  Besides, this information will
14436      be correctly output when this method is actually
14437      compiled.  */
14438
14439   /* Clear out the meanings of the local variables of this level;
14440      also record in each decl which block it belongs to.  */
14441
14442   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14443     {
14444       if (DECL_NAME (link) != NULL_TREE)
14445         pop_binding (DECL_NAME (link), link);
14446       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14447       DECL_CONTEXT (link) = NULL_TREE;
14448     }
14449
14450   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14451                       (HOST_WIDE_INT) current_binding_level->level_chain,
14452                       current_binding_level->parm_flag,
14453                       current_binding_level->keep);
14454
14455   poplevel (0, 0, 0);
14456
14457   DECL_INITIAL (fndecl) = old_initial;
14458
14459   /* We used to check if the context of FNDECL was different from
14460      current_class_type as another way to get inside here.  This didn't work
14461      for String.cc in libg++.  */
14462   if (DECL_FRIEND_P (fndecl))
14463     {
14464       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14465         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14466       decl = void_type_node;
14467     }
14468
14469   return decl;
14470 }
14471 \f
14472 /* Called when a new struct TYPE is defined.
14473    If this structure or union completes the type of any previous
14474    variable declaration, lay it out and output its rtl.  */
14475
14476 void
14477 hack_incomplete_structures (type)
14478      tree type;
14479 {
14480   tree *list;
14481   struct binding_level *level;
14482
14483   if (!type) /* Don't do this for class templates.  */
14484     return;
14485
14486   if (namespace_bindings_p ())
14487     {
14488       level = 0;
14489       list = &namespace_scope_incomplete;
14490     }
14491   else
14492     {
14493       level = innermost_nonclass_level ();
14494       list = &level->incomplete;
14495     }
14496
14497   while (1)
14498     {
14499       while (*list)
14500         {
14501           tree decl = TREE_VALUE (*list);
14502           if ((decl && TREE_TYPE (decl) == type)
14503               || (TREE_TYPE (decl)
14504                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14505                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14506             {
14507               int toplevel = toplevel_bindings_p ();
14508               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14509                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14510                 layout_type (TREE_TYPE (decl));
14511               layout_decl (decl, 0);
14512               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14513               if (! toplevel)
14514                 {
14515                   tree cleanup;
14516                   expand_decl (decl);
14517                   cleanup = maybe_build_cleanup (decl);
14518                   expand_decl_init (decl);
14519                   if (! expand_decl_cleanup (decl, cleanup))
14520                     cp_error ("parser lost in parsing declaration of `%D'",
14521                               decl);
14522                 }
14523               *list = TREE_CHAIN (*list);
14524             }
14525           else
14526             list = &TREE_CHAIN (*list);
14527         }
14528
14529       /* Keep looking through artificial binding levels generated
14530          for local variables.  */
14531       if (level && level->keep == 2)
14532         {
14533           level = level->level_chain;
14534           list = &level->incomplete;
14535         }
14536       else
14537         break;
14538     }
14539 }
14540
14541 /* If DECL is of a type which needs a cleanup, build that cleanup
14542    here.  */
14543
14544 tree
14545 maybe_build_cleanup (decl)
14546      tree decl;
14547 {
14548   tree type = TREE_TYPE (decl);
14549
14550   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14551     {
14552       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14553       tree rval;
14554
14555       if (TREE_CODE (type) == ARRAY_TYPE)
14556         rval = decl;
14557       else
14558         {
14559           mark_addressable (decl);
14560           rval = build_unary_op (ADDR_EXPR, decl, 0);
14561         }
14562
14563       /* Optimize for space over speed here.  */
14564       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14565           || flag_expensive_optimizations)
14566         flags |= LOOKUP_NONVIRTUAL;
14567
14568       rval = build_delete (TREE_TYPE (rval), rval,
14569                            sfk_complete_destructor, flags, 0);
14570
14571       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14572           && ! TYPE_HAS_DESTRUCTOR (type))
14573         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14574                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14575
14576       return rval;
14577     }
14578   return 0;
14579 }
14580 \f
14581 /* When a stmt has been parsed, this function is called.  */
14582
14583 void
14584 finish_stmt ()
14585 {
14586   /* Always assume this statement was not an expression statement.  If
14587      it actually was an expression statement, its our callers
14588      responsibility to fix this up.  */
14589   last_expr_type = NULL_TREE;
14590 }
14591
14592 /* DECL was originally constructed as a non-static member function,
14593    but turned out to be static.  Update it accordingly.  */
14594
14595 void
14596 revert_static_member_fn (decl)
14597      tree decl;
14598 {
14599   tree tmp;
14600   tree function = TREE_TYPE (decl);
14601   tree args = TYPE_ARG_TYPES (function);
14602
14603   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14604       != TYPE_UNQUALIFIED)
14605     cp_error ("static member function `%#D' declared with type qualifiers",
14606               *decl);
14607
14608   args = TREE_CHAIN (args);
14609   tmp = build_function_type (TREE_TYPE (function), args);
14610   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14611   tmp = build_exception_variant (tmp,
14612                                  TYPE_RAISES_EXCEPTIONS (function));
14613   TREE_TYPE (decl) = tmp;
14614   if (DECL_ARGUMENTS (decl))
14615     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14616   DECL_STATIC_FUNCTION_P (decl) = 1;
14617 }
14618
14619 /* Initialize the variables used during compilation of a C++
14620    function.  */
14621
14622 static void
14623 push_cp_function_context (f)
14624      struct function *f;
14625 {
14626   struct cp_language_function *p
14627     = ((struct cp_language_function *)
14628        xcalloc (1, sizeof (struct cp_language_function)));
14629   f->language = (struct language_function *) p;
14630
14631   /* It takes an explicit call to expand_body to generate RTL for a
14632      function.  */
14633   expanding_p = 0;
14634
14635   /* Whenever we start a new function, we destroy temporaries in the
14636      usual way.  */
14637   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14638 }
14639
14640 /* Free the language-specific parts of F, now that we've finished
14641    compiling the function.  */
14642
14643 static void
14644 pop_cp_function_context (f)
14645      struct function *f;
14646 {
14647   if (f->language)
14648     free (f->language);
14649   f->language = 0;
14650 }
14651
14652 /* Mark P for GC.  */
14653
14654 static void
14655 mark_lang_function (p)
14656      struct cp_language_function *p;
14657 {
14658   if (!p)
14659     return;
14660
14661   mark_c_language_function (&p->base);
14662
14663   ggc_mark_tree (p->x_ctor_label);
14664   ggc_mark_tree (p->x_dtor_label);
14665   ggc_mark_tree (p->x_current_class_ptr);
14666   ggc_mark_tree (p->x_current_class_ref);
14667   ggc_mark_tree (p->x_eh_spec_try_block);
14668
14669   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14670   mark_binding_level (&p->bindings);
14671 }
14672
14673 /* Mark the language-specific data in F for GC.  */
14674
14675 static void
14676 mark_cp_function_context (f)
14677      struct function *f;
14678 {
14679   mark_lang_function ((struct cp_language_function *) f->language);
14680 }
14681
14682 void
14683 lang_mark_tree (t)
14684      tree t;
14685 {
14686   enum tree_code code = TREE_CODE (t);
14687   if (code == IDENTIFIER_NODE)
14688     {
14689       struct lang_identifier *li = (struct lang_identifier *) t;
14690       struct lang_id2 *li2 = li->x;
14691       ggc_mark_tree (li->namespace_bindings);
14692       ggc_mark_tree (li->bindings);
14693       ggc_mark_tree (li->class_value);
14694       ggc_mark_tree (li->class_template_info);
14695
14696       if (li2)
14697         {
14698           ggc_mark_tree (li2->label_value);
14699           ggc_mark_tree (li2->implicit_decl);
14700           ggc_mark_tree (li2->error_locus);
14701         }
14702     }
14703   else if (code == CPLUS_BINDING)
14704     {
14705       if (BINDING_HAS_LEVEL_P (t))
14706         mark_binding_level (&BINDING_LEVEL (t));
14707       else
14708         ggc_mark_tree (BINDING_SCOPE (t));
14709       ggc_mark_tree (BINDING_VALUE (t));
14710     }
14711   else if (code == OVERLOAD)
14712     ggc_mark_tree (OVL_FUNCTION (t));
14713   else if (code == TEMPLATE_PARM_INDEX)
14714     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14715   else if (TREE_CODE_CLASS (code) == 'd')
14716     {
14717       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14718
14719       if (ld)
14720         {
14721           ggc_mark (ld);
14722           c_mark_lang_decl (&ld->decl_flags.base);
14723           if (!DECL_GLOBAL_CTOR_P (t)
14724               && !DECL_GLOBAL_DTOR_P (t)
14725               && !DECL_THUNK_P (t))
14726             ggc_mark_tree (ld->decl_flags.u2.access);
14727           else if (DECL_THUNK_P (t))
14728             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14729           if (TREE_CODE (t) != NAMESPACE_DECL)
14730             ggc_mark_tree (ld->decl_flags.u.template_info);
14731           else
14732             mark_binding_level (&NAMESPACE_LEVEL (t));
14733           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14734             {
14735               ggc_mark_tree (ld->befriending_classes);
14736               ggc_mark_tree (ld->context);
14737               ggc_mark_tree (ld->cloned_function);
14738               if (!DECL_OVERLOADED_OPERATOR_P (t))
14739                 ggc_mark_tree (ld->u2.vtt_parm);
14740               if (TREE_CODE (t) == TYPE_DECL)
14741                 ggc_mark_tree (ld->u.sorted_fields);
14742               else if (TREE_CODE (t) == FUNCTION_DECL
14743                        && !DECL_PENDING_INLINE_P (t))
14744                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14745             }
14746         }
14747     }
14748   else if (TREE_CODE_CLASS (code) == 't')
14749     {
14750       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14751
14752       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14753                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14754         {
14755           ggc_mark (lt);
14756           ggc_mark_tree (lt->primary_base);
14757           ggc_mark_tree (lt->vfields);
14758           ggc_mark_tree (lt->vbases);
14759           ggc_mark_tree (lt->tags);
14760           ggc_mark_tree (lt->size);
14761           ggc_mark_tree (lt->pure_virtuals);
14762           ggc_mark_tree (lt->friend_classes);
14763           ggc_mark_tree (lt->rtti);
14764           ggc_mark_tree (lt->methods);
14765           ggc_mark_tree (lt->template_info);
14766           ggc_mark_tree (lt->befriending_classes);
14767         }
14768       else if (lt)
14769         /* In the case of pointer-to-member function types, the
14770            TYPE_LANG_SPECIFIC is really just a tree.  */
14771         ggc_mark_tree ((tree) lt);
14772     }
14773 }