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 /* Namespace std.  */
 271 int in_std;
 272
 273 /* Expect only namespace names now. */
 274 static int only_namespace_names;
 275
 276 /* Used only for jumps to as-yet undefined labels, since jumps to
 277    defined labels can have their validity checked immediately.  */
 278
 279 struct named_label_use_list
 280 {
 281   struct binding_level *binding_level;
 282   tree names_in_scope;
 283   tree label_decl;
 284   const char *filename_o_goto;
 285   int lineno_o_goto;
 286   struct named_label_use_list *next;
 287 };
 288
 289 #define named_label_uses cp_function_chain->x_named_label_uses
 290
 291 /* A list of objects which have constructors or destructors
 292    which reside in the global scope.  The decl is stored in
 293    the TREE_VALUE slot and the initializer is stored
 294    in the TREE_PURPOSE slot.  */
 295 tree static_aggregates;
 296
 297 /* -- end of C++ */
 298
 299 /* A node for the integer constants 2, and 3.  */
 300
 301 tree integer_two_node, integer_three_node;
 302
 303 /* Parsing a function declarator leaves here a chain of structure
 304    and enum types declared in the parmlist.  */
 305
 306 static tree last_function_parm_tags;
 307
 308 /* Similar, for last_function_parm_tags.  */
 309 tree last_function_parms;
 310 static tree current_function_parm_tags;
 311
 312 /* A list of all LABEL_DECLs in the function that have names.  Here so
 313    we can clear out their names' definitions at the end of the
 314    function, and so we can check the validity of jumps to these labels.  */
 315
 316 struct named_label_list
 317 {
 318   struct binding_level *binding_level;
 319   tree names_in_scope;
 320   tree old_value;
 321   tree label_decl;
 322   tree bad_decls;
 323   int eh_region;
 324   struct named_label_list *next;
 325 };
 326
 327 #define named_labels cp_function_chain->x_named_labels
 328
 329 /* Set to 0 at beginning of a function definition, and whenever
 330    a label (case or named) is defined.  Set to value of expression
 331    returned from function when that value can be transformed into
 332    a named return value.  */
 333
 334 tree current_function_return_value;
 335
 336 /* Nonzero means use the ISO C94 dialect of C.  */
 337
 338 int flag_isoc94;
 339
 340 /* Nonzero means use the ISO C99 dialect of C.  */
 341
 342 int flag_isoc99;
 343
 344 /* Nonzero means we are a hosted implementation for code shared with C.  */
 345
 346 int flag_hosted = 1;
 347
 348 /* Nonzero means add default format_arg attributes for functions not
 349    in ISO C.  */
 350
 351 int flag_noniso_default_format_attributes = 1;
 352
 353 /* Nonzero means give `double' the same size as `float'.  */
 354
 355 extern int flag_short_double;
 356
 357 /* Nonzero means don't recognize any builtin functions.  */
 358
 359 extern int flag_no_builtin;
 360
 361 /* Nonzero means don't recognize the non-ANSI builtin functions.
 362    -ansi sets this.  */
 363
 364 extern int flag_no_nonansi_builtin;
 365
 366 /* Nonzero if we want to conserve space in the .o files.  We do this
 367    by putting uninitialized data and runtime initialized data into
 368    .common instead of .data at the expense of not flagging multiple
 369    definitions.  */
 370 extern int flag_conserve_space;
 371 \f
 372 /* C and C++ flags are in decl2.c.  */
 373
 374 /* Flag used when debugging spew.c */
 375
 376 extern int spew_debug;
 377
 378 /* A expression of value 0 with the same precision as a sizetype
 379    node, but signed.  */
 380 tree signed_size_zero_node;
 381
 382 /* The name of the anonymous namespace, throughout this translation
 383    unit.  */
 384 tree anonymous_namespace_name;
 385
 386 /* The number of function bodies which we are currently processing.
 387    (Zero if we are at namespace scope, one inside the body of a
 388    function, two inside the body of a function in a local class, etc.)  */
 389 int function_depth;
 390 \f
 391 /* For each binding contour we allocate a binding_level structure
 392    which records the names defined in that contour.
 393    Contours include:
 394     0) the global one
 395     1) one for each function definition,
 396        where internal declarations of the parameters appear.
 397     2) one for each compound statement,
 398        to record its declarations.
 399
 400    The current meaning of a name can be found by searching the levels
 401    from the current one out to the global one.
 402
 403    Off to the side, may be the class_binding_level.  This exists only
 404    to catch class-local declarations.  It is otherwise nonexistent.
 405
 406    Also there may be binding levels that catch cleanups that must be
 407    run when exceptions occur.  Thus, to see whether a name is bound in
 408    the current scope, it is not enough to look in the
 409    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 410    instead.  */
 411
 412 /* Note that the information in the `names' component of the global contour
 413    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 414
 415 struct binding_level
 416   {
 417     /* A chain of _DECL nodes for all variables, constants, functions,
 418        and typedef types.  These are in the reverse of the order
 419        supplied.  There may be OVERLOADs on this list, too, but they
 420        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 421     tree names;
 422
 423     /* A list of structure, union and enum definitions, for looking up
 424        tag names.
 425        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 426        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 427        or ENUMERAL_TYPE node.
 428
 429        C++: the TREE_VALUE nodes can be simple types for
 430        component_bindings.  */
 431     tree tags;
 432
 433     /* A list of USING_DECL nodes. */
 434     tree usings;
 435
 436     /* A list of used namespaces. PURPOSE is the namespace,
 437        VALUE the common ancestor with this binding_level's namespace. */
 438     tree using_directives;
 439
 440     /* If this binding level is the binding level for a class, then
 441        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 442        is the name of an entity bound in the class; the TREE_VALUE is
 443        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 444        when leaving class scope, we can restore the
 445        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 446        the DECL bound by this name in the class.  */
 447     tree class_shadowed;
 448
 449     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 450        is used for all binding levels.  */
 451     tree type_shadowed;
 452
 453     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 454        label in this scope.  The TREE_PURPOSE is the previous value of
 455        the IDENTIFIER_LABEL VALUE.  */
 456     tree shadowed_labels;
 457
 458     /* For each level (except not the global one),
 459        a chain of BLOCK nodes for all the levels
 460        that were entered and exited one level down.  */
 461     tree blocks;
 462
 463     /* The _TYPE node for this level, if parm_flag == 2.  */
 464     tree this_class;
 465
 466     /* The binding level which this one is contained in (inherits from).  */
 467     struct binding_level *level_chain;
 468
 469     /* List of decls in `names' that have incomplete
 470        structure or union types.  */
 471     tree incomplete;
 472
 473     /* List of VAR_DECLS saved from a previous for statement.
 474        These would be dead in ISO-conforming code, but might
 475        be referenced in ARM-era code.  These are stored in a
 476        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 477     tree dead_vars_from_for;
 478
 479     /* 1 for the level that holds the parameters of a function.
 480        2 for the level that holds a class declaration.  */
 481     unsigned parm_flag : 2;
 482
 483     /* 1 means make a BLOCK for this level regardless of all else.
 484        2 for temporary binding contours created by the compiler.  */
 485     unsigned keep : 2;
 486
 487     /* Nonzero if this level "doesn't exist" for tags.  */
 488     unsigned tag_transparent : 1;
 489
 490     /* Nonzero if this level can safely have additional
 491        cleanup-needing variables added to it.  */
 492     unsigned more_cleanups_ok : 1;
 493     unsigned have_cleanups : 1;
 494
 495     /* Nonzero if this scope is for storing the decls for template
 496        parameters and generic decls; these decls will be discarded and
 497        replaced with a TEMPLATE_DECL.  */
 498     unsigned template_parms_p : 1;
 499
 500     /* Nonzero if this scope corresponds to the `<>' in a
 501        `template <>' clause.  Whenever this flag is set,
 502        TEMPLATE_PARMS_P will be set as well.  */
 503     unsigned template_spec_p : 1;
 504
 505     /* This is set for a namespace binding level.  */
 506     unsigned namespace_p : 1;
 507
 508     /* True if this level is that of a for-statement where we need to
 509        worry about ambiguous (ARM or ISO) scope rules.  */
 510     unsigned is_for_scope : 1;
 511
 512     /* True if this level corresponds to an EH region, as for a try block.
 513        Currently this information is only available while building the
 514        tree structure.  */
 515     unsigned eh_region : 1;
 516
 517     /* Four bits left for this word.  */
 518
 519 #if defined(DEBUG_CP_BINDING_LEVELS)
 520     /* Binding depth at which this level began.  */
 521     unsigned binding_depth;
 522 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 523   };
 524
 525 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 526
 527 /* The binding level currently in effect.  */
 528
 529 #define current_binding_level                   \
 530   (cfun                                         \
 531    ? cp_function_chain->bindings                \
 532    : scope_chain->bindings)
 533
 534 /* The binding level of the current class, if any.  */
 535
 536 #define class_binding_level scope_chain->class_bindings
 537
 538 /* A chain of binding_level structures awaiting reuse.  */
 539
 540 static struct binding_level *free_binding_level;
 541
 542 /* The outermost binding level, for names of file scope.
 543    This is created when the compiler is started and exists
 544    through the entire run.  */
 545
 546 static struct binding_level *global_binding_level;
 547
 548 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 549
 550 static int keep_next_level_flag;
 551
 552 #if defined(DEBUG_CP_BINDING_LEVELS)
 553 static int binding_depth = 0;
 554 static int is_class_level = 0;
 555
 556 static void
 557 indent ()
 558 {
 559   register unsigned i;
 560
 561   for (i = 0; i < binding_depth*2; i++)
 562     putc (' ', stderr);
 563 }
 564 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 565
 566 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 567
 568 static void
 569 push_binding_level (newlevel, tag_transparent, keep)
 570      struct binding_level *newlevel;
 571      int tag_transparent, keep;
 572 {
 573   /* Add this level to the front of the chain (stack) of levels that
 574      are active.  */
 575   bzero ((char*) newlevel, sizeof (struct binding_level));
 576   newlevel->level_chain = current_binding_level;
 577   current_binding_level = newlevel;
 578   newlevel->tag_transparent = tag_transparent;
 579   newlevel->more_cleanups_ok = 1;
 580
 581   newlevel->keep = keep;
 582 #if defined(DEBUG_CP_BINDING_LEVELS)
 583   newlevel->binding_depth = binding_depth;
 584   indent ();
 585   fprintf (stderr, "push %s level 0x%08x line %d\n",
 586            (is_class_level) ? "class" : "block", newlevel, lineno);
 587   is_class_level = 0;
 588   binding_depth++;
 589 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 590 }
 591
 592 /* Find the innermost enclosing class scope, and reset
 593    CLASS_BINDING_LEVEL appropriately.  */
 594
 595 static void
 596 find_class_binding_level ()
 597 {
 598   struct binding_level *level = current_binding_level;
 599
 600   while (level && level->parm_flag != 2)
 601     level = level->level_chain;
 602   if (level && level->parm_flag == 2)
 603     class_binding_level = level;
 604   else
 605     class_binding_level = 0;
 606 }
 607
 608 static void
 609 pop_binding_level ()
 610 {
 611   if (global_binding_level)
 612     {
 613       /* Cannot pop a level, if there are none left to pop.  */
 614       if (current_binding_level == global_binding_level)
 615         my_friendly_abort (123);
 616     }
 617   /* Pop the current level, and free the structure for reuse.  */
 618 #if defined(DEBUG_CP_BINDING_LEVELS)
 619   binding_depth--;
 620   indent ();
 621   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 622           (is_class_level) ? "class" : "block",
 623           current_binding_level, lineno);
 624   if (is_class_level != (current_binding_level == class_binding_level))
 625     {
 626       indent ();
 627       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 628     }
 629   is_class_level = 0;
 630 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 631   {
 632     register struct binding_level *level = current_binding_level;
 633     current_binding_level = current_binding_level->level_chain;
 634     level->level_chain = free_binding_level;
 635 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 636     if (level->binding_depth != binding_depth)
 637       abort ();
 638 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 639     free_binding_level = level;
 640     find_class_binding_level ();
 641   }
 642 }
 643
 644 static void
 645 suspend_binding_level ()
 646 {
 647   if (class_binding_level)
 648     current_binding_level = class_binding_level;
 649
 650   if (global_binding_level)
 651     {
 652       /* Cannot suspend a level, if there are none left to suspend.  */
 653       if (current_binding_level == global_binding_level)
 654         my_friendly_abort (123);
 655     }
 656   /* Suspend the current level.  */
 657 #if defined(DEBUG_CP_BINDING_LEVELS)
 658   binding_depth--;
 659   indent ();
 660   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 661           (is_class_level) ? "class" : "block",
 662           current_binding_level, lineno);
 663   if (is_class_level != (current_binding_level == class_binding_level))
 664     {
 665       indent ();
 666       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 667     }
 668   is_class_level = 0;
 669 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 670   current_binding_level = current_binding_level->level_chain;
 671   find_class_binding_level ();
 672 }
 673
 674 static void
 675 resume_binding_level (b)
 676      struct binding_level *b;
 677 {
 678   /* Resuming binding levels is meant only for namespaces,
 679      and those cannot nest into classes. */
 680   my_friendly_assert(!class_binding_level, 386);
 681   /* Also, resuming a non-directly nested namespace is a no-no.  */
 682   my_friendly_assert(b->level_chain == current_binding_level, 386);
 683   current_binding_level = b;
 684 #if defined(DEBUG_CP_BINDING_LEVELS)
 685   b->binding_depth = binding_depth;
 686   indent ();
 687   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 688            (is_class_level) ? "class" : "block", b, lineno);
 689   is_class_level = 0;
 690   binding_depth++;
 691 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 692 }
 693 \f
 694 /* Create a new `struct binding_level'.  */
 695
 696 static
 697 struct binding_level *
 698 make_binding_level ()
 699 {
 700   /* NOSTRICT */
 701   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 702 }
 703
 704 /* Nonzero if we are currently in the global binding level.  */
 705
 706 int
 707 global_bindings_p ()
 708 {
 709   return current_binding_level == global_binding_level;
 710 }
 711
 712 /* Return the innermost binding level that is not for a class scope.  */
 713
 714 static struct binding_level *
 715 innermost_nonclass_level ()
 716 {
 717   struct binding_level *b;
 718
 719   b = current_binding_level;
 720   while (b->parm_flag == 2)
 721     b = b->level_chain;
 722
 723   return b;
 724 }
 725
 726 /* Nonzero if we are currently in a toplevel binding level.  This
 727    means either the global binding level or a namespace in a toplevel
 728    binding level.  Since there are no non-toplevel namespace levels,
 729    this really means any namespace or template parameter level.  We
 730    also include a class whose context is toplevel.  */
 731
 732 int
 733 toplevel_bindings_p ()
 734 {
 735   struct binding_level *b = innermost_nonclass_level ();
 736
 737   return b->namespace_p || b->template_parms_p;
 738 }
 739
 740 /* Nonzero if this is a namespace scope, or if we are defining a class
 741    which is itself at namespace scope, or whose enclosing class is
 742    such a class, etc.  */
 743
 744 int
 745 namespace_bindings_p ()
 746 {
 747   struct binding_level *b = innermost_nonclass_level ();
 748
 749   return b->namespace_p;
 750 }
 751
 752 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 753    unconditionally.  Otherwise, use the normal logic to decide whether
 754    or not to create a BLOCK.  */
 755
 756 void
 757 keep_next_level (keep)
 758      int keep;
 759 {
 760   keep_next_level_flag = keep;
 761 }
 762
 763 /* Nonzero if the current level needs to have a BLOCK made.  */
 764
 765 int
 766 kept_level_p ()
 767 {
 768   return (current_binding_level->blocks != NULL_TREE
 769           || current_binding_level->keep
 770           || current_binding_level->names != NULL_TREE
 771           || (current_binding_level->tags != NULL_TREE
 772               && !current_binding_level->tag_transparent));
 773 }
 774
 775 static void
 776 declare_namespace_level ()
 777 {
 778   current_binding_level->namespace_p = 1;
 779 }
 780
 781 /* Returns non-zero if this scope was created to store template
 782    parameters.  */
 783
 784 int
 785 template_parm_scope_p ()
 786 {
 787   return current_binding_level->template_parms_p;
 788 }
 789
 790 /* Returns the kind of template specialization we are currently
 791    processing, given that it's declaration contained N_CLASS_SCOPES
 792    explicit scope qualifications.  */
 793
 794 tmpl_spec_kind
 795 current_tmpl_spec_kind (n_class_scopes)
 796      int n_class_scopes;
 797 {
 798   int n_template_parm_scopes = 0;
 799   int seen_specialization_p = 0;
 800   int innermost_specialization_p = 0;
 801   struct binding_level *b;
 802
 803   /* Scan through the template parameter scopes.  */
 804   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 805     {
 806       /* If we see a specialization scope inside a parameter scope,
 807          then something is wrong.  That corresponds to a declaration
 808          like:
 809
 810             template <class T> template <> ...
 811
 812          which is always illegal since [temp.expl.spec] forbids the
 813          specialization of a class member template if the enclosing
 814          class templates are not explicitly specialized as well.  */
 815       if (b->template_spec_p)
 816         {
 817           if (n_template_parm_scopes == 0)
 818             innermost_specialization_p = 1;
 819           else
 820             seen_specialization_p = 1;
 821         }
 822       else if (seen_specialization_p == 1)
 823         return tsk_invalid_member_spec;
 824
 825       ++n_template_parm_scopes;
 826     }
 827
 828   /* Handle explicit instantiations.  */
 829   if (processing_explicit_instantiation)
 830     {
 831       if (n_template_parm_scopes != 0)
 832         /* We've seen a template parameter list during an explicit
 833            instantiation.  For example:
 834
 835              template <class T> template void f(int);
 836
 837            This is erroneous.  */
 838         return tsk_invalid_expl_inst;
 839       else
 840         return tsk_expl_inst;
 841     }
 842
 843   if (n_template_parm_scopes < n_class_scopes)
 844     /* We've not seen enough template headers to match all the
 845        specialized classes present.  For example:
 846
 847          template <class T> void R<T>::S<T>::f(int);
 848
 849        This is illegal; there needs to be one set of template
 850        parameters for each class.  */
 851     return tsk_insufficient_parms;
 852   else if (n_template_parm_scopes == n_class_scopes)
 853     /* We're processing a non-template declaration (even though it may
 854        be a member of a template class.)  For example:
 855
 856          template <class T> void S<T>::f(int);
 857
 858        The `class T' maches the `S<T>', leaving no template headers
 859        corresponding to the `f'.  */
 860     return tsk_none;
 861   else if (n_template_parm_scopes > n_class_scopes + 1)
 862     /* We've got too many template headers.  For example:
 863
 864          template <> template <class T> void f (T);
 865
 866        There need to be more enclosing classes.  */
 867     return tsk_excessive_parms;
 868   else
 869     /* This must be a template.  It's of the form:
 870
 871          template <class T> template <class U> void S<T>::f(U);
 872
 873        This is a specialization if the innermost level was a
 874        specialization; otherwise it's just a definition of the
 875        template.  */
 876     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 877 }
 878
 879 void
 880 set_class_shadows (shadows)
 881      tree shadows;
 882 {
 883   class_binding_level->class_shadowed = shadows;
 884 }
 885
 886 /* Enter a new binding level.
 887    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 888    not for that of tags.  */
 889
 890 void
 891 pushlevel (tag_transparent)
 892      int tag_transparent;
 893 {
 894   struct binding_level *newlevel;
 895
 896   if (cfun && !doing_semantic_analysis_p ())
 897     return;
 898
 899   /* Reuse or create a struct for this binding level.  */
 900 #if defined(DEBUG_CP_BINDING_LEVELS)
 901   if (0)
 902 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 903   if (free_binding_level)
 904 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 905     {
 906       newlevel = free_binding_level;
 907       free_binding_level = free_binding_level->level_chain;
 908     }
 909   else
 910     newlevel = make_binding_level ();
 911
 912   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 913   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 914   keep_next_level_flag = 0;
 915 }
 916
 917 /* Enter a new scope.  The KIND indicates what kind of scope is being
 918    created.  */
 919
 920 void
 921 begin_scope (sk)
 922      scope_kind sk;
 923 {
 924   pushlevel (0);
 925
 926   switch (sk)
 927     {
 928     case sk_template_spec:
 929       current_binding_level->template_spec_p = 1;
 930       /* Fall through.  */
 931
 932     case sk_template_parms:
 933       current_binding_level->template_parms_p = 1;
 934       break;
 935
 936     default:
 937       my_friendly_abort (20000309);
 938     }
 939 }
 940
 941 /* Exit the current scope.  */
 942
 943 void
 944 finish_scope ()
 945 {
 946   poplevel (0, 0, 0);
 947 }
 948
 949 void
 950 note_level_for_for ()
 951 {
 952   current_binding_level->is_for_scope = 1;
 953 }
 954
 955 /* Record that the current binding level represents a try block.  */
 956
 957 void
 958 note_level_for_eh ()
 959 {
 960   current_binding_level->eh_region = 1;
 961 }
 962
 963 /* For a binding between a name and an entity at a block scope,
 964    this is the `struct binding_level' for the block.  */
 965 #define BINDING_LEVEL(NODE) \
 966    (((struct tree_binding*)NODE)->scope.level)
 967
 968 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 969    level at which this declaration is being bound.  */
 970
 971 static void
 972 push_binding (id, decl, level)
 973      tree id;
 974      tree decl;
 975      struct binding_level* level;
 976 {
 977   tree binding;
 978
 979   binding = make_node (CPLUS_BINDING);
 980
 981   /* Now, fill in the binding information.  */
 982   BINDING_VALUE (binding) = decl;
 983   BINDING_TYPE (binding) = NULL_TREE;
 984   BINDING_LEVEL (binding) = level;
 985   INHERITED_VALUE_BINDING_P (binding) = 0;
 986   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 987   BINDING_HAS_LEVEL_P (binding) = 1;
 988
 989   /* And put it on the front of the list of bindings for ID.  */
 990   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 991   IDENTIFIER_BINDING (id) = binding;
 992 }
 993
 994 /* ID is already bound in the current scope.  But, DECL is an
 995    additional binding for ID in the same scope.  This is the `struct
 996    stat' hack whereby a non-typedef class-name or enum-name can be
 997    bound at the same level as some other kind of entity.  It's the
 998    responsibility of the caller to check that inserting this name is
 999    legal here.  Returns nonzero if the new binding was successful.  */
1000 static int
1001 add_binding (id, decl)
1002      tree id;
1003      tree decl;
1004 {
1005   tree binding = IDENTIFIER_BINDING (id);
1006   int ok = 1;
1007
1008   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1009     /* The new name is the type name.  */
1010     BINDING_TYPE (binding) = decl;
1011   else if (!BINDING_VALUE (binding))
1012     /* This situation arises when push_class_level_binding moves an
1013        inherited type-binding out of the way to make room for a new
1014        value binding.  */
1015     BINDING_VALUE (binding) = decl;
1016   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1017            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1018     {
1019       /* The old binding was a type name.  It was placed in
1020          BINDING_VALUE because it was thought, at the point it was
1021          declared, to be the only entity with such a name.  Move the
1022          type name into the type slot; it is now hidden by the new
1023          binding.  */
1024       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1025       BINDING_VALUE (binding) = decl;
1026       INHERITED_VALUE_BINDING_P (binding) = 0;
1027     }
1028   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1029            && TREE_CODE (decl) == TYPE_DECL
1030            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1031            && same_type_p (TREE_TYPE (decl),
1032                            TREE_TYPE (BINDING_VALUE (binding))))
1033     /* We have two typedef-names, both naming the same type to have
1034        the same name.  This is OK because of:
1035
1036          [dcl.typedef]
1037
1038          In a given scope, a typedef specifier can be used to redefine
1039          the name of any type declared in that scope to refer to the
1040          type to which it already refers.  */
1041     ok = 0;
1042   /* There can be two block-scope declarations of the same variable,
1043      so long as they are `extern' declarations.  */
1044   else if (TREE_CODE (decl) == VAR_DECL
1045            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1046            && DECL_EXTERNAL (decl)
1047            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1048     {
1049       duplicate_decls (decl, BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052   else
1053     {
1054       cp_error ("declaration of `%#D'", decl);
1055       cp_error_at ("conflicts with previous declaration `%#D'",
1056                    BINDING_VALUE (binding));
1057       ok = 0;
1058     }
1059
1060   return ok;
1061 }
1062
1063 /* Add DECL to the list of things declared in B.  */
1064
1065 static void
1066 add_decl_to_level (decl, b)
1067      tree decl;
1068      struct binding_level *b;
1069 {
1070   /* We build up the list in reverse order, and reverse it later if
1071      necessary.  */
1072   TREE_CHAIN (decl) = b->names;
1073   b->names = decl;
1074 }
1075
1076 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1077    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1078    doesn't really belong to this binding level, that it got here
1079    through a using-declaration.  */
1080
1081 void
1082 push_local_binding (id, decl, flags)
1083      tree id;
1084      tree decl;
1085      int flags;
1086 {
1087   struct binding_level *b;
1088
1089   /* Skip over any local classes.  This makes sense if we call
1090      push_local_binding with a friend decl of a local class.  */
1091   b = current_binding_level;
1092   while (b->parm_flag == 2)
1093     b = b->level_chain;
1094
1095   if (lookup_name_current_level (id))
1096     {
1097       /* Supplement the existing binding.  */
1098       if (!add_binding (id, decl))
1099         /* It didn't work.  Something else must be bound at this
1100            level.  Do not add DECL to the list of things to pop
1101            later.  */
1102         return;
1103     }
1104   else
1105     /* Create a new binding.  */
1106     push_binding (id, decl, b);
1107
1108   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1109     /* We must put the OVERLOAD into a TREE_LIST since the
1110        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1111        decls that got here through a using-declaration.  */
1112     decl = build_tree_list (NULL_TREE, decl);
1113
1114   /* And put DECL on the list of things declared by the current
1115      binding level.  */
1116   add_decl_to_level (decl, b);
1117 }
1118
1119 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1120    binding was successful.  */
1121
1122 int
1123 push_class_binding (id, decl)
1124      tree id;
1125      tree decl;
1126 {
1127   int result = 1;
1128   tree binding = IDENTIFIER_BINDING (id);
1129   tree context;
1130
1131   /* Note that we declared this value so that we can issue an error if
1132      this an illegal redeclaration of a name already used for some
1133      other purpose.  */
1134   note_name_declared_in_class (id, decl);
1135
1136   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1137     /* Supplement the existing binding.  */
1138     result = add_binding (id, decl);
1139   else
1140     /* Create a new binding.  */
1141     push_binding (id, decl, class_binding_level);
1142
1143   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1144      class-level declaration.  Note that we do not use DECL here
1145      because of the possibility of the `struct stat' hack; if DECL is
1146      a class-name or enum-name we might prefer a field-name, or some
1147      such.  */
1148   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1149
1150   /* If this is a binding from a base class, mark it as such.  */
1151   binding = IDENTIFIER_BINDING (id);
1152   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1153     {
1154       /* Any implicit typename must be from a base-class.  The
1155          context for an implicit typename declaration is always
1156          the derived class in which the lookup was done, so the checks
1157          based on the context of DECL below will not trigger.  */
1158       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1159         INHERITED_VALUE_BINDING_P (binding) = 1;
1160       else
1161         {
1162           if (TREE_CODE (decl) == OVERLOAD)
1163             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1164           else
1165             {
1166               my_friendly_assert (DECL_P (decl), 0);
1167               context = CP_DECL_CONTEXT (decl);
1168             }
1169
1170           if (is_properly_derived_from (current_class_type, context))
1171             INHERITED_VALUE_BINDING_P (binding) = 1;
1172           else
1173             INHERITED_VALUE_BINDING_P (binding) = 0;
1174         }
1175     }
1176   else if (BINDING_VALUE (binding) == decl)
1177     /* We only encounter a TREE_LIST when push_class_decls detects an
1178        ambiguity.  Such an ambiguity can be overridden by a definition
1179        in this class.  */
1180     INHERITED_VALUE_BINDING_P (binding) = 1;
1181
1182   return result;
1183 }
1184
1185 /* Remove the binding for DECL which should be the innermost binding
1186    for ID.  */
1187
1188 static void
1189 pop_binding (id, decl)
1190      tree id;
1191      tree decl;
1192 {
1193   tree binding;
1194
1195   if (id == NULL_TREE)
1196     /* It's easiest to write the loops that call this function without
1197        checking whether or not the entities involved have names.  We
1198        get here for such an entity.  */
1199     return;
1200
1201   /* Get the innermost binding for ID.  */
1202   binding = IDENTIFIER_BINDING (id);
1203
1204   /* The name should be bound.  */
1205   my_friendly_assert (binding != NULL_TREE, 0);
1206
1207   /* The DECL will be either the ordinary binding or the type
1208      binding for this identifier.  Remove that binding.  */
1209   if (BINDING_VALUE (binding) == decl)
1210     BINDING_VALUE (binding) = NULL_TREE;
1211   else if (BINDING_TYPE (binding) == decl)
1212     BINDING_TYPE (binding) = NULL_TREE;
1213   else
1214     my_friendly_abort (0);
1215
1216   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1217     /* We're completely done with the innermost binding for this
1218        identifier.  Unhook it from the list of bindings.  */
1219     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1220 }
1221
1222 /* When a label goes out of scope, check to see if that label was used
1223    in a valid manner, and issue any appropriate warnings or errors.  */
1224
1225 static void
1226 pop_label (label, old_value)
1227      tree label;
1228      tree old_value;
1229 {
1230   if (!processing_template_decl && doing_semantic_analysis_p ())
1231     {
1232       if (DECL_INITIAL (label) == NULL_TREE)
1233         {
1234           cp_error_at ("label `%D' used but not defined", label);
1235           /* Avoid crashing later.  */
1236           define_label (input_filename, 1, DECL_NAME (label));
1237         }
1238       else if (warn_unused_label && !TREE_USED (label))
1239         cp_warning_at ("label `%D' defined but not used", label);
1240     }
1241
1242   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1243 }
1244
1245 /* At the end of a function, all labels declared within the function
1246    go out of scope.  BLOCK is the top-level block for the
1247    function.  */
1248
1249 static void
1250 pop_labels (block)
1251      tree block;
1252 {
1253   struct named_label_list *link;
1254
1255   /* Clear out the definitions of all label names, since their scopes
1256      end here.  */
1257   for (link = named_labels; link; link = link->next)
1258     {
1259       pop_label (link->label_decl, link->old_value);
1260       /* Put the labels into the "variables" of the top-level block,
1261          so debugger can see them.  */
1262       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1263       BLOCK_VARS (block) = link->label_decl;
1264     }
1265
1266   named_labels = NULL;
1267 }
1268
1269 /* Exit a binding level.
1270    Pop the level off, and restore the state of the identifier-decl mappings
1271    that were in effect when this level was entered.
1272
1273    If KEEP == 1, this level had explicit declarations, so
1274    and create a "block" (a BLOCK node) for the level
1275    to record its declarations and subblocks for symbol table output.
1276
1277    If FUNCTIONBODY is nonzero, this level is the body of a function,
1278    so create a block as if KEEP were set and also clear out all
1279    label names.
1280
1281    If REVERSE is nonzero, reverse the order of decls before putting
1282    them into the BLOCK.  */
1283
1284 tree
1285 poplevel (keep, reverse, functionbody)
1286      int keep;
1287      int reverse;
1288      int functionbody;
1289 {
1290   register tree link;
1291   /* The chain of decls was accumulated in reverse order.
1292      Put it into forward order, just for cleanliness.  */
1293   tree decls;
1294   int tmp = functionbody;
1295   int real_functionbody;
1296   tree tags;
1297   tree subblocks;
1298   tree block = NULL_TREE;
1299   tree decl;
1300   int leaving_for_scope;
1301
1302   if (cfun && !doing_semantic_analysis_p ())
1303     return NULL_TREE;
1304
1305   my_friendly_assert (current_binding_level->parm_flag != 2,
1306                       19990916);
1307
1308   real_functionbody = (current_binding_level->keep == 2
1309                        ? ((functionbody = 0), tmp) : functionbody);
1310   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1311   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1312
1313   my_friendly_assert (!current_binding_level->class_shadowed,
1314                       19990414);
1315
1316   /* We used to use KEEP == 2 to indicate that the new block should go
1317      at the beginning of the list of blocks at this binding level,
1318      rather than the end.  This hack is no longer used.  */
1319   my_friendly_assert (keep == 0 || keep == 1, 0);
1320
1321   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1322                       (HOST_WIDE_INT) current_binding_level->level_chain,
1323                       current_binding_level->parm_flag,
1324                       current_binding_level->keep);
1325
1326   if (current_binding_level->keep == 1)
1327     keep = 1;
1328
1329   /* Any uses of undefined labels, and any defined labels, now operate
1330      under constraints of next binding contour.  */
1331   if (cfun && !functionbody)
1332     {
1333       struct binding_level *level_chain;
1334       level_chain = current_binding_level->level_chain;
1335       if (level_chain)
1336         {
1337           struct named_label_use_list *uses;
1338           struct named_label_list *labels;
1339           for (labels = named_labels; labels; labels = labels->next)
1340             if (labels->binding_level == current_binding_level)
1341               {
1342                 tree decl;
1343                 if (current_binding_level->eh_region)
1344                   labels->eh_region = 1;
1345                 for (decl = labels->names_in_scope; decl;
1346                      decl = TREE_CHAIN (decl))
1347                   if (decl_jump_unsafe (decl))
1348                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1349                                                    labels->bad_decls);
1350                 labels->binding_level = level_chain;
1351                 labels->names_in_scope = level_chain->names;
1352               }
1353
1354           for (uses = named_label_uses; uses; uses = uses->next)
1355             if (uses->binding_level == current_binding_level)
1356               {
1357                 uses->binding_level = level_chain;
1358                 uses->names_in_scope = level_chain->names;
1359               }
1360         }
1361     }
1362
1363   /* Get the decls in the order they were written.
1364      Usually current_binding_level->names is in reverse order.
1365      But parameter decls were previously put in forward order.  */
1366
1367   if (reverse)
1368     current_binding_level->names
1369       = decls = nreverse (current_binding_level->names);
1370   else
1371     decls = current_binding_level->names;
1372
1373   /* Output any nested inline functions within this block
1374      if they weren't already output.  */
1375   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1376     if (TREE_CODE (decl) == FUNCTION_DECL
1377         && ! TREE_ASM_WRITTEN (decl)
1378         && DECL_INITIAL (decl) != NULL_TREE
1379         && TREE_ADDRESSABLE (decl)
1380         && decl_function_context (decl) == current_function_decl)
1381       {
1382         /* If this decl was copied from a file-scope decl
1383            on account of a block-scope extern decl,
1384            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1385         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1386           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1387         else
1388           {
1389             push_function_context ();
1390             output_inline_function (decl);
1391             pop_function_context ();
1392           }
1393       }
1394
1395   /* When not in function-at-a-time mode, expand_end_bindings will
1396      warn about unused variables.  But, in function-at-a-time mode
1397      expand_end_bindings is not passed the list of variables in the
1398      current scope, and therefore no warning is emitted.  So, we
1399      explicitly warn here.  */
1400   if (!processing_template_decl)
1401     warn_about_unused_variables (getdecls ());
1402
1403   /* If there were any declarations or structure tags in that level,
1404      or if this level is a function body,
1405      create a BLOCK to record them for the life of this function.  */
1406   block = NULL_TREE;
1407   if (keep == 1 || functionbody)
1408     block = make_node (BLOCK);
1409   if (block != NULL_TREE)
1410     {
1411       BLOCK_VARS (block) = decls;
1412       BLOCK_SUBBLOCKS (block) = subblocks;
1413     }
1414
1415   /* In each subblock, record that this is its superior.  */
1416   if (keep >= 0)
1417     for (link = subblocks; link; link = TREE_CHAIN (link))
1418       BLOCK_SUPERCONTEXT (link) = block;
1419
1420   /* We still support the old for-scope rules, whereby the variables
1421      in a for-init statement were in scope after the for-statement
1422      ended.  We only use the new rules in flag_new_for_scope is
1423      nonzero.  */
1424   leaving_for_scope
1425     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1426
1427   /* Remove declarations for all the DECLs in this level.  */
1428   for (link = decls; link; link = TREE_CHAIN (link))
1429     {
1430       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1431           && DECL_NAME (link))
1432         {
1433           tree outer_binding
1434             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1435           tree ns_binding;
1436
1437           if (!outer_binding)
1438             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1439           else
1440             ns_binding = NULL_TREE;
1441
1442           if (outer_binding
1443               && (BINDING_LEVEL (outer_binding)
1444                   == current_binding_level->level_chain))
1445             /* We have something like:
1446
1447                  int i;
1448                  for (int i; ;);
1449
1450                and we are leaving the `for' scope.  There's no reason to
1451                keep the binding of the inner `i' in this case.  */
1452             pop_binding (DECL_NAME (link), link);
1453           else if ((outer_binding
1454                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1455                         == TYPE_DECL))
1456                    || (ns_binding
1457                        && TREE_CODE (ns_binding) == TYPE_DECL))
1458             /* Here, we have something like:
1459
1460                  typedef int I;
1461
1462                  void f () {
1463                    for (int I; ;);
1464                  }
1465
1466                We must pop the for-scope binding so we know what's a
1467                type and what isn't.  */
1468             pop_binding (DECL_NAME (link), link);
1469           else
1470             {
1471               /* Mark this VAR_DECL as dead so that we can tell we left it
1472                  there only for backward compatibility.  */
1473               DECL_DEAD_FOR_LOCAL (link) = 1;
1474
1475               /* Keep track of what should of have happenned when we
1476                  popped the binding.  */
1477               if (outer_binding && BINDING_VALUE (outer_binding))
1478                 DECL_SHADOWED_FOR_VAR (link)
1479                   = BINDING_VALUE (outer_binding);
1480
1481               /* Add it to the list of dead variables in the next
1482                  outermost binding to that we can remove these when we
1483                  leave that binding.  */
1484               current_binding_level->level_chain->dead_vars_from_for
1485                 = tree_cons (NULL_TREE, link,
1486                              current_binding_level->level_chain->
1487                              dead_vars_from_for);
1488
1489               /* Although we don't pop the CPLUS_BINDING, we do clear
1490                  its BINDING_LEVEL since the level is going away now.  */
1491               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1492                 = 0;
1493             }
1494         }
1495       else
1496         {
1497           /* Remove the binding.  */
1498           decl = link;
1499           if (TREE_CODE (decl) == TREE_LIST)
1500             decl = TREE_VALUE (decl);
1501           if (DECL_P (decl))
1502             pop_binding (DECL_NAME (decl), decl);
1503           else if (TREE_CODE (decl) == OVERLOAD)
1504             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1505           else
1506             my_friendly_abort (0);
1507         }
1508     }
1509
1510   /* Remove declarations for any `for' variables from inner scopes
1511      that we kept around.  */
1512   for (link = current_binding_level->dead_vars_from_for;
1513        link; link = TREE_CHAIN (link))
1514     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1515
1516   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1517   for (link = current_binding_level->type_shadowed;
1518        link; link = TREE_CHAIN (link))
1519     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1520
1521   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1522   for (link = current_binding_level->shadowed_labels;
1523        link;
1524        link = TREE_CHAIN (link))
1525     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1526
1527   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1528      list if a `using' declaration put them there.  The debugging
1529      back-ends won't understand OVERLOAD, so we remove them here.
1530      Because the BLOCK_VARS are (temporarily) shared with
1531      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1532      popped all the bindings.  */
1533   if (block)
1534     {
1535       tree* d;
1536
1537       for (d = &BLOCK_VARS (block); *d; )
1538         {
1539           if (TREE_CODE (*d) == TREE_LIST)
1540             *d = TREE_CHAIN (*d);
1541           else
1542             d = &TREE_CHAIN (*d);
1543         }
1544     }
1545
1546   /* If the level being exited is the top level of a function,
1547      check over all the labels.  */
1548   if (functionbody)
1549     {
1550       /* Since this is the top level block of a function, the vars are
1551          the function's parameters.  Don't leave them in the BLOCK
1552          because they are found in the FUNCTION_DECL instead.  */
1553       BLOCK_VARS (block) = 0;
1554       pop_labels (block);
1555     }
1556
1557   tmp = current_binding_level->keep;
1558
1559   pop_binding_level ();
1560   if (functionbody)
1561     DECL_INITIAL (current_function_decl) = block;
1562   else if (block)
1563     current_binding_level->blocks
1564       = chainon (current_binding_level->blocks, block);
1565
1566   /* If we did not make a block for the level just exited,
1567      any blocks made for inner levels
1568      (since they cannot be recorded as subblocks in that level)
1569      must be carried forward so they will later become subblocks
1570      of something else.  */
1571   else if (subblocks)
1572     current_binding_level->blocks
1573       = chainon (current_binding_level->blocks, subblocks);
1574
1575   /* Each and every BLOCK node created here in `poplevel' is important
1576      (e.g. for proper debugging information) so if we created one
1577      earlier, mark it as "used".  */
1578   if (block)
1579     TREE_USED (block) = 1;
1580
1581   /* Take care of compiler's internal binding structures.  */
1582   if (tmp == 2)
1583     {
1584       tree scope_stmts;
1585
1586       scope_stmts
1587         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1588       if (block)
1589         {
1590           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1591           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1592         }
1593
1594       block = poplevel (keep, reverse, functionbody);
1595     }
1596
1597   return block;
1598 }
1599
1600 /* Delete the node BLOCK from the current binding level.
1601    This is used for the block inside a stmt expr ({...})
1602    so that the block can be reinserted where appropriate.  */
1603
1604 void
1605 delete_block (block)
1606      tree block;
1607 {
1608   tree t;
1609   if (current_binding_level->blocks == block)
1610     current_binding_level->blocks = TREE_CHAIN (block);
1611   for (t = current_binding_level->blocks; t;)
1612     {
1613       if (TREE_CHAIN (t) == block)
1614         TREE_CHAIN (t) = TREE_CHAIN (block);
1615       else
1616         t = TREE_CHAIN (t);
1617     }
1618   TREE_CHAIN (block) = NULL_TREE;
1619   /* Clear TREE_USED which is always set by poplevel.
1620      The flag is set again if insert_block is called.  */
1621   TREE_USED (block) = 0;
1622 }
1623
1624 /* Insert BLOCK at the end of the list of subblocks of the
1625    current binding level.  This is used when a BIND_EXPR is expanded,
1626    to handle the BLOCK node inside the BIND_EXPR.  */
1627
1628 void
1629 insert_block (block)
1630      tree block;
1631 {
1632   TREE_USED (block) = 1;
1633   current_binding_level->blocks
1634     = chainon (current_binding_level->blocks, block);
1635 }
1636
1637 /* Set the BLOCK node for the innermost scope
1638    (the one we are currently in).  */
1639
1640 void
1641 set_block (block)
1642     tree block ATTRIBUTE_UNUSED;
1643 {
1644   /* The RTL expansion machinery requires us to provide this callback,
1645      but it is not applicable in function-at-a-time mode.  */
1646   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1647 }
1648
1649 /* Do a pushlevel for class declarations.  */
1650
1651 void
1652 pushlevel_class ()
1653 {
1654   register struct binding_level *newlevel;
1655
1656   /* Reuse or create a struct for this binding level.  */
1657 #if defined(DEBUG_CP_BINDING_LEVELS)
1658   if (0)
1659 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1660   if (free_binding_level)
1661 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1662     {
1663       newlevel = free_binding_level;
1664       free_binding_level = free_binding_level->level_chain;
1665     }
1666   else
1667     newlevel = make_binding_level ();
1668
1669 #if defined(DEBUG_CP_BINDING_LEVELS)
1670   is_class_level = 1;
1671 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1672
1673   push_binding_level (newlevel, 0, 0);
1674
1675   class_binding_level = current_binding_level;
1676   class_binding_level->parm_flag = 2;
1677   class_binding_level->this_class = current_class_type;
1678 }
1679
1680 /* ...and a poplevel for class declarations.  */
1681
1682 void
1683 poplevel_class ()
1684 {
1685   register struct binding_level *level = class_binding_level;
1686   tree shadowed;
1687
1688   my_friendly_assert (level != 0, 354);
1689
1690   /* If we're leaving a toplevel class, don't bother to do the setting
1691      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1692      shouldn't even be used when current_class_type isn't set, and second,
1693      if we don't touch it here, we're able to use the cache effect if the
1694      next time we're entering a class scope, it is the same class.  */
1695   if (current_class_depth != 1)
1696     {
1697       struct binding_level* b;
1698
1699       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1700       for (shadowed = level->class_shadowed;
1701            shadowed;
1702            shadowed = TREE_CHAIN (shadowed))
1703         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1704
1705       /* Find the next enclosing class, and recreate
1706          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1707       b = level->level_chain;
1708       while (b && b->parm_flag != 2)
1709         b = b->level_chain;
1710
1711       if (b)
1712         for (shadowed = b->class_shadowed;
1713              shadowed;
1714              shadowed = TREE_CHAIN (shadowed))
1715           {
1716             tree t;
1717
1718             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1719             while (t && BINDING_LEVEL (t) != b)
1720               t = TREE_CHAIN (t);
1721
1722             if (t)
1723               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1724                 = BINDING_VALUE (t);
1725           }
1726     }
1727   else
1728     /* Remember to save what IDENTIFIER's were bound in this scope so we
1729        can recover from cache misses.  */
1730     {
1731       previous_class_type = current_class_type;
1732       previous_class_values = class_binding_level->class_shadowed;
1733     }
1734   for (shadowed = level->type_shadowed;
1735        shadowed;
1736        shadowed = TREE_CHAIN (shadowed))
1737     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1738
1739   /* Remove the bindings for all of the class-level declarations.  */
1740   for (shadowed = level->class_shadowed;
1741        shadowed;
1742        shadowed = TREE_CHAIN (shadowed))
1743     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1744
1745   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1746                       (HOST_WIDE_INT) class_binding_level->level_chain,
1747                       class_binding_level->parm_flag,
1748                       class_binding_level->keep);
1749
1750   /* Now, pop out of the binding level which we created up in the
1751      `pushlevel_class' routine.  */
1752 #if defined(DEBUG_CP_BINDING_LEVELS)
1753   is_class_level = 1;
1754 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1755
1756   pop_binding_level ();
1757 }
1758
1759 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1760    for any names in enclosing classes.  */
1761
1762 void
1763 clear_identifier_class_values ()
1764 {
1765   tree t;
1766
1767   if (!class_binding_level)
1768     return;
1769
1770   for (t = class_binding_level->class_shadowed;
1771        t;
1772        t = TREE_CHAIN (t))
1773     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1774 }
1775
1776 /* Returns non-zero if T is a virtual function table.  */
1777
1778 int
1779 vtable_decl_p (t, data)
1780      tree t;
1781      void *data ATTRIBUTE_UNUSED;
1782 {
1783   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1784 }
1785
1786 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1787    functions.  */
1788
1789 int
1790 vtype_decl_p (t, data)
1791      tree t;
1792      void *data ATTRIBUTE_UNUSED;
1793 {
1794   return (TREE_CODE (t) == TYPE_DECL
1795           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1796           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1797 }
1798
1799 /* Return the declarations that are members of the namespace NS.  */
1800
1801 tree
1802 cp_namespace_decls (ns)
1803      tree ns;
1804 {
1805   return NAMESPACE_LEVEL (ns)->names;
1806 }
1807
1808 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1809    itself, calling F for each.  The DATA is passed to F as well.  */
1810
1811 static int
1812 walk_namespaces_r (namespace, f, data)
1813      tree namespace;
1814      walk_namespaces_fn f;
1815      void *data;
1816 {
1817   tree current;
1818   int result = 0;
1819
1820   result |= (*f) (namespace, data);
1821
1822   for (current = cp_namespace_decls (namespace);
1823        current;
1824        current = TREE_CHAIN (current))
1825     {
1826       if (TREE_CODE (current) != NAMESPACE_DECL
1827           || DECL_NAMESPACE_ALIAS (current))
1828         continue;
1829       if (!DECL_LANG_SPECIFIC (current))
1830         {
1831           /* Hmm. std. */
1832           my_friendly_assert (current == std_node, 393);
1833           continue;
1834         }
1835
1836       /* We found a namespace.  */
1837       result |= walk_namespaces_r (current, f, data);
1838     }
1839
1840   return result;
1841 }
1842
1843 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1844    F as well.  */
1845
1846 int
1847 walk_namespaces (f, data)
1848      walk_namespaces_fn f;
1849      void *data;
1850 {
1851   return walk_namespaces_r (global_namespace, f, data);
1852 }
1853
1854 struct walk_globals_data {
1855   walk_globals_pred p;
1856   walk_globals_fn f;
1857   void *data;
1858 };
1859
1860 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1861    for which P returns non-zero, call F with its address.  If any call
1862    to F returns a non-zero value, return a non-zero value.  */
1863
1864 static int
1865 walk_globals_r (namespace, data)
1866      tree namespace;
1867      void *data;
1868 {
1869   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1870   walk_globals_pred p = wgd->p;
1871   walk_globals_fn f = wgd->f;
1872   void *d = wgd->data;
1873   tree *t;
1874   int result = 0;
1875
1876   t = &NAMESPACE_LEVEL (namespace)->names;
1877
1878   while (*t)
1879     {
1880       tree glbl = *t;
1881
1882       if ((*p) (glbl, d))
1883         result |= (*f) (t, d);
1884
1885       /* If F changed *T, then *T still points at the next item to
1886          examine.  */
1887       if (*t == glbl)
1888         t = &TREE_CHAIN (*t);
1889     }
1890
1891   return result;
1892 }
1893
1894 /* Walk the global declarations.  Whenever one is found for which P
1895    returns non-zero, call F with its address.  If any call to F
1896    returns a non-zero value, return a non-zero value.  */
1897
1898 int
1899 walk_globals (p, f, data)
1900      walk_globals_pred p;
1901      walk_globals_fn f;
1902      void *data;
1903 {
1904   struct walk_globals_data wgd;
1905   wgd.p = p;
1906   wgd.f = f;
1907   wgd.data = data;
1908
1909   return walk_namespaces (walk_globals_r, &wgd);
1910 }
1911
1912 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1913    DATA is non-NULL, this is the last time we will call
1914    wrapup_global_declarations for this NAMESPACE.  */
1915
1916 int
1917 wrapup_globals_for_namespace (namespace, data)
1918      tree namespace;
1919      void *data;
1920 {
1921   tree globals = cp_namespace_decls (namespace);
1922   int len = list_length (globals);
1923   tree *vec = (tree *) alloca (sizeof (tree) * len);
1924   int i;
1925   int result;
1926   tree decl;
1927   int last_time = (data != 0);
1928
1929   if (last_time && namespace == global_namespace)
1930     /* Let compile_file handle the global namespace.  */
1931     return 0;
1932
1933   /* Process the decls in reverse order--earliest first.
1934      Put them into VEC from back to front, then take out from front.  */
1935
1936   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1937     {
1938       /* Pretend we've output an unused static variable.  This ensures
1939          that the toplevel __FUNCTION__ etc won't be emitted, unless
1940          needed. */
1941       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1942           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1943         {
1944           TREE_ASM_WRITTEN (decl) = 1;
1945           DECL_IGNORED_P (decl) = 1;
1946         }
1947       vec[len - i - 1] = decl;
1948     }
1949
1950   if (last_time)
1951     {
1952       check_global_declarations (vec, len);
1953       return 0;
1954     }
1955
1956   /* Temporarily mark vtables as external.  That prevents
1957      wrapup_global_declarations from writing them out; we must process
1958      them ourselves in finish_vtable_vardecl.  */
1959   for (i = 0; i < len; ++i)
1960     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1961       {
1962         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1963         DECL_EXTERNAL (vec[i]) = 1;
1964       }
1965
1966   /* Write out any globals that need to be output.  */
1967   result = wrapup_global_declarations (vec, len);
1968
1969   /* Undo the hack to DECL_EXTERNAL above.  */
1970   for (i = 0; i < len; ++i)
1971     if (vtable_decl_p (vec[i], /*data=*/0)
1972         && DECL_NOT_REALLY_EXTERN (vec[i]))
1973       {
1974         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1975         DECL_EXTERNAL (vec[i]) = 0;
1976       }
1977
1978   return result;
1979 }
1980
1981 \f
1982 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1983
1984 static void
1985 mark_binding_level (arg)
1986      void *arg;
1987 {
1988   struct binding_level *lvl = *(struct binding_level **)arg;
1989
1990   for (; lvl; lvl = lvl->level_chain)
1991     {
1992       ggc_mark_tree (lvl->names);
1993       ggc_mark_tree (lvl->tags);
1994       ggc_mark_tree (lvl->usings);
1995       ggc_mark_tree (lvl->using_directives);
1996       ggc_mark_tree (lvl->class_shadowed);
1997       ggc_mark_tree (lvl->type_shadowed);
1998       ggc_mark_tree (lvl->shadowed_labels);
1999       ggc_mark_tree (lvl->blocks);
2000       ggc_mark_tree (lvl->this_class);
2001       ggc_mark_tree (lvl->incomplete);
2002       ggc_mark_tree (lvl->dead_vars_from_for);
2003     }
2004 }
2005
2006 static void
2007 mark_named_label_lists (labs, uses)
2008      void *labs;
2009      void *uses;
2010 {
2011   struct named_label_list *l = *(struct named_label_list **)labs;
2012   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2013
2014   for (; l; l = l->next)
2015     {
2016       ggc_mark (l);
2017       mark_binding_level (l->binding_level);
2018       ggc_mark_tree (l->old_value);
2019       ggc_mark_tree (l->label_decl);
2020       ggc_mark_tree (l->bad_decls);
2021     }
2022
2023   for (; u; u = u->next)
2024     ggc_mark (u);
2025 }
2026 \f
2027 /* For debugging.  */
2028 static int no_print_functions = 0;
2029 static int no_print_builtins = 0;
2030
2031 void
2032 print_binding_level (lvl)
2033      struct binding_level *lvl;
2034 {
2035   tree t;
2036   int i = 0, len;
2037   fprintf (stderr, " blocks=");
2038   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2039   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2040            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2041   if (lvl->tag_transparent)
2042     fprintf (stderr, " tag-transparent");
2043   if (lvl->more_cleanups_ok)
2044     fprintf (stderr, " more-cleanups-ok");
2045   if (lvl->have_cleanups)
2046     fprintf (stderr, " have-cleanups");
2047   fprintf (stderr, "\n");
2048   if (lvl->names)
2049     {
2050       fprintf (stderr, " names:\t");
2051       /* We can probably fit 3 names to a line?  */
2052       for (t = lvl->names; t; t = TREE_CHAIN (t))
2053         {
2054           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2055             continue;
2056           if (no_print_builtins
2057               && (TREE_CODE (t) == TYPE_DECL)
2058               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2059             continue;
2060
2061           /* Function decls tend to have longer names.  */
2062           if (TREE_CODE (t) == FUNCTION_DECL)
2063             len = 3;
2064           else
2065             len = 2;
2066           i += len;
2067           if (i > 6)
2068             {
2069               fprintf (stderr, "\n\t");
2070               i = len;
2071             }
2072           print_node_brief (stderr, "", t, 0);
2073           if (t == error_mark_node)
2074             break;
2075         }
2076       if (i)
2077         fprintf (stderr, "\n");
2078     }
2079   if (lvl->tags)
2080     {
2081       fprintf (stderr, " tags:\t");
2082       i = 0;
2083       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2084         {
2085           if (TREE_PURPOSE (t) == NULL_TREE)
2086             len = 3;
2087           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2088             len = 2;
2089           else
2090             len = 4;
2091           i += len;
2092           if (i > 5)
2093             {
2094               fprintf (stderr, "\n\t");
2095               i = len;
2096             }
2097           if (TREE_PURPOSE (t) == NULL_TREE)
2098             {
2099               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2100               fprintf (stderr, ">");
2101             }
2102           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2103             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2104           else
2105             {
2106               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2107               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2108               fprintf (stderr, ">");
2109             }
2110         }
2111       if (i)
2112         fprintf (stderr, "\n");
2113     }
2114   if (lvl->class_shadowed)
2115     {
2116       fprintf (stderr, " class-shadowed:");
2117       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2118         {
2119           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2120         }
2121       fprintf (stderr, "\n");
2122     }
2123   if (lvl->type_shadowed)
2124     {
2125       fprintf (stderr, " type-shadowed:");
2126       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2127         {
2128           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2129         }
2130       fprintf (stderr, "\n");
2131     }
2132 }
2133
2134 void
2135 print_other_binding_stack (stack)
2136      struct binding_level *stack;
2137 {
2138   struct binding_level *level;
2139   for (level = stack; level != global_binding_level; level = level->level_chain)
2140     {
2141       fprintf (stderr, "binding level ");
2142       fprintf (stderr, HOST_PTR_PRINTF, level);
2143       fprintf (stderr, "\n");
2144       print_binding_level (level);
2145     }
2146 }
2147
2148 void
2149 print_binding_stack ()
2150 {
2151   struct binding_level *b;
2152   fprintf (stderr, "current_binding_level=");
2153   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2154   fprintf (stderr, "\nclass_binding_level=");
2155   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2156   fprintf (stderr, "\nglobal_binding_level=");
2157   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2158   fprintf (stderr, "\n");
2159   if (class_binding_level)
2160     {
2161       for (b = class_binding_level; b; b = b->level_chain)
2162         if (b == current_binding_level)
2163           break;
2164       if (b)
2165         b = class_binding_level;
2166       else
2167         b = current_binding_level;
2168     }
2169   else
2170     b = current_binding_level;
2171   print_other_binding_stack (b);
2172   fprintf (stderr, "global:\n");
2173   print_binding_level (global_binding_level);
2174 }
2175
2176 /* Namespace binding access routines: The namespace_bindings field of
2177    the identifier is polymorphic, with three possible values:
2178    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2179    indicating the BINDING_VALUE of global_namespace. */
2180
2181 /* Check whether the a binding for the name to scope is known.
2182    Assumes that the bindings of the name are already a list
2183    of bindings. Returns the binding found, or NULL_TREE. */
2184
2185 static tree
2186 find_binding (name, scope)
2187      tree name;
2188      tree scope;
2189 {
2190   tree iter, prev = NULL_TREE;
2191
2192   scope = ORIGINAL_NAMESPACE (scope);
2193
2194   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2195        iter = TREE_CHAIN (iter))
2196     {
2197       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2198       if (BINDING_SCOPE (iter) == scope)
2199         {
2200           /* Move binding found to the front of the list, so
2201              subsequent lookups will find it faster. */
2202           if (prev)
2203             {
2204               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2205               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2206               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2207             }
2208           return iter;
2209         }
2210       prev = iter;
2211     }
2212   return NULL_TREE;
2213 }
2214
2215 /* Always returns a binding for name in scope. If the
2216    namespace_bindings is not a list, convert it to one first.
2217    If no binding is found, make a new one. */
2218
2219 tree
2220 binding_for_name (name, scope)
2221      tree name;
2222      tree scope;
2223 {
2224   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2225   tree result;
2226
2227   scope = ORIGINAL_NAMESPACE (scope);
2228
2229   if (b && TREE_CODE (b) != CPLUS_BINDING)
2230     {
2231       /* Get rid of optimization for global scope. */
2232       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2233       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2234       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2235     }
2236   if (b && (result = find_binding (name, scope)))
2237     return result;
2238   /* Not found, make a new one. */
2239   result = make_node (CPLUS_BINDING);
2240   TREE_CHAIN (result) = b;
2241   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2242   BINDING_SCOPE (result) = scope;
2243   BINDING_TYPE (result) = NULL_TREE;
2244   BINDING_VALUE (result) = NULL_TREE;
2245   return result;
2246 }
2247
2248 /* Return the binding value for name in scope, considering that
2249    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2250
2251 tree
2252 namespace_binding (name, scope)
2253      tree name;
2254      tree scope;
2255 {
2256   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2257   if (b == NULL_TREE)
2258     return NULL_TREE;
2259   if (scope == NULL_TREE)
2260     scope = global_namespace;
2261   if (TREE_CODE (b) != CPLUS_BINDING)
2262     return (scope == global_namespace) ? b : NULL_TREE;
2263   name = find_binding (name,scope);
2264   if (name == NULL_TREE)
2265     return name;
2266   return BINDING_VALUE (name);
2267 }
2268
2269 /* Set the binding value for name in scope. If modifying the binding
2270    of global_namespace is attempted, try to optimize it. */
2271
2272 void
2273 set_namespace_binding (name, scope, val)
2274      tree name;
2275      tree scope;
2276      tree val;
2277 {
2278   tree b;
2279
2280   if (scope == NULL_TREE)
2281     scope = global_namespace;
2282
2283   if (scope == global_namespace)
2284     {
2285       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2286       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2287         {
2288           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2289           return;
2290         }
2291     }
2292   b = binding_for_name (name, scope);
2293   BINDING_VALUE (b) = val;
2294 }
2295
2296 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2297    select a name that is unique to this compilation unit.  */
2298
2299 void
2300 push_namespace (name)
2301      tree name;
2302 {
2303   tree d = NULL_TREE;
2304   int need_new = 1;
2305   int implicit_use = 0;
2306   int global = 0;
2307   if (!global_namespace)
2308     {
2309       /* This must be ::. */
2310       my_friendly_assert (name == get_identifier ("::"), 377);
2311       global = 1;
2312     }
2313   else if (!name)
2314     {
2315       /* The name of anonymous namespace is unique for the translation
2316          unit.  */
2317       if (!anonymous_namespace_name)
2318         anonymous_namespace_name = get_file_function_name ('N');
2319       name = anonymous_namespace_name;
2320       d = IDENTIFIER_NAMESPACE_VALUE (name);
2321       if (d)
2322         /* Reopening anonymous namespace.  */
2323         need_new = 0;
2324       implicit_use = 1;
2325     }
2326   else if (current_namespace == global_namespace
2327            && name == DECL_NAME (std_node))
2328     {
2329       in_std++;
2330       return;
2331     }
2332   else
2333     {
2334       /* Check whether this is an extended namespace definition. */
2335       d = IDENTIFIER_NAMESPACE_VALUE (name);
2336       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2337         {
2338           need_new = 0;
2339           if (DECL_NAMESPACE_ALIAS (d))
2340             {
2341               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2342                         d, DECL_NAMESPACE_ALIAS (d));
2343               d = DECL_NAMESPACE_ALIAS (d);
2344             }
2345         }
2346     }
2347
2348   if (need_new)
2349     {
2350       /* Make a new namespace, binding the name to it. */
2351       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2352       /* The global namespace is not pushed, and the global binding
2353          level is set elsewhere.  */
2354       if (!global)
2355         {
2356           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2357           d = pushdecl (d);
2358           pushlevel (0);
2359           declare_namespace_level ();
2360           NAMESPACE_LEVEL (d) = current_binding_level;
2361         }
2362     }
2363   else
2364     resume_binding_level (NAMESPACE_LEVEL (d));
2365
2366   if (implicit_use)
2367     do_using_directive (d);
2368   /* Enter the name space. */
2369   current_namespace = d;
2370 }
2371
2372 /* Pop from the scope of the current namespace.  */
2373
2374 void
2375 pop_namespace ()
2376 {
2377   if (current_namespace == global_namespace)
2378     {
2379       my_friendly_assert (in_std>0, 980421);
2380       in_std--;
2381       return;
2382     }
2383   current_namespace = CP_DECL_CONTEXT (current_namespace);
2384   /* The binding level is not popped, as it might be re-opened later.  */
2385   suspend_binding_level ();
2386 }
2387
2388 /* Push into the scope of the namespace NS, even if it is deeply
2389    nested within another namespace.  */
2390
2391 void
2392 push_nested_namespace (ns)
2393      tree ns;
2394 {
2395   if (ns == global_namespace)
2396     push_to_top_level ();
2397   else
2398     {
2399       push_nested_namespace (CP_DECL_CONTEXT (ns));
2400       push_namespace (DECL_NAME (ns));
2401     }
2402 }
2403
2404 /* Pop back from the scope of the namespace NS, which was previously
2405    entered with push_nested_namespace.  */
2406
2407 void
2408 pop_nested_namespace (ns)
2409      tree ns;
2410 {
2411   while (ns != global_namespace)
2412     {
2413       pop_namespace ();
2414       ns = CP_DECL_CONTEXT (ns);
2415     }
2416
2417   pop_from_top_level ();
2418 }
2419
2420 \f
2421 /* Subroutines for reverting temporarily to top-level for instantiation
2422    of templates and such.  We actually need to clear out the class- and
2423    local-value slots of all identifiers, so that only the global values
2424    are at all visible.  Simply setting current_binding_level to the global
2425    scope isn't enough, because more binding levels may be pushed.  */
2426 struct saved_scope *scope_chain;
2427
2428 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2429
2430 static void
2431 mark_saved_scope (arg)
2432      void *arg;
2433 {
2434   struct saved_scope *t = *(struct saved_scope **)arg;
2435   while (t)
2436     {
2437       mark_binding_level (&t->class_bindings);
2438       ggc_mark_tree (t->old_bindings);
2439       ggc_mark_tree (t->old_namespace);
2440       ggc_mark_tree (t->class_name);
2441       ggc_mark_tree (t->class_type);
2442       ggc_mark_tree (t->access_specifier);
2443       ggc_mark_tree (t->function_decl);
2444       if (t->lang_base)
2445         ggc_mark_tree_varray (t->lang_base);
2446       ggc_mark_tree (t->lang_name);
2447       ggc_mark_tree (t->template_parms);
2448       ggc_mark_tree (t->x_previous_class_type);
2449       ggc_mark_tree (t->x_previous_class_values);
2450       ggc_mark_tree (t->x_saved_tree);
2451       ggc_mark_tree (t->incomplete);
2452       ggc_mark_tree (t->lookups);
2453
2454       mark_stmt_tree (&t->x_stmt_tree);
2455       mark_binding_level (&t->bindings);
2456       t = t->prev;
2457     }
2458 }
2459
2460 static tree
2461 store_bindings (names, old_bindings)
2462      tree names, old_bindings;
2463 {
2464   tree t;
2465   for (t = names; t; t = TREE_CHAIN (t))
2466     {
2467       tree binding, t1, id;
2468
2469       if (TREE_CODE (t) == TREE_LIST)
2470         id = TREE_PURPOSE (t);
2471       else
2472         id = DECL_NAME (t);
2473
2474       if (!id
2475           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2476              we have no IDENTIFIER_BINDING if we have left the class
2477              scope, but cached the class-level declarations.  */
2478           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2479         continue;
2480
2481       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2482         if (TREE_VEC_ELT (t1, 0) == id)
2483           goto skip_it;
2484
2485       binding = make_tree_vec (4);
2486
2487       if (id)
2488         {
2489           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2490           TREE_VEC_ELT (binding, 0) = id;
2491           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2492           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2493           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2494           IDENTIFIER_BINDING (id) = NULL_TREE;
2495           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2496         }
2497       TREE_CHAIN (binding) = old_bindings;
2498       old_bindings = binding;
2499     skip_it:
2500       ;
2501     }
2502   return old_bindings;
2503 }
2504
2505 void
2506 maybe_push_to_top_level (pseudo)
2507      int pseudo;
2508 {
2509   struct saved_scope *s;
2510   struct binding_level *b;
2511   tree old_bindings;
2512   int need_pop;
2513
2514   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2515
2516   b = scope_chain ? current_binding_level : 0;
2517
2518   /* If we're in the middle of some function, save our state.  */
2519   if (cfun)
2520     {
2521       need_pop = 1;
2522       push_function_context_to (NULL_TREE);
2523     }
2524   else
2525     need_pop = 0;
2526
2527   old_bindings = NULL_TREE;
2528   if (scope_chain && previous_class_type)
2529     old_bindings = store_bindings (previous_class_values, old_bindings);
2530
2531   /* Have to include global_binding_level, because class-level decls
2532      aren't listed anywhere useful.  */
2533   for (; b; b = b->level_chain)
2534     {
2535       tree t;
2536
2537       /* Template IDs are inserted into the global level. If they were
2538          inserted into namespace level, finish_file wouldn't find them
2539          when doing pending instantiations. Therefore, don't stop at
2540          namespace level, but continue until :: .  */
2541       if (b == global_binding_level || (pseudo && b->template_parms_p))
2542         break;
2543
2544       old_bindings = store_bindings (b->names, old_bindings);
2545       /* We also need to check class_shadowed to save class-level type
2546          bindings, since pushclass doesn't fill in b->names.  */
2547       if (b->parm_flag == 2)
2548         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2549
2550       /* Unwind type-value slots back to top level.  */
2551       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2552         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2553     }
2554   s->prev = scope_chain;
2555   s->old_bindings = old_bindings;
2556   s->bindings = b;
2557   s->need_pop_function_context = need_pop;
2558   s->function_decl = current_function_decl;
2559
2560   scope_chain = s;
2561   current_function_decl = NULL_TREE;
2562   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2563   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2564   current_lang_name = lang_name_cplusplus;
2565   current_namespace = global_namespace;
2566 }
2567
2568 void
2569 push_to_top_level ()
2570 {
2571   maybe_push_to_top_level (0);
2572 }
2573
2574 void
2575 pop_from_top_level ()
2576 {
2577   struct saved_scope *s = scope_chain;
2578   tree t;
2579
2580   /* Clear out class-level bindings cache.  */
2581   if (previous_class_type)
2582     invalidate_class_lookup_cache ();
2583
2584   VARRAY_FREE (current_lang_base);
2585
2586   scope_chain = s->prev;
2587   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2588     {
2589       tree id = TREE_VEC_ELT (t, 0);
2590       if (id)
2591         {
2592           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2593           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2594           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2595         }
2596     }
2597
2598   /* If we were in the middle of compiling a function, restore our
2599      state.  */
2600   if (s->need_pop_function_context)
2601     pop_function_context_from (NULL_TREE);
2602   current_function_decl = s->function_decl;
2603
2604   free (s);
2605 }
2606 \f
2607 /* Push a definition of struct, union or enum tag "name".
2608    into binding_level "b".   "type" should be the type node,
2609    We assume that the tag "name" is not already defined.
2610
2611    Note that the definition may really be just a forward reference.
2612    In that case, the TYPE_SIZE will be a NULL_TREE.
2613
2614    C++ gratuitously puts all these tags in the name space.  */
2615
2616 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2617    record the shadowed value for this binding contour.  TYPE is
2618    the type that ID maps to.  */
2619
2620 static void
2621 set_identifier_type_value_with_scope (id, type, b)
2622      tree id;
2623      tree type;
2624      struct binding_level *b;
2625 {
2626   if (!b->namespace_p)
2627     {
2628       /* Shadow the marker, not the real thing, so that the marker
2629          gets restored later. */
2630       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2631       b->type_shadowed
2632         = tree_cons (id, old_type_value, b->type_shadowed);
2633     }
2634   else
2635     {
2636       tree binding = binding_for_name (id, current_namespace);
2637       BINDING_TYPE (binding) = type;
2638       /* Store marker instead of real type. */
2639       type = global_type_node;
2640     }
2641   SET_IDENTIFIER_TYPE_VALUE (id, type);
2642 }
2643
2644 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2645
2646 void
2647 set_identifier_type_value (id, type)
2648      tree id;
2649      tree type;
2650 {
2651   set_identifier_type_value_with_scope (id, type, current_binding_level);
2652 }
2653
2654 /* Return the type associated with id. */
2655
2656 tree
2657 identifier_type_value (id)
2658      tree id;
2659 {
2660   /* There is no type with that name, anywhere. */
2661   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2662     return NULL_TREE;
2663   /* This is not the type marker, but the real thing. */
2664   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2665     return REAL_IDENTIFIER_TYPE_VALUE (id);
2666   /* Have to search for it. It must be on the global level, now.
2667      Ask lookup_name not to return non-types. */
2668   id = lookup_name_real (id, 2, 1, 0);
2669   if (id)
2670     return TREE_TYPE (id);
2671   return NULL_TREE;
2672 }
2673
2674 /* Pop off extraneous binding levels left over due to syntax errors.
2675
2676    We don't pop past namespaces, as they might be valid.  */
2677
2678 void
2679 pop_everything ()
2680 {
2681 #ifdef DEBUG_CP_BINDING_LEVELS
2682   fprintf (stderr, "XXX entering pop_everything ()\n");
2683 #endif
2684   while (!toplevel_bindings_p ())
2685     {
2686       if (current_binding_level->parm_flag == 2)
2687         pop_nested_class ();
2688       else
2689         poplevel (0, 0, 0);
2690     }
2691 #ifdef DEBUG_CP_BINDING_LEVELS
2692   fprintf (stderr, "XXX leaving pop_everything ()\n");
2693 #endif
2694 }
2695
2696 /* The type TYPE is being declared.  If it is a class template, or a
2697    specialization of a class template, do any processing required and
2698    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2699    being declared a friend.  B is the binding level at which this TYPE
2700    should be bound.
2701
2702    Returns the TYPE_DECL for TYPE, which may have been altered by this
2703    processing.  */
2704
2705 static tree
2706 maybe_process_template_type_declaration (type, globalize, b)
2707      tree type;
2708      int globalize;
2709      struct binding_level* b;
2710 {
2711   tree decl = TYPE_NAME (type);
2712
2713   if (processing_template_parmlist)
2714     /* You can't declare a new template type in a template parameter
2715        list.  But, you can declare a non-template type:
2716
2717          template <class A*> struct S;
2718
2719        is a forward-declaration of `A'.  */
2720     ;
2721   else
2722     {
2723       maybe_check_template_type (type);
2724
2725       my_friendly_assert (IS_AGGR_TYPE (type)
2726                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2727
2728
2729       if (processing_template_decl)
2730         {
2731           /* This may change after the call to
2732              push_template_decl_real, but we want the original value.  */
2733           tree name = DECL_NAME (decl);
2734
2735           decl = push_template_decl_real (decl, globalize);
2736           /* If the current binding level is the binding level for the
2737              template parameters (see the comment in
2738              begin_template_parm_list) and the enclosing level is a class
2739              scope, and we're not looking at a friend, push the
2740              declaration of the member class into the class scope.  In the
2741              friend case, push_template_decl will already have put the
2742              friend into global scope, if appropriate.  */
2743           if (TREE_CODE (type) != ENUMERAL_TYPE
2744               && !globalize && b->template_parms_p
2745               && b->level_chain->parm_flag == 2)
2746             {
2747               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2748               /* Put this tag on the list of tags for the class, since
2749                  that won't happen below because B is not the class
2750                  binding level, but is instead the pseudo-global level.  */
2751               b->level_chain->tags =
2752                 tree_cons (name, type, b->level_chain->tags);
2753               if (!COMPLETE_TYPE_P (current_class_type))
2754                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2755             }
2756         }
2757     }
2758
2759   return decl;
2760 }
2761
2762 /* In C++, you don't have to write `struct S' to refer to `S'; you
2763    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2764    if the user had written `typedef struct S S'.  Create and return
2765    the TYPE_DECL for TYPE.  */
2766
2767 tree
2768 create_implicit_typedef (name, type)
2769      tree name;
2770      tree type;
2771 {
2772   tree decl;
2773
2774   decl = build_decl (TYPE_DECL, name, type);
2775   DECL_ARTIFICIAL (decl) = 1;
2776   /* There are other implicit type declarations, like the one *within*
2777      a class that allows you to write `S::S'.  We must distinguish
2778      amongst these.  */
2779   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2780   TYPE_NAME (type) = decl;
2781
2782   return decl;
2783 }
2784
2785 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2786    Normally put it into the inner-most non-tag-transparent scope,
2787    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2788    The latter is needed for implicit declarations.  */
2789
2790 void
2791 pushtag (name, type, globalize)
2792      tree name, type;
2793      int globalize;
2794 {
2795   register struct binding_level *b;
2796
2797   b = current_binding_level;
2798   while (b->tag_transparent
2799          || (globalize && b->parm_flag == 2))
2800     b = b->level_chain;
2801
2802   b->tags = tree_cons (name, type, b->tags);
2803
2804   if (name)
2805     {
2806       /* Do C++ gratuitous typedefing.  */
2807       if (IDENTIFIER_TYPE_VALUE (name) != type)
2808         {
2809           register tree d = NULL_TREE;
2810           int in_class = 0;
2811           tree context = TYPE_CONTEXT (type);
2812
2813           if (! context)
2814             {
2815               tree cs = current_scope ();
2816
2817               if (! globalize)
2818                 context = cs;
2819               else if (cs != NULL_TREE && TYPE_P (cs))
2820                 /* When declaring a friend class of a local class, we want
2821                    to inject the newly named class into the scope
2822                    containing the local class, not the namespace scope.  */
2823                 context = decl_function_context (get_type_decl (cs));
2824             }
2825           if (!context)
2826             context = current_namespace;
2827
2828           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2829               || b->parm_flag == 2)
2830             in_class = 1;
2831
2832           if (current_lang_name == lang_name_java)
2833             TYPE_FOR_JAVA (type) = 1;
2834
2835           d = create_implicit_typedef (name, type);
2836           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2837           if (! in_class)
2838             set_identifier_type_value_with_scope (name, type, b);
2839
2840           d = maybe_process_template_type_declaration (type,
2841                                                        globalize, b);
2842
2843           if (b->parm_flag == 2)
2844             {
2845               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2846                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2847                    class.  But if it's a member template class, we
2848                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2849                    is done later.  */
2850                 finish_member_declaration (d);
2851               else
2852                 pushdecl_class_level (d);
2853             }
2854           else
2855             d = pushdecl_with_scope (d, b);
2856
2857           if (ANON_AGGRNAME_P (name))
2858             DECL_IGNORED_P (d) = 1;
2859
2860           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2861           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2862
2863           /* If this is a local class, keep track of it.  We need this
2864              information for name-mangling, and so that it is possible to find
2865              all function definitions in a translation unit in a convenient
2866              way.  (It's otherwise tricky to find a member function definition
2867              it's only pointed to from within a local class.)  */
2868           if (TYPE_CONTEXT (type)
2869               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2870               && !processing_template_decl)
2871             VARRAY_PUSH_TREE (local_classes, type);
2872
2873           if (!uses_template_parms (type))
2874             {
2875               if (flag_new_abi)
2876                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2877               else
2878                 DECL_ASSEMBLER_NAME (d)
2879                   = get_identifier (build_overload_name (type, 1, 1));
2880             }
2881         }
2882       if (b->parm_flag == 2)
2883         {
2884           if (!COMPLETE_TYPE_P (current_class_type))
2885             CLASSTYPE_TAGS (current_class_type) = b->tags;
2886         }
2887     }
2888
2889   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2890     /* Use the canonical TYPE_DECL for this node.  */
2891     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2892   else
2893     {
2894       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2895          will be the tagged type we just added to the current
2896          binding level.  This fake NULL-named TYPE_DECL node helps
2897          dwarfout.c to know when it needs to output a
2898          representation of a tagged type, and it also gives us a
2899          convenient place to record the "scope start" address for
2900          the tagged type.  */
2901
2902       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2903       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2904     }
2905 }
2906
2907 /* Counter used to create anonymous type names.  */
2908
2909 static int anon_cnt = 0;
2910
2911 /* Return an IDENTIFIER which can be used as a name for
2912    anonymous structs and unions.  */
2913
2914 tree
2915 make_anon_name ()
2916 {
2917   char buf[32];
2918
2919   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2920   return get_identifier (buf);
2921 }
2922
2923 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2924    This keeps dbxout from getting confused.  */
2925
2926 void
2927 clear_anon_tags ()
2928 {
2929   register struct binding_level *b;
2930   register tree tags;
2931   static int last_cnt = 0;
2932
2933   /* Fast out if no new anon names were declared.  */
2934   if (last_cnt == anon_cnt)
2935     return;
2936
2937   b = current_binding_level;
2938   while (b->tag_transparent)
2939     b = b->level_chain;
2940   tags = b->tags;
2941   while (tags)
2942     {
2943       /* A NULL purpose means we have already processed all tags
2944          from here to the end of the list.  */
2945       if (TREE_PURPOSE (tags) == NULL_TREE)
2946         break;
2947       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2948         TREE_PURPOSE (tags) = NULL_TREE;
2949       tags = TREE_CHAIN (tags);
2950     }
2951   last_cnt = anon_cnt;
2952 }
2953 \f
2954 /* Subroutine of duplicate_decls: return truthvalue of whether
2955    or not types of these decls match.
2956
2957    For C++, we must compare the parameter list so that `int' can match
2958    `int&' in a parameter position, but `int&' is not confused with
2959    `const int&'.  */
2960
2961 int
2962 decls_match (newdecl, olddecl)
2963      tree newdecl, olddecl;
2964 {
2965   int types_match;
2966
2967   if (newdecl == olddecl)
2968     return 1;
2969
2970   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2971     /* If the two DECLs are not even the same kind of thing, we're not
2972        interested in their types.  */
2973     return 0;
2974
2975   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2976     {
2977       tree f1 = TREE_TYPE (newdecl);
2978       tree f2 = TREE_TYPE (olddecl);
2979       tree p1 = TYPE_ARG_TYPES (f1);
2980       tree p2 = TYPE_ARG_TYPES (f2);
2981
2982       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2983           && ! (DECL_EXTERN_C_P (newdecl)
2984                 && DECL_EXTERN_C_P (olddecl)))
2985         return 0;
2986
2987       if (TREE_CODE (f1) != TREE_CODE (f2))
2988         return 0;
2989
2990       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2991         {
2992           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2993               && (DECL_BUILT_IN (olddecl)
2994 #ifndef NO_IMPLICIT_EXTERN_C
2995                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2996                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2997 #endif
2998               ))
2999             {
3000               types_match = self_promoting_args_p (p1);
3001               if (p1 == void_list_node)
3002                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3003             }
3004 #ifndef NO_IMPLICIT_EXTERN_C
3005           else if (p1 == NULL_TREE
3006                    && (DECL_EXTERN_C_P (olddecl)
3007                        && DECL_IN_SYSTEM_HEADER (olddecl)
3008                        && !DECL_CLASS_SCOPE_P (olddecl))
3009                    && (DECL_EXTERN_C_P (newdecl)
3010                        && DECL_IN_SYSTEM_HEADER (newdecl)
3011                        && !DECL_CLASS_SCOPE_P (newdecl)))
3012             {
3013               types_match = self_promoting_args_p (p2);
3014               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3015             }
3016 #endif
3017           else
3018             types_match = compparms (p1, p2);
3019         }
3020       else
3021         types_match = 0;
3022     }
3023   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3024     {
3025       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3026                                 DECL_TEMPLATE_PARMS (olddecl)))
3027         return 0;
3028
3029       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3030           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3031         return 0;
3032
3033       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3034         types_match = 1;
3035       else
3036         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3037                                    DECL_TEMPLATE_RESULT (newdecl));
3038     }
3039   else
3040     {
3041       if (TREE_TYPE (newdecl) == error_mark_node)
3042         types_match = TREE_TYPE (olddecl) == error_mark_node;
3043       else if (TREE_TYPE (olddecl) == NULL_TREE)
3044         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3045       else if (TREE_TYPE (newdecl) == NULL_TREE)
3046         types_match = 0;
3047       else
3048         types_match = comptypes (TREE_TYPE (newdecl),
3049                                  TREE_TYPE (olddecl),
3050                                  COMPARE_REDECLARATION);
3051     }
3052
3053   return types_match;
3054 }
3055
3056 /* If NEWDECL is `static' and an `extern' was seen previously,
3057    warn about it.  OLDDECL is the previous declaration.
3058
3059    Note that this does not apply to the C++ case of declaring
3060    a variable `extern const' and then later `const'.
3061
3062    Don't complain about built-in functions, since they are beyond
3063    the user's control.  */
3064
3065 static void
3066 warn_extern_redeclared_static (newdecl, olddecl)
3067      tree newdecl, olddecl;
3068 {
3069   static const char *explicit_extern_static_warning
3070     = "`%D' was declared `extern' and later `static'";
3071   static const char *implicit_extern_static_warning
3072     = "`%D' was declared implicitly `extern' and later `static'";
3073
3074   tree name;
3075
3076   if (TREE_CODE (newdecl) == TYPE_DECL
3077       || TREE_CODE (newdecl) == TEMPLATE_DECL
3078       || TREE_CODE (newdecl) == CONST_DECL)
3079     return;
3080
3081   /* Don't get confused by static member functions; that's a different
3082      use of `static'.  */
3083   if (TREE_CODE (newdecl) == FUNCTION_DECL
3084       && DECL_STATIC_FUNCTION_P (newdecl))
3085     return;
3086
3087   /* If the old declaration was `static', or the new one isn't, then
3088      then everything is OK.  */
3089   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3090     return;
3091
3092   /* It's OK to declare a builtin function as `static'.  */
3093   if (TREE_CODE (olddecl) == FUNCTION_DECL
3094       && DECL_ARTIFICIAL (olddecl))
3095     return;
3096
3097   name = DECL_ASSEMBLER_NAME (newdecl);
3098   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3099               ? implicit_extern_static_warning
3100               : explicit_extern_static_warning, newdecl);
3101   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3102 }
3103
3104 /* Handle when a new declaration NEWDECL has the same name as an old
3105    one OLDDECL in the same binding contour.  Prints an error message
3106    if appropriate.
3107
3108    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3109    Otherwise, return 0.  */
3110
3111 int
3112 duplicate_decls (newdecl, olddecl)
3113      tree newdecl, olddecl;
3114 {
3115   unsigned olddecl_uid = DECL_UID (olddecl);
3116   int olddecl_friend = 0, types_match = 0;
3117   int new_defines_function = 0;
3118
3119   if (newdecl == olddecl)
3120     return 1;
3121
3122   types_match = decls_match (newdecl, olddecl);
3123
3124   /* If either the type of the new decl or the type of the old decl is an
3125      error_mark_node, then that implies that we have already issued an
3126      error (earlier) for some bogus type specification, and in that case,
3127      it is rather pointless to harass the user with yet more error message
3128      about the same declaration, so just pretend the types match here.  */
3129   if (TREE_TYPE (newdecl) == error_mark_node
3130       || TREE_TYPE (olddecl) == error_mark_node)
3131     types_match = 1;
3132
3133   /* Check for redeclaration and other discrepancies. */
3134   if (TREE_CODE (olddecl) == FUNCTION_DECL
3135       && DECL_ARTIFICIAL (olddecl))
3136     {
3137       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3138         {
3139           /* If you declare a built-in or predefined function name as static,
3140              the old definition is overridden, but optionally warn this was a
3141              bad choice of name.  */
3142           if (! TREE_PUBLIC (newdecl))
3143             {
3144               if (warn_shadow)
3145                 cp_warning ("shadowing %s function `%#D'",
3146                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3147                             olddecl);
3148               /* Discard the old built-in function.  */
3149               return 0;
3150             }
3151           /* If the built-in is not ansi, then programs can override
3152              it even globally without an error.  */
3153           else if (! DECL_BUILT_IN (olddecl))
3154             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3155                         olddecl, newdecl);
3156           else
3157             {
3158               cp_error ("declaration of `%#D'", newdecl);
3159               cp_error ("conflicts with built-in declaration `%#D'",
3160                         olddecl);
3161             }
3162           return 0;
3163         }
3164       else if (!types_match)
3165         {
3166           if ((DECL_EXTERN_C_P (newdecl)
3167                && DECL_EXTERN_C_P (olddecl))
3168               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3169                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3170             {
3171               /* A near match; override the builtin.  */
3172
3173               if (TREE_PUBLIC (newdecl))
3174                 {
3175                   cp_warning ("new declaration `%#D'", newdecl);
3176                   cp_warning ("ambiguates built-in declaration `%#D'",
3177                               olddecl);
3178                 }
3179               else if (warn_shadow)
3180                 cp_warning ("shadowing %s function `%#D'",
3181                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3182                             olddecl);
3183             }
3184           else
3185             /* Discard the old built-in function.  */
3186             return 0;
3187         }
3188
3189       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3190         {
3191           /* If a builtin function is redeclared as `static', merge
3192              the declarations, but make the original one static.  */
3193           DECL_THIS_STATIC (olddecl) = 1;
3194           TREE_PUBLIC (olddecl) = 0;
3195
3196           /* Make the old declaration consistent with the new one so
3197              that all remnants of the builtin-ness of this function
3198              will be banished.  */
3199           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3200           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3201           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3202           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3203                                        newdecl);
3204         }
3205     }
3206   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3207     {
3208       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3209            && TREE_CODE (newdecl) != TYPE_DECL
3210            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3211                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3212           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3213               && TREE_CODE (olddecl) != TYPE_DECL
3214               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3215                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3216                         == TYPE_DECL))))
3217         {
3218           /* We do nothing special here, because C++ does such nasty
3219              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3220              get shadowed, and know that if we need to find a TYPE_DECL
3221              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3222              slot of the identifier.  */
3223           return 0;
3224         }
3225
3226       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3227            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3228           || (TREE_CODE (olddecl) == FUNCTION_DECL
3229               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3230         return 0;
3231
3232       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3233       if (TREE_CODE (olddecl) == TREE_LIST)
3234         olddecl = TREE_VALUE (olddecl);
3235       cp_error_at ("previous declaration of `%#D'", olddecl);
3236
3237       /* New decl is completely inconsistent with the old one =>
3238          tell caller to replace the old one.  */
3239
3240       return 0;
3241     }
3242   else if (!types_match)
3243     {
3244       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3245         /* These are certainly not duplicate declarations; they're
3246            from different scopes.  */
3247         return 0;
3248
3249       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3250         {
3251           /* The name of a class template may not be declared to refer to
3252              any other template, class, function, object, namespace, value,
3253              or type in the same scope.  */
3254           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3255               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3256             {
3257               cp_error ("declaration of template `%#D'", newdecl);
3258               cp_error_at ("conflicts with previous declaration `%#D'",
3259                            olddecl);
3260             }
3261           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3262                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3263                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3264                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3265                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3266                                            DECL_TEMPLATE_PARMS (olddecl)))
3267             {
3268               cp_error ("new declaration `%#D'", newdecl);
3269               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3270             }
3271           return 0;
3272         }
3273       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3274         {
3275           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3276             {
3277               cp_error ("declaration of C function `%#D' conflicts with",
3278                         newdecl);
3279               cp_error_at ("previous declaration `%#D' here", olddecl);
3280             }
3281           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3282                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3283             {
3284               cp_error ("new declaration `%#D'", newdecl);
3285               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3286             }
3287           else
3288             return 0;
3289         }
3290
3291       /* Already complained about this, so don't do so again.  */
3292       else if (current_class_type == NULL_TREE
3293           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3294         {
3295           cp_error ("conflicting types for `%#D'", newdecl);
3296           cp_error_at ("previous declaration as `%#D'", olddecl);
3297         }
3298     }
3299   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3300             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3301                  && (!DECL_TEMPLATE_INFO (newdecl)
3302                      || (DECL_TI_TEMPLATE (newdecl)
3303                          != DECL_TI_TEMPLATE (olddecl))))
3304                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3305                     && (!DECL_TEMPLATE_INFO (olddecl)
3306                         || (DECL_TI_TEMPLATE (olddecl)
3307                             != DECL_TI_TEMPLATE (newdecl))))))
3308     /* It's OK to have a template specialization and a non-template
3309        with the same type, or to have specializations of two
3310        different templates with the same type.  Note that if one is a
3311        specialization, and the other is an instantiation of the same
3312        template, that we do not exit at this point.  That situation
3313        can occur if we instantiate a template class, and then
3314        specialize one of its methods.  This situation is legal, but
3315        the declarations must be merged in the usual way.  */
3316     return 0;
3317   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3318            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3319                 && !DECL_USE_TEMPLATE (newdecl))
3320                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3321                    && !DECL_USE_TEMPLATE (olddecl))))
3322     /* One of the declarations is a template instantiation, and the
3323        other is not a template at all.  That's OK.  */
3324     return 0;
3325   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3326            && DECL_NAMESPACE_ALIAS (newdecl)
3327            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3328     /* Redeclaration of namespace alias, ignore it. */
3329     return 1;
3330   else
3331     {
3332       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3333       if (errmsg)
3334         {
3335           cp_error (errmsg, newdecl);
3336           if (DECL_NAME (olddecl) != NULL_TREE)
3337             cp_error_at ((DECL_INITIAL (olddecl)
3338                           && namespace_bindings_p ())
3339                          ? "`%#D' previously defined here"
3340                          : "`%#D' previously declared here", olddecl);
3341         }
3342       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3343                && DECL_INITIAL (olddecl) != NULL_TREE
3344                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3345                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3346         {
3347           /* Prototype decl follows defn w/o prototype.  */
3348           cp_warning_at ("prototype for `%#D'", newdecl);
3349           cp_warning_at ("follows non-prototype definition here", olddecl);
3350         }
3351       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3352                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3353         {
3354           /* extern "C" int foo ();
3355              int foo () { bar (); }
3356              is OK.  */
3357           if (current_lang_stack
3358               == &VARRAY_TREE (current_lang_base, 0))
3359             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3360           else
3361             {
3362               cp_error_at ("previous declaration of `%#D' with %L linkage",
3363                            olddecl, DECL_LANGUAGE (olddecl));
3364               cp_error ("conflicts with new declaration with %L linkage",
3365                         DECL_LANGUAGE (newdecl));
3366             }
3367         }
3368
3369       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3370         ;
3371       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3372         {
3373           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3374           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3375           int i = 1;
3376
3377           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3378             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3379
3380           for (; t1 && t1 != void_list_node;
3381                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3382             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3383               {
3384                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3385                                            TREE_PURPOSE (t2)))
3386                   {
3387                     if (pedantic)
3388                       {
3389                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3390                                     i, newdecl);
3391                         cp_pedwarn_at ("after previous specification in `%#D'",
3392                                        olddecl);
3393                       }
3394                   }
3395                 else
3396                   {
3397                     cp_error ("default argument given for parameter %d of `%#D'",
3398                               i, newdecl);
3399                     cp_error_at ("after previous specification in `%#D'",
3400                                  olddecl);
3401                   }
3402               }
3403
3404           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3405               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3406             {
3407               cp_warning ("`%#D' was used before it was declared inline",
3408                           newdecl);
3409               cp_warning_at ("previous non-inline declaration here",
3410                              olddecl);
3411             }
3412         }
3413     }
3414
3415   /* If new decl is `static' and an `extern' was seen previously,
3416      warn about it.  */
3417   warn_extern_redeclared_static (newdecl, olddecl);
3418
3419   /* We have committed to returning 1 at this point.  */
3420   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3421     {
3422       /* Now that functions must hold information normally held
3423          by field decls, there is extra work to do so that
3424          declaration information does not get destroyed during
3425          definition.  */
3426       if (DECL_VINDEX (olddecl))
3427         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3428       if (DECL_VIRTUAL_CONTEXT (olddecl))
3429         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3430       if (DECL_CONTEXT (olddecl))
3431         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3432       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3433         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3434       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3435       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3436       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3437       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3438       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3439       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3440       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3441       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3442
3443       /* Optionally warn about more than one declaration for the same
3444          name, but don't warn about a function declaration followed by a
3445          definition.  */
3446       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3447           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3448           /* Don't warn about extern decl followed by definition. */
3449           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3450           /* Don't warn about friends, let add_friend take care of it. */
3451           && ! DECL_FRIEND_P (newdecl))
3452         {
3453           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3454           cp_warning_at ("previous declaration of `%D'", olddecl);
3455         }
3456     }
3457
3458   /* Deal with C++: must preserve virtual function table size.  */
3459   if (TREE_CODE (olddecl) == TYPE_DECL)
3460     {
3461       register tree newtype = TREE_TYPE (newdecl);
3462       register tree oldtype = TREE_TYPE (olddecl);
3463
3464       if (newtype != error_mark_node && oldtype != error_mark_node
3465           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3466         {
3467           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3468           CLASSTYPE_FRIEND_CLASSES (newtype)
3469             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3470         }
3471
3472       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3473     }
3474
3475   /* Copy all the DECL_... slots specified in the new decl
3476      except for any that we copy here from the old type.  */
3477   DECL_MACHINE_ATTRIBUTES (newdecl)
3478     = merge_machine_decl_attributes (olddecl, newdecl);
3479
3480   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3481     {
3482       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3483       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3484         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3485                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3486
3487       return 1;
3488     }
3489
3490   if (types_match)
3491     {
3492       /* Automatically handles default parameters.  */
3493       tree oldtype = TREE_TYPE (olddecl);
3494       tree newtype;
3495
3496       /* Merge the data types specified in the two decls.  */
3497       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3498
3499       /* If common_type produces a non-typedef type, just use the old type.  */
3500       if (TREE_CODE (newdecl) == TYPE_DECL
3501           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3502         newtype = oldtype;
3503
3504       if (TREE_CODE (newdecl) == VAR_DECL)
3505         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3506       /* Do this after calling `common_type' so that default
3507          parameters don't confuse us.  */
3508       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3509           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3510               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3511         {
3512           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3513                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3514           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3515                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3516
3517           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3518               && DECL_SOURCE_LINE (olddecl) != 0
3519               && flag_exceptions
3520               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3521                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3522             {
3523               cp_error ("declaration of `%F' throws different exceptions",
3524                         newdecl);
3525               cp_error_at ("than previous declaration `%F'", olddecl);
3526             }
3527         }
3528       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3529
3530       /* Lay the type out, unless already done.  */
3531       if (! same_type_p (newtype, oldtype)
3532           && TREE_TYPE (newdecl) != error_mark_node
3533           && !(processing_template_decl && uses_template_parms (newdecl)))
3534         layout_type (TREE_TYPE (newdecl));
3535
3536       if ((TREE_CODE (newdecl) == VAR_DECL
3537            || TREE_CODE (newdecl) == PARM_DECL
3538            || TREE_CODE (newdecl) == RESULT_DECL
3539            || TREE_CODE (newdecl) == FIELD_DECL
3540            || TREE_CODE (newdecl) == TYPE_DECL)
3541           && !(processing_template_decl && uses_template_parms (newdecl)))
3542         layout_decl (newdecl, 0);
3543
3544       /* Merge the type qualifiers.  */
3545       if (TREE_READONLY (newdecl))
3546         TREE_READONLY (olddecl) = 1;
3547       if (TREE_THIS_VOLATILE (newdecl))
3548         TREE_THIS_VOLATILE (olddecl) = 1;
3549
3550       /* Merge the initialization information.  */
3551       if (DECL_INITIAL (newdecl) == NULL_TREE
3552           && DECL_INITIAL (olddecl) != NULL_TREE)
3553         {
3554           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3555           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3556           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3557           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3558               && DECL_LANG_SPECIFIC (newdecl)
3559               && DECL_LANG_SPECIFIC (olddecl))
3560             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3561         }
3562
3563       /* Merge the section attribute.
3564          We want to issue an error if the sections conflict but that must be
3565          done later in decl_attributes since we are called before attributes
3566          are assigned.  */
3567       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3568         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3569
3570       /* Keep the old rtl since we can safely use it.  */
3571       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3572
3573       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3574         {
3575           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3576             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3577           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3578             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3579           DECL_NO_LIMIT_STACK (newdecl)
3580             |= DECL_NO_LIMIT_STACK (olddecl);
3581         }
3582     }
3583   /* If cannot merge, then use the new type and qualifiers,
3584      and don't preserve the old rtl.  */
3585   else
3586     {
3587       /* Clean out any memory we had of the old declaration.  */
3588       tree oldstatic = value_member (olddecl, static_aggregates);
3589       if (oldstatic)
3590         TREE_VALUE (oldstatic) = error_mark_node;
3591
3592       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3593       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3594       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3595       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3596     }
3597
3598   /* Merge the storage class information.  */
3599   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3600   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3601   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3602   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3603   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3604   if (! DECL_EXTERNAL (olddecl))
3605     DECL_EXTERNAL (newdecl) = 0;
3606
3607   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3608     {
3609       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3610       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3611       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3612       DECL_TEMPLATE_INSTANTIATED (newdecl)
3613         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3614       /* Don't really know how much of the language-specific
3615          values we should copy from old to new.  */
3616       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3617       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3618       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3619       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3620       olddecl_friend = DECL_FRIEND_P (olddecl);
3621
3622       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3623       if (TREE_CODE (newdecl) == FUNCTION_DECL
3624           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3625         DECL_BEFRIENDING_CLASSES (newdecl)
3626           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3627                      DECL_BEFRIENDING_CLASSES (olddecl));
3628     }
3629
3630   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3631     {
3632       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3633           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3634         {
3635           /* If newdecl is not a specialization, then it is not a
3636              template-related function at all.  And that means that we
3637              shoud have exited above, returning 0.  */
3638           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3639                               0);
3640
3641           if (TREE_USED (olddecl))
3642             /* From [temp.expl.spec]:
3643
3644                If a template, a member template or the member of a class
3645                template is explicitly specialized then that
3646                specialization shall be declared before the first use of
3647                that specialization that would cause an implicit
3648                instantiation to take place, in every translation unit in
3649                which such a use occurs.  */
3650             cp_error ("explicit specialization of %D after first use",
3651                       olddecl);
3652
3653           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3654         }
3655       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3656
3657       /* If either decl says `inline', this fn is inline, unless its
3658          definition was passed already.  */
3659       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3660         DECL_INLINE (olddecl) = 1;
3661       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3662
3663       if (! types_match)
3664         {
3665           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3666           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3667           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3668         }
3669       if (! types_match || new_defines_function)
3670         {
3671           /* These need to be copied so that the names are available.
3672              Note that if the types do match, we'll preserve inline
3673              info and other bits, but if not, we won't.  */
3674           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3675           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3676         }
3677       if (new_defines_function)
3678         /* If defining a function declared with other language
3679            linkage, use the previously declared language linkage.  */
3680         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3681       else if (types_match)
3682         {
3683           /* If redeclaring a builtin function, and not a definition,
3684              it stays built in.  */
3685           if (DECL_BUILT_IN (olddecl))
3686             {
3687               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3688               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3689               /* If we're keeping the built-in definition, keep the rtl,
3690                  regardless of declaration matches.  */
3691               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3692             }
3693           else
3694             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3695
3696           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3697           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3698             /* Previously saved insns go together with
3699                the function's previous definition.  */
3700             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3701           /* Don't clear out the arguments if we're redefining a function.  */
3702           if (DECL_ARGUMENTS (olddecl))
3703             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3704         }
3705     }
3706
3707   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3708     {
3709       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3710     }
3711
3712   /* Now preserve various other info from the definition.  */
3713   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3714   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3715   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3716   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3717
3718   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3719     {
3720       int function_size;
3721
3722       function_size = sizeof (struct tree_decl);
3723
3724       bcopy ((char *) newdecl + sizeof (struct tree_common),
3725              (char *) olddecl + sizeof (struct tree_common),
3726              function_size - sizeof (struct tree_common));
3727
3728       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3729         {
3730           /* If newdecl is a template instantiation, it is possible that
3731              the following sequence of events has occurred:
3732
3733              o A friend function was declared in a class template.  The
3734              class template was instantiated.
3735
3736              o The instantiation of the friend declaration was
3737              recorded on the instantiation list, and is newdecl.
3738
3739              o Later, however, instantiate_class_template called pushdecl
3740              on the newdecl to perform name injection.  But, pushdecl in
3741              turn called duplicate_decls when it discovered that another
3742              declaration of a global function with the same name already
3743              existed.
3744
3745              o Here, in duplicate_decls, we decided to clobber newdecl.
3746
3747              If we're going to do that, we'd better make sure that
3748              olddecl, and not newdecl, is on the list of
3749              instantiations so that if we try to do the instantiation
3750              again we won't get the clobbered declaration.  */
3751
3752           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3753           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3754
3755           for (; decls; decls = TREE_CHAIN (decls))
3756             if (TREE_VALUE (decls) == newdecl)
3757               TREE_VALUE (decls) = olddecl;
3758         }
3759     }
3760   else
3761     {
3762       bcopy ((char *) newdecl + sizeof (struct tree_common),
3763              (char *) olddecl + sizeof (struct tree_common),
3764              sizeof (struct tree_decl) - sizeof (struct tree_common)
3765              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3766     }
3767
3768   DECL_UID (olddecl) = olddecl_uid;
3769   if (olddecl_friend)
3770     DECL_FRIEND_P (olddecl) = 1;
3771
3772   /* NEWDECL contains the merged attribute lists.
3773      Update OLDDECL to be the same.  */
3774   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3775
3776   return 1;
3777 }
3778
3779 /* Record a decl-node X as belonging to the current lexical scope.
3780    Check for errors (such as an incompatible declaration for the same
3781    name already seen in the same scope).
3782
3783    Returns either X or an old decl for the same name.
3784    If an old decl is returned, it may have been smashed
3785    to agree with what X says.  */
3786
3787 tree
3788 pushdecl (x)
3789      tree x;
3790 {
3791   register tree t;
3792   register tree name;
3793   int need_new_binding;
3794
3795   /* We shouldn't be calling pushdecl when we're generating RTL for a
3796      function that we already did semantic analysis on previously.  */
3797   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3798                       19990913);
3799
3800   need_new_binding = 1;
3801
3802   if (DECL_TEMPLATE_PARM_P (x))
3803     /* Template parameters have no context; they are not X::T even
3804        when declared within a class or namespace.  */
3805     ;
3806   else
3807     {
3808       if (current_function_decl && x != current_function_decl
3809           /* A local declaration for a function doesn't constitute
3810              nesting.  */
3811           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3812           /* A local declaration for an `extern' variable is in the
3813              scope of the current namespace, not the current
3814              function.  */
3815           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3816           && !DECL_CONTEXT (x))
3817         DECL_CONTEXT (x) = current_function_decl;
3818
3819       /* If this is the declaration for a namespace-scope function,
3820          but the declaration itself is in a local scope, mark the
3821          declaration.  */
3822       if (TREE_CODE (x) == FUNCTION_DECL
3823           && DECL_NAMESPACE_SCOPE_P (x)
3824           && current_function_decl
3825           && x != current_function_decl)
3826         DECL_LOCAL_FUNCTION_P (x) = 1;
3827     }
3828
3829   name = DECL_NAME (x);
3830   if (name)
3831     {
3832       int different_binding_level = 0;
3833
3834       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3835         name = TREE_OPERAND (name, 0);
3836
3837       /* In case this decl was explicitly namespace-qualified, look it
3838          up in its namespace context.  */
3839       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3840           && namespace_bindings_p ())
3841         t = namespace_binding (name, DECL_CONTEXT (x));
3842       else
3843         t = lookup_name_current_level (name);
3844
3845       /* [basic.link] If there is a visible declaration of an entity
3846          with linkage having the same name and type, ignoring entities
3847          declared outside the innermost enclosing namespace scope, the
3848          block scope declaration declares that same entity and
3849          receives the linkage of the previous declaration.  */
3850       if (! t && current_function_decl && x != current_function_decl
3851           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3852           && DECL_EXTERNAL (x))
3853         {
3854           /* Look in block scope.  */
3855           t = IDENTIFIER_VALUE (name);
3856           /* Or in the innermost namespace.  */
3857           if (! t)
3858             t = namespace_binding (name, DECL_CONTEXT (x));
3859           /* Does it have linkage?  */
3860           if (t && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3861             t = NULL_TREE;
3862           if (t)
3863             different_binding_level = 1;
3864         }
3865
3866       /* If we are declaring a function, and the result of name-lookup
3867          was an OVERLOAD, look for an overloaded instance that is
3868          actually the same as the function we are declaring.  (If
3869          there is one, we have to merge our declaration with the
3870          previous declaration.)  */
3871       if (t && TREE_CODE (t) == OVERLOAD)
3872         {
3873           tree match;
3874
3875           if (TREE_CODE (x) == FUNCTION_DECL)
3876             for (match = t; match; match = OVL_NEXT (match))
3877               {
3878                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3879                     == DECL_ASSEMBLER_NAME (x))
3880                   break;
3881               }
3882           else
3883             /* Just choose one.  */
3884             match = t;
3885
3886           if (match)
3887             t = OVL_CURRENT (match);
3888           else
3889             t = NULL_TREE;
3890         }
3891
3892       if (t == error_mark_node)
3893         {
3894           /* error_mark_node is 0 for a while during initialization!  */
3895           t = NULL_TREE;
3896           cp_error_at ("`%#D' used prior to declaration", x);
3897         }
3898       else if (t != NULL_TREE)
3899         {
3900           if (different_binding_level)
3901             {
3902               if (decls_match (x, t))
3903                 /* The standard only says that the local extern
3904                    inherits linkage from the previous decl; in
3905                    particular, default args are not shared.  It would
3906                    be nice to propagate inlining info, though.  FIXME.  */
3907                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3908             }
3909           else if (TREE_CODE (t) == PARM_DECL)
3910             {
3911               if (DECL_CONTEXT (t) == NULL_TREE)
3912                 fatal ("parse errors have confused me too much");
3913
3914               /* Check for duplicate params.  */
3915               if (duplicate_decls (x, t))
3916                 return t;
3917             }
3918           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3919                     || DECL_FUNCTION_TEMPLATE_P (x))
3920                    && is_overloaded_fn (t))
3921             /* Don't do anything just yet. */;
3922           else if (t == wchar_decl_node)
3923             {
3924               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3925                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3926
3927               /* Throw away the redeclaration.  */
3928               return t;
3929             }
3930           else if (TREE_CODE (t) != TREE_CODE (x))
3931             {
3932               if (duplicate_decls (x, t))
3933                 return t;
3934             }
3935           else if (duplicate_decls (x, t))
3936             {
3937               if (TREE_CODE (t) == TYPE_DECL)
3938                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3939               else if (TREE_CODE (t) == FUNCTION_DECL)
3940                 check_default_args (t);
3941
3942               return t;
3943             }
3944           else if (DECL_MAIN_P (x))
3945             {
3946               /* A redeclaration of main, but not a duplicate of the
3947                  previous one.
3948
3949                  [basic.start.main]
3950
3951                  This function shall not be overloaded.  */
3952               cp_error_at ("invalid redeclaration of `%D'", t);
3953               cp_error ("as `%D'", x);
3954               /* We don't try to push this declaration since that
3955                  causes a crash.  */
3956               return x;
3957             }
3958         }
3959
3960       check_template_shadow (x);
3961
3962       /* If this is a function conjured up by the backend, massage it
3963          so it looks friendly.  */
3964       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3965         {
3966           retrofit_lang_decl (x);
3967           DECL_LANGUAGE (x) = lang_c;
3968         }
3969
3970       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3971         {
3972           t = push_overloaded_decl (x, PUSH_LOCAL);
3973           if (t != x)
3974             return t;
3975           if (!namespace_bindings_p ())
3976             /* We do not need to create a binding for this name;
3977                push_overloaded_decl will have already done so if
3978                necessary.  */
3979             need_new_binding = 0;
3980         }
3981       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3982         {
3983           t = push_overloaded_decl (x, PUSH_GLOBAL);
3984           if (t == x)
3985             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3986           return t;
3987         }
3988
3989       /* If declaring a type as a typedef, copy the type (unless we're
3990          at line 0), and install this TYPE_DECL as the new type's typedef
3991          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3992       if (TREE_CODE (x) == TYPE_DECL)
3993         {
3994           tree type = TREE_TYPE (x);
3995           if (DECL_SOURCE_LINE (x) == 0)
3996             {
3997               if (TYPE_NAME (type) == 0)
3998                 TYPE_NAME (type) = x;
3999             }
4000           else if (type != error_mark_node && TYPE_NAME (type) != x
4001                    /* We don't want to copy the type when all we're
4002                       doing is making a TYPE_DECL for the purposes of
4003                       inlining.  */
4004                    && (!TYPE_NAME (type)
4005                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4006             {
4007               DECL_ORIGINAL_TYPE (x) = type;
4008               type = build_type_copy (type);
4009               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4010               TYPE_NAME (type) = x;
4011               TREE_TYPE (x) = type;
4012             }
4013
4014           if (type != error_mark_node
4015               && TYPE_NAME (type)
4016               && TYPE_IDENTIFIER (type))
4017             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4018                                                   current_binding_level);
4019
4020         }
4021
4022       /* Multiple external decls of the same identifier ought to match.
4023
4024          We get warnings about inline functions where they are defined.
4025          We get warnings about other functions from push_overloaded_decl.
4026
4027          Avoid duplicate warnings where they are used.  */
4028       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4029         {
4030           tree decl;
4031
4032           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4033           if (decl && TREE_CODE (decl) == OVERLOAD)
4034             decl = OVL_FUNCTION (decl);
4035
4036           if (decl && decl != error_mark_node
4037               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4038               /* If different sort of thing, we already gave an error.  */
4039               && TREE_CODE (decl) == TREE_CODE (x)
4040               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4041             {
4042               cp_pedwarn ("type mismatch with previous external decl", x);
4043               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4044             }
4045         }
4046
4047       /* This name is new in its binding level.
4048          Install the new declaration and return it.  */
4049       if (namespace_bindings_p ())
4050         {
4051           /* Install a global value.  */
4052
4053           /* If the first global decl has external linkage,
4054              warn if we later see static one.  */
4055           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4056             TREE_PUBLIC (name) = 1;
4057
4058           /* Bind the mangled name for the entity.  In the future, we
4059              should not need to do this; mangled names are an
4060              implementation detail of which the front-end should not
4061              need to be aware.  */
4062           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4063                 && t != NULL_TREE)
4064               /* For an ordinary function, we create a binding from
4065                  the mangled name (i.e., NAME) to the DECL.  But, for
4066                  an `extern "C"' function, the mangled name and the
4067                  ordinary name are the same so we need not do this.  */
4068               && !DECL_EXTERN_C_FUNCTION_P (x))
4069             {
4070               tree mangled_name;
4071
4072               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4073                   || TREE_CODE (x) == NAMESPACE_DECL)
4074                 mangled_name = name;
4075               else
4076                 mangled_name = DECL_ASSEMBLER_NAME (x);
4077
4078               if (TREE_CODE (x) == FUNCTION_DECL)
4079                 my_friendly_assert
4080                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4081                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4082               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4083             }
4084
4085           /* Don't forget if the function was used via an implicit decl.  */
4086           if (IDENTIFIER_IMPLICIT_DECL (name)
4087               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4088             TREE_USED (x) = 1;
4089
4090           /* Don't forget if its address was taken in that way.  */
4091           if (IDENTIFIER_IMPLICIT_DECL (name)
4092               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4093             TREE_ADDRESSABLE (x) = 1;
4094
4095           /* Warn about mismatches against previous implicit decl.  */
4096           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4097               /* If this real decl matches the implicit, don't complain.  */
4098               && ! (TREE_CODE (x) == FUNCTION_DECL
4099                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4100             cp_warning
4101               ("`%D' was previously implicitly declared to return `int'", x);
4102
4103           /* If new decl is `static' and an `extern' was seen previously,
4104              warn about it.  */
4105           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4106             warn_extern_redeclared_static (x, t);
4107         }
4108       else
4109         {
4110           /* Here to install a non-global value.  */
4111           tree oldlocal = IDENTIFIER_VALUE (name);
4112           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4113
4114           if (need_new_binding)
4115             {
4116               push_local_binding (name, x, 0);
4117               /* Because push_local_binding will hook X on to the
4118                  current_binding_level's name list, we don't want to
4119                  do that again below.  */
4120               need_new_binding = 0;
4121             }
4122
4123           /* If this is a TYPE_DECL, push it into the type value slot.  */
4124           if (TREE_CODE (x) == TYPE_DECL)
4125             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4126                                                   current_binding_level);
4127
4128           /* Clear out any TYPE_DECL shadowed by a namespace so that
4129              we won't think this is a type.  The C struct hack doesn't
4130              go through namespaces.  */
4131           if (TREE_CODE (x) == NAMESPACE_DECL)
4132             set_identifier_type_value_with_scope (name, NULL_TREE,
4133                                                   current_binding_level);
4134
4135           if (oldlocal)
4136             {
4137               tree d = oldlocal;
4138
4139               while (oldlocal
4140                      && TREE_CODE (oldlocal) == VAR_DECL
4141                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4142                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4143
4144               if (oldlocal == NULL_TREE)
4145                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4146             }
4147
4148           /* If this is an extern function declaration, see if we
4149              have a global definition or declaration for the function.  */
4150           if (oldlocal == NULL_TREE
4151               && DECL_EXTERNAL (x)
4152               && oldglobal != NULL_TREE
4153               && TREE_CODE (x) == FUNCTION_DECL
4154               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4155             {
4156               /* We have one.  Their types must agree.  */
4157               if (decls_match (x, oldglobal))
4158                 /* OK */;
4159               else
4160                 {
4161                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4162                   cp_warning_at ("global declaration `%#D'", oldglobal);
4163                 }
4164             }
4165           /* If we have a local external declaration,
4166              and no file-scope declaration has yet been seen,
4167              then if we later have a file-scope decl it must not be static.  */
4168           if (oldlocal == NULL_TREE
4169               && oldglobal == NULL_TREE
4170               && DECL_EXTERNAL (x)
4171               && TREE_PUBLIC (x))
4172             TREE_PUBLIC (name) = 1;
4173
4174           /* Warn if shadowing an argument at the top level of the body.  */
4175           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4176               /* Inline decls shadow nothing.  */
4177               && !DECL_FROM_INLINE (x)
4178               && TREE_CODE (oldlocal) == PARM_DECL
4179               /* Don't complain if it's from an enclosing function.  */
4180               && DECL_CONTEXT (oldlocal) == current_function_decl
4181               && TREE_CODE (x) != PARM_DECL)
4182             {
4183               /* Go to where the parms should be and see if we
4184                  find them there.  */
4185               struct binding_level *b = current_binding_level->level_chain;
4186
4187               if (cleanup_label)
4188                 b = b->level_chain;
4189
4190               /* ARM $8.3 */
4191               if (b->parm_flag == 1)
4192                 cp_error ("declaration of `%#D' shadows a parameter", name);
4193             }
4194
4195           /* Maybe warn if shadowing something else.  */
4196           if (warn_shadow && !DECL_EXTERNAL (x)
4197               /* Inline decls shadow nothing.  */
4198               && !DECL_FROM_INLINE (x)
4199               /* No shadow warnings for internally generated vars.  */
4200               && ! DECL_ARTIFICIAL (x)
4201               /* No shadow warnings for vars made for inlining.  */
4202               && ! DECL_FROM_INLINE (x))
4203             {
4204               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4205                 warning ("declaration of `%s' shadows a parameter",
4206                         IDENTIFIER_POINTER (name));
4207               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4208                        && current_class_ptr
4209                        && !TREE_STATIC (name))
4210                 warning ("declaration of `%s' shadows a member of `this'",
4211                         IDENTIFIER_POINTER (name));
4212               else if (oldlocal != NULL_TREE)
4213                 warning ("declaration of `%s' shadows previous local",
4214                         IDENTIFIER_POINTER (name));
4215               else if (oldglobal != NULL_TREE)
4216                 /* XXX shadow warnings in outer-more namespaces */
4217                 warning ("declaration of `%s' shadows global declaration",
4218                         IDENTIFIER_POINTER (name));
4219             }
4220         }
4221
4222       if (TREE_CODE (x) == FUNCTION_DECL)
4223         check_default_args (x);
4224
4225       /* Keep count of variables in this level with incomplete type.  */
4226       if (TREE_CODE (x) == VAR_DECL
4227           && TREE_TYPE (x) != error_mark_node
4228           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4229                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4230               /* RTTI TD entries are created while defining the type_info.  */
4231               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4232                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4233         {
4234           if (namespace_bindings_p ())
4235             namespace_scope_incomplete
4236               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4237           else
4238             current_binding_level->incomplete
4239               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4240         }
4241     }
4242
4243   if (need_new_binding)
4244     add_decl_to_level (x,
4245                        DECL_NAMESPACE_SCOPE_P (x)
4246                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4247                        : current_binding_level);
4248
4249   return x;
4250 }
4251
4252 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4253    caller to set DECL_CONTEXT properly.  */
4254
4255 static tree
4256 pushdecl_with_scope (x, level)
4257      tree x;
4258      struct binding_level *level;
4259 {
4260   register struct binding_level *b;
4261   tree function_decl = current_function_decl;
4262
4263   current_function_decl = NULL_TREE;
4264   if (level->parm_flag == 2)
4265     {
4266       b = class_binding_level;
4267       class_binding_level = level;
4268       pushdecl_class_level (x);
4269       class_binding_level = b;
4270     }
4271   else
4272     {
4273       b = current_binding_level;
4274       current_binding_level = level;
4275       x = pushdecl (x);
4276       current_binding_level = b;
4277     }
4278   current_function_decl = function_decl;
4279   return x;
4280 }
4281
4282 /* Like pushdecl, only it places X in the current namespace,
4283    if appropriate.  */
4284
4285 tree
4286 pushdecl_namespace_level (x)
4287      tree x;
4288 {
4289   register struct binding_level *b = current_binding_level;
4290   register tree t;
4291
4292   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4293
4294   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4295      what we want.  */
4296   if (TREE_CODE (x) == TYPE_DECL)
4297     {
4298       tree name = DECL_NAME (x);
4299       tree newval;
4300       tree *ptr = (tree *)0;
4301       for (; b != global_binding_level; b = b->level_chain)
4302         {
4303           tree shadowed = b->type_shadowed;
4304           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4305             if (TREE_PURPOSE (shadowed) == name)
4306               {
4307                 ptr = &TREE_VALUE (shadowed);
4308                 /* Can't break out of the loop here because sometimes
4309                    a binding level will have duplicate bindings for
4310                    PT names.  It's gross, but I haven't time to fix it.  */
4311               }
4312         }
4313       newval = TREE_TYPE (x);
4314       if (ptr == (tree *)0)
4315         {
4316           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4317              up here if this is changed to an assertion.  --KR  */
4318           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4319         }
4320       else
4321         {
4322           *ptr = newval;
4323         }
4324     }
4325   return t;
4326 }
4327
4328 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4329    if appropriate.  */
4330
4331 tree
4332 pushdecl_top_level (x)
4333      tree x;
4334 {
4335   push_to_top_level ();
4336   x = pushdecl_namespace_level (x);
4337   pop_from_top_level ();
4338   return x;
4339 }
4340
4341 /* Make the declaration of X appear in CLASS scope.  */
4342
4343 void
4344 pushdecl_class_level (x)
4345      tree x;
4346 {
4347   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4348      scope looks for the pre-mangled name.  */
4349   register tree name;
4350
4351   if (TREE_CODE (x) == OVERLOAD)
4352     x = OVL_CURRENT (x);
4353   name = DECL_NAME (x);
4354
4355   if (name)
4356     {
4357       push_class_level_binding (name, x);
4358       if (TREE_CODE (x) == TYPE_DECL)
4359         set_identifier_type_value (name, TREE_TYPE (x));
4360     }
4361   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4362     {
4363       tree f;
4364
4365       for (f = TYPE_FIELDS (TREE_TYPE (x));
4366            f;
4367            f = TREE_CHAIN (f))
4368         pushdecl_class_level (f);
4369     }
4370 }
4371
4372 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4373    DECL, or a modified version thereof.  */
4374
4375 tree
4376 maybe_push_decl (decl)
4377      tree decl;
4378 {
4379   tree type = TREE_TYPE (decl);
4380
4381   /* Add this decl to the current binding level, but not if it comes
4382      from another scope, e.g. a static member variable.  TEM may equal
4383      DECL or it may be a previous decl of the same name.  */
4384   if (decl == error_mark_node
4385       || (TREE_CODE (decl) != PARM_DECL
4386           && DECL_CONTEXT (decl) != NULL_TREE
4387           /* Definitions of namespace members outside their namespace are
4388              possible. */
4389           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4390       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4391       || TREE_CODE (type) == UNKNOWN_TYPE
4392       /* The declaration of a template specialization does not affect
4393          the functions available for overload resolution, so we do not
4394          call pushdecl.  */
4395       || (TREE_CODE (decl) == FUNCTION_DECL
4396           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4397     return decl;
4398   else
4399     return pushdecl (decl);
4400 }
4401
4402 /* Make the declaration(s) of X appear in CLASS scope
4403    under the name NAME.  */
4404
4405 void
4406 push_class_level_binding (name, x)
4407      tree name;
4408      tree x;
4409 {
4410   tree binding;
4411   /* The class_binding_level will be NULL if x is a template
4412      parameter name in a member template.  */
4413   if (!class_binding_level)
4414     return;
4415
4416   /* Make sure that this new member does not have the same name
4417      as a template parameter.  */
4418   if (TYPE_BEING_DEFINED (current_class_type))
4419     check_template_shadow (x);
4420
4421   /* If this declaration shadows a declaration from an enclosing
4422      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4423      we leave this class.  Record the shadowed declaration here.  */
4424   binding = IDENTIFIER_BINDING (name);
4425   if (binding
4426       && ((TREE_CODE (x) == OVERLOAD
4427            && BINDING_VALUE (binding)
4428            && is_overloaded_fn (BINDING_VALUE (binding)))
4429           || INHERITED_VALUE_BINDING_P (binding)))
4430     {
4431       tree shadow;
4432       tree old_decl;
4433
4434       /* If the old binding was from a base class, and was for a tag
4435          name, slide it over to make room for the new binding.  The
4436          old binding is still visible if explicitly qualified with a
4437          class-key.  */
4438       if (INHERITED_VALUE_BINDING_P (binding)
4439           && BINDING_VALUE (binding)
4440           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4441           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4442           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4443         {
4444           old_decl = BINDING_TYPE (binding);
4445           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4446           BINDING_VALUE (binding) = NULL_TREE;
4447           INHERITED_VALUE_BINDING_P (binding) = 0;
4448         }
4449       else
4450         old_decl = BINDING_VALUE (binding);
4451
4452       /* There was already a binding for X containing fewer
4453          functions than are named in X.  Find the previous
4454          declaration of X on the class-shadowed list, and update it.  */
4455       for (shadow = class_binding_level->class_shadowed;
4456            shadow;
4457            shadow = TREE_CHAIN (shadow))
4458         if (TREE_PURPOSE (shadow) == name
4459             && TREE_TYPE (shadow) == old_decl)
4460           {
4461             BINDING_VALUE (binding) = x;
4462             INHERITED_VALUE_BINDING_P (binding) = 0;
4463             TREE_TYPE (shadow) = x;
4464             return;
4465           }
4466     }
4467
4468   /* If we didn't replace an existing binding, put the binding on the
4469      stack of bindings for the identifier, and update
4470      IDENTIFIER_CLASS_VALUE.  */
4471   if (push_class_binding (name, x))
4472     {
4473       class_binding_level->class_shadowed
4474         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4475                      class_binding_level->class_shadowed);
4476       /* Record the value we are binding NAME to so that we can know
4477          what to pop later.  */
4478       TREE_TYPE (class_binding_level->class_shadowed) = x;
4479     }
4480 }
4481
4482 /* Insert another USING_DECL into the current binding level, returning
4483    this declaration. If this is a redeclaration, do nothing, and
4484    return NULL_TREE if this not in namespace scope (in namespace
4485    scope, a using decl might extend any previous bindings).  */
4486
4487 tree
4488 push_using_decl (scope, name)
4489      tree scope;
4490      tree name;
4491 {
4492   tree decl;
4493
4494   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4495   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4496   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4497     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4498       break;
4499   if (decl)
4500     return namespace_bindings_p () ? decl : NULL_TREE;
4501   decl = build_lang_decl (USING_DECL, name, void_type_node);
4502   DECL_INITIAL (decl) = scope;
4503   TREE_CHAIN (decl) = current_binding_level->usings;
4504   current_binding_level->usings = decl;
4505   return decl;
4506 }
4507
4508 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4509    changed (i.e. there was already a directive), or the fresh
4510    TREE_LIST otherwise.  */
4511
4512 tree
4513 push_using_directive (used)
4514      tree used;
4515 {
4516   tree ud = current_binding_level->using_directives;
4517   tree iter, ancestor;
4518
4519   /* Check if we already have this. */
4520   if (purpose_member (used, ud) != NULL_TREE)
4521     return NULL_TREE;
4522
4523   /* Recursively add all namespaces used. */
4524   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4525     push_using_directive (TREE_PURPOSE (iter));
4526
4527   ancestor = namespace_ancestor (current_decl_namespace (), used);
4528   ud = current_binding_level->using_directives;
4529   ud = tree_cons (used, ancestor, ud);
4530   current_binding_level->using_directives = ud;
4531   return ud;
4532 }
4533
4534 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4535    other definitions already in place.  We get around this by making
4536    the value of the identifier point to a list of all the things that
4537    want to be referenced by that name.  It is then up to the users of
4538    that name to decide what to do with that list.
4539
4540    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4541    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4542
4543    FLAGS is a bitwise-or of the following values:
4544      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4545                  namespace scope.
4546      PUSH_USING: DECL is being pushed as the result of a using
4547                  declaration.
4548
4549    The value returned may be a previous declaration if we guessed wrong
4550    about what language DECL should belong to (C or C++).  Otherwise,
4551    it's always DECL (and never something that's not a _DECL).  */
4552
4553 tree
4554 push_overloaded_decl (decl, flags)
4555      tree decl;
4556      int flags;
4557 {
4558   tree name = DECL_NAME (decl);
4559   tree old;
4560   tree new_binding;
4561   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4562
4563   if (doing_global)
4564     old = namespace_binding (name, DECL_CONTEXT (decl));
4565   else
4566     old = lookup_name_current_level (name);
4567
4568   if (old)
4569     {
4570       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4571         {
4572           tree t = TREE_TYPE (old);
4573           if (IS_AGGR_TYPE (t) && warn_shadow
4574               && (! DECL_IN_SYSTEM_HEADER (decl)
4575                   || ! DECL_IN_SYSTEM_HEADER (old)))
4576             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4577           old = NULL_TREE;
4578         }
4579       else if (is_overloaded_fn (old))
4580         {
4581           tree tmp;
4582
4583           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4584             {
4585               tree fn = OVL_CURRENT (tmp);
4586
4587               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4588                   && !(flags & PUSH_USING)
4589                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4590                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4591                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4592                           decl, fn);
4593
4594               if (duplicate_decls (decl, fn))
4595                 return fn;
4596             }
4597         }
4598       else if (old == error_mark_node)
4599         /* Ignore the undefined symbol marker.  */
4600         old = NULL_TREE;
4601       else
4602         {
4603           cp_error_at ("previous non-function declaration `%#D'", old);
4604           cp_error ("conflicts with function declaration `%#D'", decl);
4605           return decl;
4606         }
4607     }
4608
4609   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4610     {
4611       if (old && TREE_CODE (old) != OVERLOAD)
4612         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4613       else
4614         new_binding = ovl_cons (decl, old);
4615       if (flags & PUSH_USING)
4616         OVL_USED (new_binding) = 1;
4617     }
4618   else
4619     /* NAME is not ambiguous.  */
4620     new_binding = decl;
4621
4622   if (doing_global)
4623     set_namespace_binding (name, current_namespace, new_binding);
4624   else
4625     {
4626       /* We only create an OVERLOAD if there was a previous binding at
4627          this level, or if decl is a template. In the former case, we
4628          need to remove the old binding and replace it with the new
4629          binding.  We must also run through the NAMES on the binding
4630          level where the name was bound to update the chain.  */
4631
4632       if (TREE_CODE (new_binding) == OVERLOAD && old)
4633         {
4634           tree *d;
4635
4636           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4637                *d;
4638                d = &TREE_CHAIN (*d))
4639             if (*d == old
4640                 || (TREE_CODE (*d) == TREE_LIST
4641                     && TREE_VALUE (*d) == old))
4642               {
4643                 if (TREE_CODE (*d) == TREE_LIST)
4644                   /* Just replace the old binding with the new.  */
4645                   TREE_VALUE (*d) = new_binding;
4646                 else
4647                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4648                   *d = tree_cons (NULL_TREE, new_binding,
4649                                   TREE_CHAIN (*d));
4650
4651                 /* And update the CPLUS_BINDING node.  */
4652                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4653                   = new_binding;
4654                 return decl;
4655               }
4656
4657           /* We should always find a previous binding in this case.  */
4658           my_friendly_abort (0);
4659         }
4660
4661       /* Install the new binding.  */
4662       push_local_binding (name, new_binding, flags);
4663     }
4664
4665   return decl;
4666 }
4667 \f
4668 /* Generate an implicit declaration for identifier FUNCTIONID
4669    as a function of type int ().  Print a warning if appropriate.  */
4670
4671 tree
4672 implicitly_declare (functionid)
4673      tree functionid;
4674 {
4675   register tree decl;
4676
4677   /* We used to reuse an old implicit decl here,
4678      but this loses with inline functions because it can clobber
4679      the saved decl chains.  */
4680   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4681
4682   DECL_EXTERNAL (decl) = 1;
4683   TREE_PUBLIC (decl) = 1;
4684
4685   /* ISO standard says implicit declarations are in the innermost block.
4686      So we record the decl in the standard fashion.  */
4687   pushdecl (decl);
4688   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4689
4690   if (warn_implicit
4691       /* Only one warning per identifier.  */
4692       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4693     {
4694       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4695     }
4696
4697   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4698
4699   return decl;
4700 }
4701
4702 /* Return zero if the declaration NEWDECL is valid
4703    when the declaration OLDDECL (assumed to be for the same name)
4704    has already been seen.
4705    Otherwise return an error message format string with a %s
4706    where the identifier should go.  */
4707
4708 static const char *
4709 redeclaration_error_message (newdecl, olddecl)
4710      tree newdecl, olddecl;
4711 {
4712   if (TREE_CODE (newdecl) == TYPE_DECL)
4713     {
4714       /* Because C++ can put things into name space for free,
4715          constructs like "typedef struct foo { ... } foo"
4716          would look like an erroneous redeclaration.  */
4717       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4718         return 0;
4719       else
4720         return "redefinition of `%#D'";
4721     }
4722   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4723     {
4724       /* If this is a pure function, its olddecl will actually be
4725          the original initialization to `0' (which we force to call
4726          abort()).  Don't complain about redefinition in this case.  */
4727       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4728         return 0;
4729
4730       /* If both functions come from different namespaces, this is not
4731          a redeclaration - this is a conflict with a used function. */
4732       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4733           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4734         return "`%D' conflicts with used function";
4735
4736       /* We'll complain about linkage mismatches in
4737          warn_extern_redeclared_static.  */
4738
4739       /* Defining the same name twice is no good.  */
4740       if (DECL_INITIAL (olddecl) != NULL_TREE
4741           && DECL_INITIAL (newdecl) != NULL_TREE)
4742         {
4743           if (DECL_NAME (olddecl) == NULL_TREE)
4744             return "`%#D' not declared in class";
4745           else
4746             return "redefinition of `%#D'";
4747         }
4748       return 0;
4749     }
4750   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4751     {
4752       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4753            && (DECL_TEMPLATE_RESULT (newdecl)
4754                != DECL_TEMPLATE_RESULT (olddecl))
4755            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4756            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4757           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4758               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4759               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4760         return "redefinition of `%#D'";
4761       return 0;
4762     }
4763   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4764     {
4765       /* Objects declared at top level:  */
4766       /* If at least one is a reference, it's ok.  */
4767       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4768         return 0;
4769       /* Reject two definitions.  */
4770       return "redefinition of `%#D'";
4771     }
4772   else
4773     {
4774       /* Objects declared with block scope:  */
4775       /* Reject two definitions, and reject a definition
4776          together with an external reference.  */
4777       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4778         return "redeclaration of `%#D'";
4779       return 0;
4780     }
4781 }
4782 \f
4783 /* Create a new label, named ID.  */
4784
4785 static tree
4786 make_label_decl (id, local_p)
4787      tree id;
4788      int local_p;
4789 {
4790   tree decl;
4791
4792   decl = build_decl (LABEL_DECL, id, void_type_node);
4793   if (expanding_p)
4794     /* Make sure every label has an rtx.  */
4795     label_rtx (decl);
4796
4797   DECL_CONTEXT (decl) = current_function_decl;
4798   DECL_MODE (decl) = VOIDmode;
4799   C_DECLARED_LABEL_FLAG (decl) = local_p;
4800
4801   /* Say where one reference is to the label, for the sake of the
4802      error if it is not defined.  */
4803   DECL_SOURCE_LINE (decl) = lineno;
4804   DECL_SOURCE_FILE (decl) = input_filename;
4805
4806   /* Record the fact that this identifier is bound to this label.  */
4807   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4808
4809   return decl;
4810 }
4811
4812 /* Record this label on the list of used labels so that we can check
4813    at the end of the function to see whether or not the label was
4814    actually defined, and so we can check when the label is defined whether
4815    this use is valid.  */
4816
4817 static void
4818 use_label (decl)
4819      tree decl;
4820 {
4821   if (named_label_uses == NULL
4822       || named_label_uses->names_in_scope != current_binding_level->names
4823       || named_label_uses->label_decl != decl)
4824     {
4825       struct named_label_use_list *new_ent;
4826       new_ent = ((struct named_label_use_list *)
4827                  ggc_alloc (sizeof (struct named_label_use_list)));
4828       new_ent->label_decl = decl;
4829       new_ent->names_in_scope = current_binding_level->names;
4830       new_ent->binding_level = current_binding_level;
4831       new_ent->lineno_o_goto = lineno;
4832       new_ent->filename_o_goto = input_filename;
4833       new_ent->next = named_label_uses;
4834       named_label_uses = new_ent;
4835     }
4836 }
4837
4838 /* Look for a label named ID in the current function.  If one cannot
4839    be found, create one.  (We keep track of used, but undefined,
4840    labels, and complain about them at the end of a function.)  */
4841
4842 tree
4843 lookup_label (id)
4844      tree id;
4845 {
4846   tree decl;
4847   struct named_label_list *ent;
4848
4849   /* You can't use labels at global scope.  */
4850   if (current_function_decl == NULL_TREE)
4851     {
4852       error ("label `%s' referenced outside of any function",
4853              IDENTIFIER_POINTER (id));
4854       return NULL_TREE;
4855     }
4856
4857   /* See if we've already got this label.  */
4858   decl = IDENTIFIER_LABEL_VALUE (id);
4859   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4860     return decl;
4861
4862   /* Record this label on the list of labels used in this function.
4863      We do this before calling make_label_decl so that we get the
4864      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4865   ent = ((struct named_label_list *)
4866          ggc_alloc_cleared (sizeof (struct named_label_list)));
4867   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4868   ent->next = named_labels;
4869   named_labels = ent;
4870
4871   /* We need a new label.  */
4872   decl = make_label_decl (id, /*local_p=*/0);
4873
4874   /* Now fill in the information we didn't have before.  */
4875   ent->label_decl = decl;
4876
4877   return decl;
4878 }
4879
4880 /* Declare a local label named ID.  */
4881
4882 tree
4883 declare_local_label (id)
4884      tree id;
4885 {
4886   tree decl;
4887
4888   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4889      this scope we can restore the old value of
4890      IDENTIFIER_TYPE_VALUE.  */
4891   current_binding_level->shadowed_labels
4892     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4893                  current_binding_level->shadowed_labels);
4894   /* Look for the label.  */
4895   decl = make_label_decl (id, /*local_p=*/1);
4896   /* Now fill in the information we didn't have before.  */
4897   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4898
4899   return decl;
4900 }
4901
4902 /* Returns nonzero if it is ill-formed to jump past the declaration of
4903    DECL.  Returns 2 if it's also a real problem.  */
4904
4905 static int
4906 decl_jump_unsafe (decl)
4907      tree decl;
4908 {
4909   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4910     return 0;
4911
4912   if (DECL_INITIAL (decl) == NULL_TREE
4913       && pod_type_p (TREE_TYPE (decl)))
4914     return 0;
4915
4916   /* This is really only important if we're crossing an initialization.
4917      The POD stuff is just pedantry; why should it matter if the class
4918      contains a field of pointer to member type?  */
4919   if (DECL_INITIAL (decl)
4920       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4921     return 2;
4922   return 1;
4923 }
4924
4925 /* Check that a single previously seen jump to a newly defined label
4926    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4927    the jump context; NAMES are the names in scope in LEVEL at the jump
4928    context; FILE and LINE are the source position of the jump or 0.  */
4929
4930 static void
4931 check_previous_goto_1 (decl, level, names, file, line)
4932      tree decl;
4933      struct binding_level *level;
4934      tree names;
4935      const char *file;
4936      int line;
4937 {
4938   int identified = 0;
4939   int saw_eh = 0;
4940   struct binding_level *b = current_binding_level;
4941   for (; b; b = b->level_chain)
4942     {
4943       tree new_decls = b->names;
4944       tree old_decls = (b == level ? names : NULL_TREE);
4945       for (; new_decls != old_decls;
4946            new_decls = TREE_CHAIN (new_decls))
4947         {
4948           int problem = decl_jump_unsafe (new_decls);
4949           if (! problem)
4950             continue;
4951
4952           if (! identified)
4953             {
4954               if (decl)
4955                 cp_pedwarn ("jump to label `%D'", decl);
4956               else
4957                 pedwarn ("jump to case label");
4958
4959               if (file)
4960                 pedwarn_with_file_and_line (file, line, "  from here");
4961               identified = 1;
4962             }
4963
4964           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4965             /* Can't skip init of __exception_info.  */
4966             cp_error_at ("  enters catch block", new_decls);
4967           else if (problem > 1)
4968             cp_error_at ("  crosses initialization of `%#D'",
4969                          new_decls);
4970           else
4971             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4972                            new_decls);
4973         }
4974
4975       if (b == level)
4976         break;
4977       if (b->eh_region && ! saw_eh)
4978         {
4979           if (! identified)
4980             {
4981               if (decl)
4982                 cp_pedwarn ("jump to label `%D'", decl);
4983               else
4984                 pedwarn ("jump to case label");
4985
4986               if (file)
4987                 pedwarn_with_file_and_line (file, line, "  from here");
4988               identified = 1;
4989             }
4990           error ("  enters try block");
4991           saw_eh = 1;
4992         }
4993     }
4994 }
4995
4996 static void
4997 check_previous_goto (use)
4998      struct named_label_use_list *use;
4999 {
5000   check_previous_goto_1 (use->label_decl, use->binding_level,
5001                          use->names_in_scope, use->filename_o_goto,
5002                          use->lineno_o_goto);
5003 }
5004
5005 static void
5006 check_switch_goto (level)
5007      struct binding_level *level;
5008 {
5009   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5010 }
5011
5012 /* Check that any previously seen jumps to a newly defined label DECL
5013    are OK.  Called by define_label.  */
5014
5015 static void
5016 check_previous_gotos (decl)
5017      tree decl;
5018 {
5019   struct named_label_use_list **usep;
5020
5021   if (! TREE_USED (decl))
5022     return;
5023
5024   for (usep = &named_label_uses; *usep; )
5025     {
5026       struct named_label_use_list *use = *usep;
5027       if (use->label_decl == decl)
5028         {
5029           check_previous_goto (use);
5030           *usep = use->next;
5031         }
5032       else
5033         usep = &(use->next);
5034     }
5035 }
5036
5037 /* Check that a new jump to a label DECL is OK.  Called by
5038    finish_goto_stmt.  */
5039
5040 void
5041 check_goto (decl)
5042      tree decl;
5043 {
5044   int identified = 0;
5045   tree bad;
5046   struct named_label_list *lab;
5047
5048   /* We can't know where a computed goto is jumping.  So we assume
5049      that it's OK.  */
5050   if (! DECL_P (decl))
5051     return;
5052
5053   /* If the label hasn't been defined yet, defer checking.  */
5054   if (! DECL_INITIAL (decl))
5055     {
5056       use_label (decl);
5057       return;
5058     }
5059
5060   for (lab = named_labels; lab; lab = lab->next)
5061     if (decl == lab->label_decl)
5062       break;
5063
5064   /* If the label is not on named_labels it's a gcc local label, so
5065      it must be in an outer scope, so jumping to it is always OK.  */
5066   if (lab == 0)
5067     return;
5068
5069   if ((lab->eh_region || lab->bad_decls) && !identified)
5070     {
5071       cp_pedwarn_at ("jump to label `%D'", decl);
5072       pedwarn ("  from here");
5073       identified = 1;
5074     }
5075
5076   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5077     {
5078       tree b = TREE_VALUE (bad);
5079       int u = decl_jump_unsafe (b);
5080
5081       if (u > 1 && DECL_ARTIFICIAL (b))
5082         /* Can't skip init of __exception_info.  */
5083         cp_error_at ("  enters catch block", b);
5084       else if (u > 1)
5085         cp_error_at ("  skips initialization of `%#D'", b);
5086       else
5087         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5088     }
5089
5090   if (lab->eh_region)
5091     error ("  enters try block");
5092 }
5093
5094 /* Define a label, specifying the location in the source file.
5095    Return the LABEL_DECL node for the label, if the definition is valid.
5096    Otherwise return 0.  */
5097
5098 tree
5099 define_label (filename, line, name)
5100      const char *filename;
5101      int line;
5102      tree name;
5103 {
5104   tree decl = lookup_label (name);
5105   struct named_label_list *ent;
5106
5107   for (ent = named_labels; ent; ent = ent->next)
5108     if (ent->label_decl == decl)
5109       break;
5110
5111   /* After labels, make any new cleanups go into their
5112      own new (temporary) binding contour.  */
5113   current_binding_level->more_cleanups_ok = 0;
5114
5115   if (name == get_identifier ("wchar_t"))
5116     cp_pedwarn ("label named wchar_t");
5117
5118   if (DECL_INITIAL (decl) != NULL_TREE)
5119     {
5120       cp_error ("duplicate label `%D'", decl);
5121       return 0;
5122     }
5123   else
5124     {
5125       /* Mark label as having been defined.  */
5126       DECL_INITIAL (decl) = error_mark_node;
5127       /* Say where in the source.  */
5128       DECL_SOURCE_FILE (decl) = filename;
5129       DECL_SOURCE_LINE (decl) = line;
5130       if (ent)
5131         {
5132           ent->names_in_scope = current_binding_level->names;
5133           ent->binding_level = current_binding_level;
5134         }
5135       check_previous_gotos (decl);
5136       current_function_return_value = NULL_TREE;
5137       return decl;
5138     }
5139 }
5140
5141 struct cp_switch
5142 {
5143   struct binding_level *level;
5144   struct cp_switch *next;
5145   /* The SWITCH_STMT being built.  */
5146   tree switch_stmt;
5147   /* A splay-tree mapping the low element of a case range to the high
5148      element, or NULL_TREE if there is no high element.  Used to
5149      determine whether or not a new case label duplicates an old case
5150      label.  We need a tree, rather than simply a hash table, because
5151      of the GNU case range extension.  */
5152   splay_tree cases;
5153 };
5154
5155 /* A stack of the currently active switch statements.  The innermost
5156    switch statement is on the top of the stack.  There is no need to
5157    mark the stack for garbage collection because it is only active
5158    during the processing of the body of a function, and we never
5159    collect at that point.  */
5160
5161 static struct cp_switch *switch_stack;
5162
5163 /* Called right after a switch-statement condition is parsed.
5164    SWITCH_STMT is the switch statement being parsed.  */
5165
5166 void
5167 push_switch (switch_stmt)
5168      tree switch_stmt;
5169 {
5170   struct cp_switch *p
5171     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5172   p->level = current_binding_level;
5173   p->next = switch_stack;
5174   p->switch_stmt = switch_stmt;
5175   p->cases = splay_tree_new (case_compare, NULL, NULL);
5176   switch_stack = p;
5177 }
5178
5179 void
5180 pop_switch ()
5181 {
5182   struct cp_switch *cs;
5183
5184   cs = switch_stack;
5185   splay_tree_delete (cs->cases);
5186   switch_stack = switch_stack->next;
5187   free (cs);
5188 }
5189
5190 /* Note that we've seen a definition of a case label, and complain if this
5191    is a bad place for one.  */
5192
5193 void
5194 finish_case_label (low_value, high_value)
5195      tree low_value;
5196      tree high_value;
5197 {
5198   tree cond;
5199
5200   if (! switch_stack)
5201     {
5202       if (high_value)
5203         error ("case label not within a switch statement");
5204       else if (low_value)
5205         cp_error ("case label `%E' not within a switch statement",
5206                   low_value);
5207       else
5208         error ("`default' label not within a switch statement");
5209       return;
5210     }
5211
5212   if (processing_template_decl)
5213     {
5214       tree label;
5215
5216       /* For templates, just add the case label; we'll do semantic
5217          analysis at instantiation-time.  */
5218       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5219       add_stmt (build_case_label (low_value, high_value, label));
5220       return;
5221     }
5222
5223   /* Find the condition on which this switch statement depends.  */
5224   cond = SWITCH_COND (switch_stack->switch_stmt);
5225   if (cond && TREE_CODE (cond) == TREE_LIST)
5226     cond = TREE_VALUE (cond);
5227
5228   c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5229
5230   check_switch_goto (switch_stack->level);
5231
5232   /* After labels, make any new cleanups go into their
5233      own new (temporary) binding contour.  */
5234   current_binding_level->more_cleanups_ok = 0;
5235   current_function_return_value = NULL_TREE;
5236 }
5237 \f
5238 /* Return the list of declarations of the current level.
5239    Note that this list is in reverse order unless/until
5240    you nreverse it; and when you do nreverse it, you must
5241    store the result back using `storedecls' or you will lose.  */
5242
5243 tree
5244 getdecls ()
5245 {
5246   return current_binding_level->names;
5247 }
5248
5249 /* Return the list of type-tags (for structs, etc) of the current level.  */
5250
5251 tree
5252 gettags ()
5253 {
5254   return current_binding_level->tags;
5255 }
5256
5257 /* Store the list of declarations of the current level.
5258    This is done for the parameter declarations of a function being defined,
5259    after they are modified in the light of any missing parameters.  */
5260
5261 static void
5262 storedecls (decls)
5263      tree decls;
5264 {
5265   current_binding_level->names = decls;
5266 }
5267
5268 /* Similarly, store the list of tags of the current level.  */
5269
5270 void
5271 storetags (tags)
5272      tree tags;
5273 {
5274   current_binding_level->tags = tags;
5275 }
5276 \f
5277 /* Given NAME, an IDENTIFIER_NODE,
5278    return the structure (or union or enum) definition for that name.
5279    Searches binding levels from BINDING_LEVEL up to the global level.
5280    If THISLEVEL_ONLY is nonzero, searches only the specified context
5281    (but skips any tag-transparent contexts to find one that is
5282    meaningful for tags).
5283    FORM says which kind of type the caller wants;
5284    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5285    If the wrong kind of type is found, and it's not a template, an error is
5286    reported.  */
5287
5288 static tree
5289 lookup_tag (form, name, binding_level, thislevel_only)
5290      enum tree_code form;
5291      tree name;
5292      struct binding_level *binding_level;
5293      int thislevel_only;
5294 {
5295   register struct binding_level *level;
5296   /* Non-zero if, we should look past a template parameter level, even
5297      if THISLEVEL_ONLY.  */
5298   int allow_template_parms_p = 1;
5299
5300   for (level = binding_level; level; level = level->level_chain)
5301     {
5302       register tree tail;
5303       if (ANON_AGGRNAME_P (name))
5304         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5305           {
5306             /* There's no need for error checking here, because
5307                anon names are unique throughout the compilation.  */
5308             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5309               return TREE_VALUE (tail);
5310           }
5311       else if (level->namespace_p)
5312         /* Do namespace lookup. */
5313         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5314           {
5315             tree old = binding_for_name (name, tail);
5316
5317             /* If we just skipped past a template parameter level,
5318                even though THISLEVEL_ONLY, and we find a template
5319                class declaration, then we use the _TYPE node for the
5320                template.  See the example below.  */
5321             if (thislevel_only && !allow_template_parms_p
5322                 && old && BINDING_VALUE (old)
5323                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5324               old = TREE_TYPE (BINDING_VALUE (old));
5325             else
5326               old = BINDING_TYPE (old);
5327
5328             /* If it has an original type, it is a typedef, and we
5329                should not return it.  */
5330             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5331               old = NULL_TREE;
5332             if (old && TREE_CODE (old) != form
5333                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5334               {
5335                 cp_error ("`%#D' redeclared as %C", old, form);
5336                 return NULL_TREE;
5337               }
5338             if (old)
5339               return old;
5340             if (thislevel_only || tail == global_namespace)
5341               return NULL_TREE;
5342           }
5343       else
5344         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5345           {
5346             if (TREE_PURPOSE (tail) == name)
5347               {
5348                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5349                 /* Should tighten this up; it'll probably permit
5350                    UNION_TYPE and a struct template, for example.  */
5351                 if (code != form
5352                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5353                   {
5354                     /* Definition isn't the kind we were looking for.  */
5355                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5356                               form);
5357                     return NULL_TREE;
5358                   }
5359                 return TREE_VALUE (tail);
5360               }
5361           }
5362       if (thislevel_only && ! level->tag_transparent)
5363         {
5364           if (level->template_parms_p && allow_template_parms_p)
5365             {
5366               /* We must deal with cases like this:
5367
5368                    template <class T> struct S;
5369                    template <class T> struct S {};
5370
5371                  When looking up `S', for the second declaration, we
5372                  would like to find the first declaration.  But, we
5373                  are in the pseudo-global level created for the
5374                  template parameters, rather than the (surrounding)
5375                  namespace level.  Thus, we keep going one more level,
5376                  even though THISLEVEL_ONLY is non-zero.  */
5377               allow_template_parms_p = 0;
5378               continue;
5379             }
5380           else
5381             return NULL_TREE;
5382         }
5383     }
5384   return NULL_TREE;
5385 }
5386
5387 #if 0
5388 void
5389 set_current_level_tags_transparency (tags_transparent)
5390      int tags_transparent;
5391 {
5392   current_binding_level->tag_transparent = tags_transparent;
5393 }
5394 #endif
5395
5396 /* Given a type, find the tag that was defined for it and return the tag name.
5397    Otherwise return 0.  However, the value can never be 0
5398    in the cases in which this is used.
5399
5400    C++: If NAME is non-zero, this is the new name to install.  This is
5401    done when replacing anonymous tags with real tag names.  */
5402
5403 static tree
5404 lookup_tag_reverse (type, name)
5405      tree type;
5406      tree name;
5407 {
5408   register struct binding_level *level;
5409
5410   for (level = current_binding_level; level; level = level->level_chain)
5411     {
5412       register tree tail;
5413       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5414         {
5415           if (TREE_VALUE (tail) == type)
5416             {
5417               if (name)
5418                 TREE_PURPOSE (tail) = name;
5419               return TREE_PURPOSE (tail);
5420             }
5421         }
5422     }
5423   return NULL_TREE;
5424 }
5425 \f
5426 /* Look up NAME in the NAMESPACE.  */
5427
5428 tree
5429 lookup_namespace_name (namespace, name)
5430      tree namespace, name;
5431 {
5432   tree val;
5433   tree template_id = NULL_TREE;
5434
5435   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5436
5437   if (TREE_CODE (name) == NAMESPACE_DECL)
5438     /* This happens for A::B<int> when B is a namespace. */
5439     return name;
5440   else if (TREE_CODE (name) == TEMPLATE_DECL)
5441     {
5442       /* This happens for A::B where B is a template, and there are no
5443          template arguments.  */
5444       cp_error ("invalid use of `%D'", name);
5445       return error_mark_node;
5446     }
5447
5448   namespace = ORIGINAL_NAMESPACE (namespace);
5449
5450   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5451     {
5452       template_id = name;
5453       name = TREE_OPERAND (name, 0);
5454       if (TREE_CODE (name) == OVERLOAD)
5455         name = DECL_NAME (OVL_CURRENT (name));
5456       else if (DECL_P (name))
5457         name = DECL_NAME (name);
5458     }
5459
5460   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5461
5462   val = make_node (CPLUS_BINDING);
5463   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5464     return error_mark_node;
5465
5466   if (BINDING_VALUE (val))
5467     {
5468       val = BINDING_VALUE (val);
5469
5470       if (template_id)
5471         {
5472           if (DECL_CLASS_TEMPLATE_P (val))
5473             val = lookup_template_class (val,
5474                                          TREE_OPERAND (template_id, 1),
5475                                          /*in_decl=*/NULL_TREE,
5476                                          /*context=*/NULL_TREE,
5477                                          /*entering_scope=*/0);
5478           else if (DECL_FUNCTION_TEMPLATE_P (val)
5479                    || TREE_CODE (val) == OVERLOAD)
5480             val = lookup_template_function (val,
5481                                             TREE_OPERAND (template_id, 1));
5482           else
5483             {
5484               cp_error ("`%D::%D' is not a template",
5485                         namespace, name);
5486               return error_mark_node;
5487             }
5488         }
5489
5490       /* If we have a single function from a using decl, pull it out.  */
5491       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5492         val = OVL_FUNCTION (val);
5493       return val;
5494     }
5495
5496   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5497   return error_mark_node;
5498 }
5499
5500 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5501
5502 static unsigned long
5503 typename_hash (k)
5504      hash_table_key k;
5505 {
5506   unsigned long hash;
5507   tree t;
5508
5509   t = (tree) k;
5510   hash = (((unsigned long) TYPE_CONTEXT (t))
5511           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5512
5513   return hash;
5514 }
5515
5516 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5517
5518 static boolean
5519 typename_compare (k1, k2)
5520      hash_table_key k1;
5521      hash_table_key k2;
5522 {
5523   tree t1;
5524   tree t2;
5525   tree d1;
5526   tree d2;
5527
5528   t1 = (tree) k1;
5529   t2 = (tree) k2;
5530   d1 = TYPE_NAME (t1);
5531   d2 = TYPE_NAME (t2);
5532
5533   return (DECL_NAME (d1) == DECL_NAME (d2)
5534           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5535           && ((TREE_TYPE (t1) != NULL_TREE)
5536               == (TREE_TYPE (t2) != NULL_TREE))
5537           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5538           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5539 }
5540
5541 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5542    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5543    is non-NULL, this type is being created by the implicit typename
5544    extension, and BASE_TYPE is a type named `t' in some base class of
5545    `T' which depends on template parameters.
5546
5547    Returns the new TYPENAME_TYPE.  */
5548
5549 tree
5550 build_typename_type (context, name, fullname, base_type)
5551      tree context;
5552      tree name;
5553      tree fullname;
5554      tree base_type;
5555 {
5556   tree t;
5557   tree d;
5558   struct hash_entry* e;
5559
5560   static struct hash_table ht;
5561
5562   if (!ht.table)
5563     {
5564       static struct hash_table *h = &ht;
5565       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5566                             &typename_compare))
5567         fatal ("virtual memory exhausted");
5568       ggc_add_tree_hash_table_root (&h, 1);
5569     }
5570
5571   /* Build the TYPENAME_TYPE.  */
5572   t = make_aggr_type (TYPENAME_TYPE);
5573   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5574   TYPENAME_TYPE_FULLNAME (t) = fullname;
5575   TREE_TYPE (t) = base_type;
5576
5577   /* Build the corresponding TYPE_DECL.  */
5578   d = build_decl (TYPE_DECL, name, t);
5579   TYPE_NAME (TREE_TYPE (d)) = d;
5580   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5581   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5582   DECL_ARTIFICIAL (d) = 1;
5583
5584   /* See if we already have this type.  */
5585   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5586   if (e)
5587     t = (tree) e->key;
5588   else
5589     /* Insert the type into the table.  */
5590     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5591
5592   return t;
5593 }
5594
5595 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5596    unless an error occurs, in which case error_mark_node is returned.
5597    If COMPLAIN zero, don't complain about any errors that occur.  */
5598
5599 tree
5600 make_typename_type (context, name, complain)
5601      tree context, name;
5602      int complain;
5603 {
5604   tree fullname;
5605
5606   if (TYPE_P (name))
5607     {
5608       if (!(TYPE_LANG_SPECIFIC (name)
5609             && (CLASSTYPE_IS_TEMPLATE (name)
5610                 || CLASSTYPE_USE_TEMPLATE (name))))
5611         name = TYPE_IDENTIFIER (name);
5612       else
5613         /* Create a TEMPLATE_ID_EXPR for the type.  */
5614         name = build_nt (TEMPLATE_ID_EXPR,
5615                          CLASSTYPE_TI_TEMPLATE (name),
5616                          CLASSTYPE_TI_ARGS (name));
5617     }
5618   else if (TREE_CODE (name) == TYPE_DECL)
5619     name = DECL_NAME (name);
5620
5621   fullname = name;
5622
5623   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5624     {
5625       name = TREE_OPERAND (name, 0);
5626       if (TREE_CODE (name) == TEMPLATE_DECL)
5627         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5628     }
5629   if (TREE_CODE (name) != IDENTIFIER_NODE)
5630     my_friendly_abort (2000);
5631
5632   if (TREE_CODE (context) == NAMESPACE_DECL)
5633     {
5634       /* We can get here from typename_sub0 in the explicit_template_type
5635          expansion.  Just fail.  */
5636       if (complain)
5637         cp_error ("no class template named `%#T' in `%#T'",
5638                   name, context);
5639       return error_mark_node;
5640     }
5641
5642   if (! uses_template_parms (context)
5643       || currently_open_class (context))
5644     {
5645       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5646         {
5647           tree tmpl = NULL_TREE;
5648           if (IS_AGGR_TYPE (context))
5649             tmpl = lookup_field (context, name, 0, 0);
5650           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5651             {
5652               if (complain)
5653                 cp_error ("no class template named `%#T' in `%#T'",
5654                           name, context);
5655               return error_mark_node;
5656             }
5657
5658           return lookup_template_class (tmpl,
5659                                         TREE_OPERAND (fullname, 1),
5660                                         NULL_TREE, context,
5661                                         /*entering_scope=*/0);
5662         }
5663       else
5664         {
5665           tree t;
5666
5667           if (!IS_AGGR_TYPE (context))
5668             {
5669               if (complain)
5670                 cp_error ("no type named `%#T' in `%#T'", name, context);
5671               return error_mark_node;
5672             }
5673
5674           t = lookup_field (context, name, 0, 1);
5675           if (t)
5676             return TREE_TYPE (t);
5677         }
5678     }
5679
5680   /* If the CONTEXT is not a template type, then either the field is
5681      there now or its never going to be.  */
5682   if (!uses_template_parms (context))
5683     {
5684       if (complain)
5685         cp_error ("no type named `%#T' in `%#T'", name, context);
5686       return error_mark_node;
5687     }
5688
5689
5690   return build_typename_type (context, name, fullname,  NULL_TREE);
5691 }
5692
5693 /* Select the right _DECL from multiple choices. */
5694
5695 static tree
5696 select_decl (binding, flags)
5697      tree binding;
5698      int flags;
5699 {
5700   tree val;
5701   val = BINDING_VALUE (binding);
5702   if (LOOKUP_NAMESPACES_ONLY (flags))
5703     {
5704       /* We are not interested in types. */
5705       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5706         return val;
5707       return NULL_TREE;
5708     }
5709
5710   /* If we could have a type and
5711      we have nothing or we need a type and have none.  */
5712   if (BINDING_TYPE (binding)
5713       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5714                    && TREE_CODE (val) != TYPE_DECL)))
5715     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5716   /* Don't return non-types if we really prefer types. */
5717   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5718            && (TREE_CODE (val) != TEMPLATE_DECL
5719                || !DECL_CLASS_TEMPLATE_P (val)))
5720     val = NULL_TREE;
5721
5722   return val;
5723 }
5724
5725 /* Unscoped lookup of a global: iterate over current namespaces,
5726    considering using-directives.  If SPACESP is non-NULL, store a list
5727    of the namespaces we've considered in it.  */
5728
5729 tree
5730 unqualified_namespace_lookup (name, flags, spacesp)
5731      tree name;
5732      int flags;
5733      tree *spacesp;
5734 {
5735   tree b = make_node (CPLUS_BINDING);
5736   tree initial = current_decl_namespace();
5737   tree scope = initial;
5738   tree siter;
5739   struct binding_level *level;
5740   tree val = NULL_TREE;
5741
5742   if (spacesp)
5743     *spacesp = NULL_TREE;
5744
5745   for (; !val; scope = CP_DECL_CONTEXT (scope))
5746     {
5747       if (spacesp)
5748         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5749       val = binding_for_name (name, scope);
5750
5751       /* Initialize binding for this context. */
5752       BINDING_VALUE (b) = BINDING_VALUE (val);
5753       BINDING_TYPE (b) = BINDING_TYPE (val);
5754
5755       /* Add all _DECLs seen through local using-directives. */
5756       for (level = current_binding_level;
5757            !level->namespace_p;
5758            level = level->level_chain)
5759         if (!lookup_using_namespace (name, b, level->using_directives,
5760                                      scope, flags, spacesp))
5761           /* Give up because of error. */
5762           return error_mark_node;
5763
5764       /* Add all _DECLs seen through global using-directives. */
5765       /* XXX local and global using lists should work equally. */
5766       siter = initial;
5767       while (1)
5768         {
5769           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5770                                        scope, flags, spacesp))
5771             /* Give up because of error. */
5772             return error_mark_node;
5773           if (siter == scope) break;
5774           siter = CP_DECL_CONTEXT (siter);
5775         }
5776
5777       val = select_decl (b, flags);
5778       if (scope == global_namespace)
5779         break;
5780     }
5781   return val;
5782 }
5783
5784 /* Combine prefer_type and namespaces_only into flags.  */
5785
5786 static int
5787 lookup_flags (prefer_type, namespaces_only)
5788   int prefer_type, namespaces_only;
5789 {
5790   if (namespaces_only)
5791     return LOOKUP_PREFER_NAMESPACES;
5792   if (prefer_type > 1)
5793     return LOOKUP_PREFER_TYPES;
5794   if (prefer_type > 0)
5795     return LOOKUP_PREFER_BOTH;
5796   return 0;
5797 }
5798
5799 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5800    ignore it or not.  Subroutine of lookup_name_real.  */
5801
5802 static tree
5803 qualify_lookup (val, flags)
5804      tree val;
5805      int flags;
5806 {
5807   if (val == NULL_TREE)
5808     return val;
5809   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5810     return val;
5811   if ((flags & LOOKUP_PREFER_TYPES)
5812       && (TREE_CODE (val) == TYPE_DECL
5813           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5814               && DECL_CLASS_TEMPLATE_P (val))))
5815     return val;
5816   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5817     return NULL_TREE;
5818   return val;
5819 }
5820
5821 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5822    that.  */
5823
5824 static void
5825 warn_about_implicit_typename_lookup (typename, binding)
5826      tree typename;
5827      tree binding;
5828 {
5829   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5830   tree name = DECL_NAME (typename);
5831
5832   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5833          && CLASSTYPE_TEMPLATE_INFO (subtype)
5834          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5835       && ! (TREE_CODE (binding) == TYPE_DECL
5836             && same_type_p (TREE_TYPE (binding), subtype)))
5837     {
5838       cp_warning ("lookup of `%D' finds `%#D'",
5839                   name, binding);
5840       cp_warning ("  instead of `%D' from dependent base class",
5841                   typename);
5842       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5843                   constructor_name (current_class_type), name);
5844     }
5845 }
5846
5847 /* Look up NAME in the current binding level and its superiors in the
5848    namespace of variables, functions and typedefs.  Return a ..._DECL
5849    node of some kind representing its definition if there is only one
5850    such declaration, or return a TREE_LIST with all the overloaded
5851    definitions if there are many, or return 0 if it is undefined.
5852
5853    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5854    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5855    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5856    Otherwise we prefer non-TYPE_DECLs.
5857
5858    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5859    using IDENTIFIER_CLASS_VALUE.  */
5860
5861 static tree
5862 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5863      tree name;
5864      int prefer_type, nonclass, namespaces_only;
5865 {
5866   tree t;
5867   tree val = NULL_TREE;
5868   int yylex = 0;
5869   tree from_obj = NULL_TREE;
5870   int flags;
5871   int val_is_implicit_typename = 0;
5872
5873   /* Hack: copy flag set by parser, if set. */
5874   if (only_namespace_names)
5875     namespaces_only = 1;
5876
5877   if (prefer_type == -2)
5878     {
5879       extern int looking_for_typename;
5880       tree type = NULL_TREE;
5881
5882       yylex = 1;
5883       prefer_type = looking_for_typename;
5884
5885       flags = lookup_flags (prefer_type, namespaces_only);
5886       /* If the next thing is '<', class templates are types. */
5887       if (looking_for_template)
5888         flags |= LOOKUP_TEMPLATES_EXPECTED;
5889
5890       /* std:: becomes :: for now.  */
5891       if (got_scope == std_node)
5892         got_scope = void_type_node;
5893
5894       if (got_scope)
5895         type = got_scope;
5896       else if (got_object != error_mark_node)
5897         type = got_object;
5898
5899       if (type)
5900         {
5901           if (type == error_mark_node)
5902             return error_mark_node;
5903           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5904             type = TREE_TYPE (type);
5905
5906           if (TYPE_P (type))
5907             type = complete_type (type);
5908
5909           if (TREE_CODE (type) == VOID_TYPE)
5910             type = global_namespace;
5911           if (TREE_CODE (type) == NAMESPACE_DECL)
5912             {
5913               val = make_node (CPLUS_BINDING);
5914               flags |= LOOKUP_COMPLAIN;
5915               if (!qualified_lookup_using_namespace (name, type, val, flags))
5916                 return NULL_TREE;
5917               val = select_decl (val, flags);
5918             }
5919           else if (! IS_AGGR_TYPE (type)
5920                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5921                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5922                    || TREE_CODE (type) == TYPENAME_TYPE)
5923             /* Someone else will give an error about this if needed.  */
5924             val = NULL_TREE;
5925           else if (type == current_class_type)
5926             val = IDENTIFIER_CLASS_VALUE (name);
5927           else
5928             {
5929               val = lookup_member (type, name, 0, prefer_type);
5930               type_access_control (type, val);
5931
5932               /* Restore the containing TYPENAME_TYPE if we looked
5933                  through it before.  */
5934               if (got_scope && got_scope != type
5935                   && val && TREE_CODE (val) == TYPE_DECL
5936                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5937                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5938             }
5939         }
5940       else
5941         val = NULL_TREE;
5942
5943       if (got_scope)
5944         goto done;
5945       else if (got_object && val)
5946         from_obj = val;
5947     }
5948   else
5949     {
5950       flags = lookup_flags (prefer_type, namespaces_only);
5951       /* If we're not parsing, we need to complain. */
5952       flags |= LOOKUP_COMPLAIN;
5953     }
5954
5955   /* First, look in non-namespace scopes.  */
5956
5957   if (current_class_type == NULL_TREE)
5958     nonclass = 1;
5959
5960   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5961     {
5962       tree binding;
5963
5964       if (!LOCAL_BINDING_P (t) && nonclass)
5965         /* We're not looking for class-scoped bindings, so keep going.  */
5966         continue;
5967
5968       /* If this is the kind of thing we're looking for, we're done.  */
5969       if (qualify_lookup (BINDING_VALUE (t), flags))
5970         binding = BINDING_VALUE (t);
5971       else if ((flags & LOOKUP_PREFER_TYPES)
5972                && qualify_lookup (BINDING_TYPE (t), flags))
5973         binding = BINDING_TYPE (t);
5974       else
5975         binding = NULL_TREE;
5976
5977       /* Handle access control on types from enclosing or base classes.  */
5978       if (binding && ! yylex
5979           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5980         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5981
5982       if (binding
5983           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5984         {
5985           if (val_is_implicit_typename && !yylex)
5986             warn_about_implicit_typename_lookup (val, binding);
5987           val = binding;
5988           val_is_implicit_typename
5989             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5990           if (!val_is_implicit_typename)
5991             break;
5992         }
5993     }
5994
5995   /* Now lookup in namespace scopes.  */
5996   if (!val || val_is_implicit_typename)
5997     {
5998       t = unqualified_namespace_lookup (name, flags, 0);
5999       if (t)
6000         {
6001           if (val_is_implicit_typename && !yylex)
6002             warn_about_implicit_typename_lookup (val, t);
6003           val = t;
6004         }
6005     }
6006
6007  done:
6008   if (val)
6009     {
6010       /* This should only warn about types used in qualified-ids.  */
6011       if (from_obj && from_obj != val)
6012         {
6013           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6014               && TREE_CODE (val) == TYPE_DECL
6015               && TREE_TYPE (from_obj) != TREE_TYPE (val))
6016             {
6017               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6018                           name, got_object, TREE_TYPE (from_obj));
6019               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
6020                           TREE_TYPE (val));
6021             }
6022
6023           /* We don't change val to from_obj if got_object depends on
6024              template parms because that breaks implicit typename for
6025              destructor calls.  */
6026           if (! uses_template_parms (got_object))
6027             val = from_obj;
6028         }
6029
6030       /* If we have a single function from a using decl, pull it out.  */
6031       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6032         val = OVL_FUNCTION (val);
6033     }
6034   else if (from_obj)
6035     val = from_obj;
6036
6037   return val;
6038 }
6039
6040 tree
6041 lookup_name_nonclass (name)
6042      tree name;
6043 {
6044   return lookup_name_real (name, 0, 1, 0);
6045 }
6046
6047 tree
6048 lookup_function_nonclass (name, args)
6049      tree name;
6050      tree args;
6051 {
6052   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6053 }
6054
6055 tree
6056 lookup_name_namespace_only (name)
6057      tree name;
6058 {
6059   /* type-or-namespace, nonclass, namespace_only */
6060   return lookup_name_real (name, 1, 1, 1);
6061 }
6062
6063 tree
6064 lookup_name (name, prefer_type)
6065      tree name;
6066      int prefer_type;
6067 {
6068   return lookup_name_real (name, prefer_type, 0, 0);
6069 }
6070
6071 /* Similar to `lookup_name' but look only in the innermost non-class
6072    binding level.  */
6073
6074 tree
6075 lookup_name_current_level (name)
6076      tree name;
6077 {
6078   struct binding_level *b;
6079   tree t = NULL_TREE;
6080
6081   b = current_binding_level;
6082   while (b->parm_flag == 2)
6083     b = b->level_chain;
6084
6085   if (b->namespace_p)
6086     {
6087       t = IDENTIFIER_NAMESPACE_VALUE (name);
6088
6089       /* extern "C" function() */
6090       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6091         t = TREE_VALUE (t);
6092     }
6093   else if (IDENTIFIER_BINDING (name)
6094            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6095     {
6096       while (1)
6097         {
6098           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6099             return IDENTIFIER_VALUE (name);
6100
6101           if (b->keep == 2)
6102             b = b->level_chain;
6103           else
6104             break;
6105         }
6106     }
6107
6108   return t;
6109 }
6110
6111 /* Like lookup_name_current_level, but for types.  */
6112
6113 tree
6114 lookup_type_current_level (name)
6115      tree name;
6116 {
6117   register tree t = NULL_TREE;
6118
6119   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6120
6121   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6122       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6123     {
6124       struct binding_level *b = current_binding_level;
6125       while (1)
6126         {
6127           if (purpose_member (name, b->type_shadowed))
6128             return REAL_IDENTIFIER_TYPE_VALUE (name);
6129           if (b->keep == 2)
6130             b = b->level_chain;
6131           else
6132             break;
6133         }
6134     }
6135
6136   return t;
6137 }
6138
6139 void
6140 begin_only_namespace_names ()
6141 {
6142   only_namespace_names = 1;
6143 }
6144
6145 void
6146 end_only_namespace_names ()
6147 {
6148   only_namespace_names = 0;
6149 }
6150 \f
6151 /* Push the declarations of builtin types into the namespace.
6152    RID_INDEX is the index of the builtin type
6153    in the array RID_POINTERS.  NAME is the name used when looking
6154    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6155
6156 static void
6157 record_builtin_type (rid_index, name, type)
6158      enum rid rid_index;
6159      const char *name;
6160      tree type;
6161 {
6162   tree rname = NULL_TREE, tname = NULL_TREE;
6163   tree tdecl = NULL_TREE;
6164
6165   if ((int) rid_index < (int) RID_MAX)
6166     rname = ridpointers[(int) rid_index];
6167   if (name)
6168     tname = get_identifier (name);
6169
6170   TYPE_BUILT_IN (type) = 1;
6171
6172   if (tname)
6173     {
6174       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6175       set_identifier_type_value (tname, NULL_TREE);
6176       if ((int) rid_index < (int) RID_MAX)
6177         /* Built-in types live in the global namespace. */
6178         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6179     }
6180   if (rname != NULL_TREE)
6181     {
6182       if (tname != NULL_TREE)
6183         {
6184           set_identifier_type_value (rname, NULL_TREE);
6185           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6186         }
6187       else
6188         {
6189           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6190           set_identifier_type_value (rname, NULL_TREE);
6191         }
6192     }
6193 }
6194
6195 /* Record one of the standard Java types.
6196  * Declare it as having the given NAME.
6197  * If SIZE > 0, it is the size of one of the integral types;
6198  * otherwise it is the negative of the size of one of the other types.  */
6199
6200 static tree
6201 record_builtin_java_type (name, size)
6202      const char *name;
6203      int size;
6204 {
6205   tree type, decl;
6206   if (size > 0)
6207     type = make_signed_type (size);
6208   else if (size > -32)
6209     { /* "__java_char" or ""__java_boolean". */
6210       type = make_unsigned_type (-size);
6211       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6212     }
6213   else
6214     { /* "__java_float" or ""__java_double". */
6215       type = make_node (REAL_TYPE);
6216       TYPE_PRECISION (type) = - size;
6217       layout_type (type);
6218     }
6219   record_builtin_type (RID_MAX, name, type);
6220   decl = TYPE_NAME (type);
6221
6222   /* Suppress generate debug symbol entries for these types,
6223      since for normal C++ they are just clutter.
6224      However, push_lang_context undoes this if extern "Java" is seen. */
6225   DECL_IGNORED_P (decl) = 1;
6226
6227   TYPE_FOR_JAVA (type) = 1;
6228   return type;
6229 }
6230
6231 /* Push a type into the namespace so that the back-ends ignore it. */
6232
6233 static void
6234 record_unknown_type (type, name)
6235      tree type;
6236      const char *name;
6237 {
6238   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6239   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6240   DECL_IGNORED_P (decl) = 1;
6241   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6242   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6243   TYPE_ALIGN (type) = 1;
6244   TYPE_USER_ALIGN (type) = 0;
6245   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6246 }
6247
6248 /* An string for which we should create an IDENTIFIER_NODE at
6249    startup.  */
6250
6251 typedef struct predefined_identifier
6252 {
6253   /* The name of the identifier.  */
6254   const char *name;
6255   /* The place where the IDENTIFIER_NODE should be stored.  */
6256   tree *node;
6257   /* Non-zero if this is the name of a constructor or destructor.  */
6258   int ctor_or_dtor_p;
6259 } predefined_identifier;
6260
6261 /* Create all the predefined identifiers.  */
6262
6263 static void
6264 initialize_predefined_identifiers ()
6265 {
6266   struct predefined_identifier *pid;
6267
6268   /* A table of identifiers to create at startup.  */
6269   static predefined_identifier predefined_identifiers[] = {
6270     { "C++", &lang_name_cplusplus, 0 },
6271     { "C", &lang_name_c, 0 },
6272     { "Java", &lang_name_java, 0 },
6273     { CTOR_NAME, &ctor_identifier, 1 },
6274     { "__base_ctor", &base_ctor_identifier, 1 },
6275     { "__comp_ctor", &complete_ctor_identifier, 1 },
6276     { DTOR_NAME, &dtor_identifier, 1 },
6277     { "__comp_dtor", &complete_dtor_identifier, 1 },
6278     { "__base_dtor", &base_dtor_identifier, 1 },
6279     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6280     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6281     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6282     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6283     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6284     { "nelts", &nelts_identifier, 0 },
6285     { THIS_NAME, &this_identifier, 0 },
6286     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6287     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6288     { "_vptr", &vptr_identifier, 0 },
6289     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6290     { "__vtt_parm", &vtt_parm_identifier, 0 },
6291     { "std", &std_identifier, 0 },
6292     { NULL, NULL, 0 }
6293   };
6294
6295   for (pid = predefined_identifiers; pid->name; ++pid)
6296     {
6297       *pid->node = get_identifier (pid->name);
6298       if (pid->ctor_or_dtor_p)
6299         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6300     }
6301 }
6302
6303 /* Create the predefined scalar types of C,
6304    and some nodes representing standard constants (0, 1, (void *)0).
6305    Initialize the global binding level.
6306    Make definitions for built-in primitive functions.  */
6307
6308 void
6309 init_decl_processing ()
6310 {
6311   tree fields[20];
6312   int wchar_type_size;
6313   tree array_domain_type;
6314
6315   /* Check to see that the user did not specify an invalid combination
6316      of command-line options.  */
6317   if (flag_new_abi && !flag_vtable_thunks)
6318     fatal ("the new ABI requires vtable thunks");
6319
6320   /* Create all the identifiers we need.  */
6321   initialize_predefined_identifiers ();
6322
6323   /* Fill in back-end hooks.  */
6324   init_lang_status = &push_cp_function_context;
6325   free_lang_status = &pop_cp_function_context;
6326   mark_lang_status = &mark_cp_function_context;
6327   lang_safe_from_p = &c_safe_from_p;
6328
6329   cp_parse_init ();
6330   init_decl2 ();
6331   init_pt ();
6332
6333   /* Create the global variables.  */
6334   push_to_top_level ();
6335
6336   /* Enter the global namespace. */
6337   my_friendly_assert (global_namespace == NULL_TREE, 375);
6338   push_namespace (get_identifier ("::"));
6339   global_namespace = current_namespace;
6340   current_lang_name = NULL_TREE;
6341
6342   /* Adjust various flags based on command-line settings.  */
6343   if (! flag_permissive && ! pedantic)
6344     flag_pedantic_errors = 1;
6345   if (!flag_no_inline)
6346     flag_inline_trees = 1;
6347
6348   /* Initially, C.  */
6349   current_lang_name = lang_name_c;
6350
6351   current_function_decl = NULL_TREE;
6352   current_binding_level = NULL_BINDING_LEVEL;
6353   free_binding_level = NULL_BINDING_LEVEL;
6354
6355   build_common_tree_nodes (flag_signed_char);
6356
6357   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6358   TREE_TYPE (error_mark_list) = error_mark_node;
6359
6360   /* Make the binding_level structure for global names.  */
6361   pushlevel (0);
6362   global_binding_level = current_binding_level;
6363   /* The global level is the namespace level of ::.  */
6364   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6365   declare_namespace_level ();
6366
6367   /* Define `int' and `char' first so that dbx will output them first.  */
6368   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6369   record_builtin_type (RID_CHAR, "char", char_type_node);
6370
6371   /* `signed' is the same as `int' */
6372   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6373   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6374   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6375   record_builtin_type (RID_MAX, "long unsigned int",
6376                        long_unsigned_type_node);
6377   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6378   record_builtin_type (RID_MAX, "long long int",
6379                        long_long_integer_type_node);
6380   record_builtin_type (RID_MAX, "long long unsigned int",
6381                        long_long_unsigned_type_node);
6382   record_builtin_type (RID_MAX, "long long unsigned",
6383                        long_long_unsigned_type_node);
6384   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6385   record_builtin_type (RID_MAX, "short unsigned int",
6386                        short_unsigned_type_node);
6387   record_builtin_type (RID_MAX, "unsigned short",
6388                        short_unsigned_type_node);
6389
6390   ptrdiff_type_node
6391     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6392   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
6393
6394   /* Define both `signed char' and `unsigned char'.  */
6395   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6396   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6397
6398   /* `unsigned long' is the standard type for sizeof.
6399      Note that stddef.h uses `unsigned long',
6400      and this must agree, even if long and int are the same size.  */
6401   c_size_type_node =
6402     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
6403   signed_size_type_node = signed_type (c_size_type_node);
6404   set_sizetype (c_size_type_node);
6405
6406   /* Create the widest literal types. */
6407   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6408   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6409                         widest_integer_literal_type_node));
6410
6411   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6412   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6413                         widest_unsigned_literal_type_node));
6414
6415   /* These are types that type_for_size and type_for_mode use.  */
6416   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6417   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6419   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6420 #if HOST_BITS_PER_WIDE_INT >= 64
6421   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6422 #endif
6423   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6424   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6425   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6426   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6427 #if HOST_BITS_PER_WIDE_INT >= 64
6428   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6429 #endif
6430
6431   build_common_tree_nodes_2 (flag_short_double);
6432
6433   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6434   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6435   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6436   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6437   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6438   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6439   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6440   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6441
6442   integer_two_node = build_int_2 (2, 0);
6443   TREE_TYPE (integer_two_node) = integer_type_node;
6444   integer_three_node = build_int_2 (3, 0);
6445   TREE_TYPE (integer_three_node) = integer_type_node;
6446
6447   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6448   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6449   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6450   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6451   TYPE_PRECISION (boolean_type_node) = 1;
6452   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6453   boolean_false_node = build_int_2 (0, 0);
6454   TREE_TYPE (boolean_false_node) = boolean_type_node;
6455   boolean_true_node = build_int_2 (1, 0);
6456   TREE_TYPE (boolean_true_node) = boolean_type_node;
6457
6458   signed_size_zero_node = build_int_2 (0, 0);
6459   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6460   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6461   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6462
6463   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6464                         complex_integer_type_node));
6465   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6466                         complex_float_type_node));
6467   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6468                         complex_double_type_node));
6469   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6470                         complex_long_double_type_node));
6471
6472   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6473
6474   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6475   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6476   TREE_PARMLIST (void_list_node) = 1;
6477
6478   string_type_node = build_pointer_type (char_type_node);
6479   const_string_type_node
6480     = build_pointer_type (build_qualified_type (char_type_node,
6481                                                 TYPE_QUAL_CONST));
6482   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6483 #if 0
6484   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6485 #endif
6486
6487   /* Make a type to be the domain of a few array types
6488      whose domains don't really matter.
6489      200 is small enough that it always fits in size_t.  */
6490   array_domain_type = build_index_type (build_int_2 (200, 0));
6491
6492   /* Make a type for arrays of characters.
6493      With luck nothing will ever really depend on the length of this
6494      array type.  */
6495   char_array_type_node
6496     = build_array_type (char_type_node, array_domain_type);
6497
6498   /* Likewise for arrays of ints.  */
6499   int_array_type_node
6500     = build_array_type (integer_type_node, array_domain_type);
6501
6502   if (flag_new_abi)
6503     delta_type_node = ptrdiff_type_node;
6504   else if (flag_huge_objects)
6505     delta_type_node = long_integer_type_node;
6506   else
6507     delta_type_node = short_integer_type_node;
6508
6509   if (flag_new_abi)
6510     vtable_index_type = ptrdiff_type_node;
6511   else
6512     vtable_index_type = delta_type_node;
6513
6514   default_function_type
6515     = build_function_type (integer_type_node, NULL_TREE);
6516
6517   ptr_type_node = build_pointer_type (void_type_node);
6518   const_ptr_type_node
6519     = build_pointer_type (build_qualified_type (void_type_node,
6520                                                 TYPE_QUAL_CONST));
6521   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6522   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6523   lang_type_promotes_to = convert_type_from_ellipsis;
6524
6525   void_ftype_ptr
6526     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6527
6528   /* C++ extensions */
6529
6530   unknown_type_node = make_node (UNKNOWN_TYPE);
6531   record_unknown_type (unknown_type_node, "unknown type");
6532
6533   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6534   TREE_TYPE (unknown_type_node) = unknown_type_node;
6535
6536   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6537
6538   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6539      result.  */
6540   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6541   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6542
6543   /* This is special for C++ so functions can be overloaded.  */
6544   wchar_type_node = get_identifier (flag_short_wchar
6545                                     ? "short unsigned int"
6546                                     : WCHAR_TYPE);
6547   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6548   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6549   if (TREE_UNSIGNED (wchar_type_node))
6550     wchar_type_node = make_signed_type (wchar_type_size);
6551   else
6552     wchar_type_node = make_unsigned_type (wchar_type_size);
6553   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6554
6555   /* Artificial declaration of wchar_t -- can be bashed */
6556   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6557                                 wchar_type_node);
6558   pushdecl (wchar_decl_node);
6559
6560   /* This is for wide string constants.  */
6561   wchar_array_type_node
6562     = build_array_type (wchar_type_node, array_domain_type);
6563
6564   wint_type_node =
6565     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WINT_TYPE)));
6566
6567   intmax_type_node =
6568     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE)));
6569   uintmax_type_node =
6570     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE)));
6571
6572   if (flag_vtable_thunks)
6573     {
6574       /* Make sure we get a unique function type, so we can give
6575          its pointer type a name.  (This wins for gdb.) */
6576       tree vfunc_type = make_node (FUNCTION_TYPE);
6577       TREE_TYPE (vfunc_type) = integer_type_node;
6578       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6579       layout_type (vfunc_type);
6580
6581       vtable_entry_type = build_pointer_type (vfunc_type);
6582     }
6583   else
6584     {
6585       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6586       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6587                               delta_type_node);
6588       fields[1] = build_decl (FIELD_DECL, index_identifier,
6589                               delta_type_node);
6590       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6591                               ptr_type_node);
6592       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6593                            double_type_node);
6594
6595       /* Make this part of an invisible union.  */
6596       fields[3] = copy_node (fields[2]);
6597       TREE_TYPE (fields[3]) = delta_type_node;
6598       DECL_NAME (fields[3]) = delta2_identifier;
6599       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6600       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6601       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6602       TREE_UNSIGNED (fields[3]) = 0;
6603       TREE_CHAIN (fields[2]) = fields[3];
6604       vtable_entry_type = build_qualified_type (vtable_entry_type,
6605                                                 TYPE_QUAL_CONST);
6606     }
6607   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6608
6609   vtbl_type_node
6610     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6611   layout_type (vtbl_type_node);
6612   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6613   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6614   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6615   layout_type (vtbl_ptr_type_node);
6616   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6617
6618   std_node = build_decl (NAMESPACE_DECL,
6619                          flag_honor_std
6620                          ? get_identifier ("fake std") : std_identifier,
6621                          void_type_node);
6622   pushdecl (std_node);
6623
6624   if (flag_new_abi)
6625     {
6626       push_namespace (get_identifier ("__cxxabiv1"));
6627       abi_node = current_namespace;
6628       pop_namespace ();
6629     }
6630
6631   global_type_node = make_node (LANG_TYPE);
6632   record_unknown_type (global_type_node, "global type");
6633
6634   /* Now, C++.  */
6635   current_lang_name = lang_name_cplusplus;
6636
6637   {
6638     tree bad_alloc_type_node, newtype, deltype;
6639     if (flag_honor_std)
6640       push_namespace (get_identifier ("std"));
6641     bad_alloc_type_node = xref_tag
6642       (class_type_node, get_identifier ("bad_alloc"), 1);
6643     if (flag_honor_std)
6644       pop_namespace ();
6645     newtype = build_exception_variant
6646       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6647     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6648     push_cp_library_fn (NEW_EXPR, newtype);
6649     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6650     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6651     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6652   }
6653
6654   abort_fndecl
6655     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6656
6657   /* Perform other language dependent initializations.  */
6658   init_class_processing ();
6659   init_init_processing ();
6660   init_search_processing ();
6661   init_rtti_processing ();
6662
6663   if (flag_exceptions)
6664     init_exception_processing ();
6665   if (flag_no_inline)
6666     {
6667       flag_inline_functions = 0;
6668     }
6669
6670   if (! supports_one_only ())
6671     flag_weak = 0;
6672
6673   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6674   function_id_node = get_identifier ("__FUNCTION__");
6675   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6676   func_id_node = get_identifier ("__func__");
6677
6678   make_fname_decl = cp_make_fname_decl;
6679   declare_function_name ();
6680
6681   /* Prepare to check format strings against argument lists.  */
6682   init_function_format_info ();
6683
6684   /* Show we use EH for cleanups.  */
6685   using_eh_for_cleanups ();
6686
6687   valid_lang_attribute = cp_valid_lang_attribute;
6688
6689   /* Maintain consistency.  Perhaps we should just complain if they
6690      say -fwritable-strings?  */
6691   if (flag_writable_strings)
6692     flag_const_strings = 0;
6693
6694   /* Add GC roots for all of our global variables.  */
6695   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6696   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6697   ggc_add_tree_root (&integer_three_node, 1);
6698   ggc_add_tree_root (&integer_two_node, 1);
6699   ggc_add_tree_root (&signed_size_zero_node, 1);
6700   ggc_add_tree_root (&size_one_node, 1);
6701   ggc_add_tree_root (&size_zero_node, 1);
6702   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6703                 mark_binding_level);
6704   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6705   ggc_add_tree_root (&static_ctors, 1);
6706   ggc_add_tree_root (&static_dtors, 1);
6707   ggc_add_tree_root (&lastiddecl, 1);
6708
6709   ggc_add_tree_root (&last_function_parm_tags, 1);
6710   ggc_add_tree_root (&current_function_return_value, 1);
6711   ggc_add_tree_root (&current_function_parm_tags, 1);
6712   ggc_add_tree_root (&last_function_parms, 1);
6713   ggc_add_tree_root (&error_mark_list, 1);
6714
6715   ggc_add_tree_root (&global_namespace, 1);
6716   ggc_add_tree_root (&global_type_node, 1);
6717   ggc_add_tree_root (&anonymous_namespace_name, 1);
6718
6719   ggc_add_tree_root (&got_object, 1);
6720   ggc_add_tree_root (&got_scope, 1);
6721
6722   ggc_add_tree_root (&current_lang_name, 1);
6723   ggc_add_tree_root (&static_aggregates, 1);
6724 }
6725
6726 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6727    decl, NAME is the initialization string and TYPE_DEP indicates whether
6728    NAME depended on the type of the function. We make use of that to detect
6729    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6730    the function before emitting any of it, we don't need to treat the
6731    VAR_DECL specially. We can decide whether to emit it later, if it was
6732    used.  */
6733
6734 static tree
6735 cp_make_fname_decl (id, name, type_dep)
6736      tree id;
6737      const char *name;
6738      int type_dep;
6739 {
6740   tree decl, type, init;
6741   size_t length = strlen (name);
6742   tree domain = NULL_TREE;
6743
6744   if (!processing_template_decl)
6745     type_dep = 0;
6746   if (!type_dep)
6747     domain = build_index_type (build_int_2 (length, 0));
6748
6749   type =  build_cplus_array_type
6750           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6751            domain);
6752
6753   decl = build_decl (VAR_DECL, id, type);
6754   TREE_STATIC (decl) = 1;
6755   TREE_READONLY (decl) = 1;
6756   DECL_SOURCE_LINE (decl) = 0;
6757   DECL_ARTIFICIAL (decl) = 1;
6758   DECL_IN_SYSTEM_HEADER (decl) = 1;
6759   pushdecl (decl);
6760   if (processing_template_decl)
6761     decl = push_template_decl (decl);
6762   if (type_dep)
6763     {
6764       init = build (FUNCTION_NAME, type);
6765       DECL_PRETTY_FUNCTION_P (decl) = 1;
6766     }
6767   else
6768     {
6769       init = build_string (length + 1, name);
6770       TREE_TYPE (init) = type;
6771     }
6772   DECL_INITIAL (decl) = init;
6773   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6774
6775   /* We will have to make sure we only emit this, if it is actually used. */
6776   return decl;
6777 }
6778
6779 /* Entry point for the benefit of c_common_nodes_and_builtins.
6780
6781    Make a definition for a builtin function named NAME and whose data type
6782    is TYPE.  TYPE should be a function type with argument types.
6783
6784    CLASS and CODE tell later passes how to compile calls to this function.
6785    See tree.h for possible values.
6786
6787    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6788    the name to be called if we can't opencode the function.  */
6789
6790 tree
6791 builtin_function (name, type, code, class, libname)
6792      const char *name;
6793      tree type;
6794      int code;
6795      enum built_in_class class;
6796      const char *libname;
6797 {
6798   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6799   DECL_BUILT_IN_CLASS (decl) = class;
6800   DECL_FUNCTION_CODE (decl) = code;
6801
6802   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6803
6804   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6805      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6806      function in the namespace.  */
6807   pushdecl (decl);
6808   if (libname)
6809     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6810   make_function_rtl (decl);
6811
6812   /* Warn if a function in the namespace for users
6813      is used without an occasion to consider it declared.  */
6814   if (name[0] != '_' || name[1] != '_')
6815     DECL_ANTICIPATED (decl) = 1;
6816
6817   return decl;
6818 }
6819
6820 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6821    function.  Not called directly.  */
6822
6823 static tree
6824 build_library_fn_1 (name, operator_code, type)
6825      tree name;
6826      enum tree_code operator_code;
6827      tree type;
6828 {
6829   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6830   DECL_EXTERNAL (fn) = 1;
6831   TREE_PUBLIC (fn) = 1;
6832   DECL_ARTIFICIAL (fn) = 1;
6833   TREE_NOTHROW (fn) = 1;
6834   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6835   return fn;
6836 }
6837
6838 /* Returns the _DECL for a library function with C linkage.
6839    We assume that such functions never throw; if this is incorrect,
6840    callers should unset TREE_NOTHROW.  */
6841
6842 tree
6843 build_library_fn (name, type)
6844      tree name;
6845      tree type;
6846 {
6847   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6848   make_function_rtl (fn);
6849   return fn;
6850 }
6851
6852 /* Returns the _DECL for a library function with C++ linkage.  */
6853
6854 static tree
6855 build_cp_library_fn (name, operator_code, type)
6856      tree name;
6857      enum tree_code operator_code;
6858      tree type;
6859 {
6860   tree fn = build_library_fn_1 (name, operator_code, type);
6861   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6862   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6863   set_mangled_name_for_decl (fn);
6864   make_function_rtl (fn);
6865   return fn;
6866 }
6867
6868 /* Like build_library_fn, but takes a C string instead of an
6869    IDENTIFIER_NODE.  */
6870
6871 tree
6872 build_library_fn_ptr (name, type)
6873      const char *name;
6874      tree type;
6875 {
6876   return build_library_fn (get_identifier (name), type);
6877 }
6878
6879 /* Like build_cp_library_fn, but takes a C string instead of an
6880    IDENTIFIER_NODE.  */
6881
6882 tree
6883 build_cp_library_fn_ptr (name, type)
6884      const char *name;
6885      tree type;
6886 {
6887   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6888 }
6889
6890 /* Like build_library_fn, but also pushes the function so that we will
6891    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6892
6893 tree
6894 push_library_fn (name, type)
6895      tree name, type;
6896 {
6897   tree fn = build_library_fn (name, type);
6898   pushdecl_top_level (fn);
6899   return fn;
6900 }
6901
6902 /* Like build_cp_library_fn, but also pushes the function so that it
6903    will be found by normal lookup.  */
6904
6905 static tree
6906 push_cp_library_fn (operator_code, type)
6907      enum tree_code operator_code;
6908      tree type;
6909 {
6910   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6911                                  operator_code,
6912                                  type);
6913   pushdecl (fn);
6914   return fn;
6915 }
6916
6917 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6918    a FUNCTION_TYPE.  */
6919
6920 tree
6921 push_void_library_fn (name, parmtypes)
6922      tree name, parmtypes;
6923 {
6924   tree type = build_function_type (void_type_node, parmtypes);
6925   return push_library_fn (name, type);
6926 }
6927
6928 /* Like push_library_fn, but also note that this function throws
6929    and does not return.  Used for __throw_foo and the like.  */
6930
6931 tree
6932 push_throw_library_fn (name, type)
6933      tree name, type;
6934 {
6935   tree fn = push_library_fn (name, type);
6936   TREE_THIS_VOLATILE (fn) = 1;
6937   TREE_NOTHROW (fn) = 0;
6938   return fn;
6939 }
6940 \f
6941 /* When we call finish_struct for an anonymous union, we create
6942    default copy constructors and such.  But, an anonymous union
6943    shouldn't have such things; this function undoes the damage to the
6944    anonymous union type T.
6945
6946    (The reason that we create the synthesized methods is that we don't
6947    distinguish `union { int i; }' from `typedef union { int i; } U'.
6948    The first is an anonymous union; the second is just an ordinary
6949    union type.)  */
6950
6951 void
6952 fixup_anonymous_aggr (t)
6953      tree t;
6954 {
6955   tree *q;
6956
6957   /* Wipe out memory of synthesized methods */
6958   TYPE_HAS_CONSTRUCTOR (t) = 0;
6959   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6960   TYPE_HAS_INIT_REF (t) = 0;
6961   TYPE_HAS_CONST_INIT_REF (t) = 0;
6962   TYPE_HAS_ASSIGN_REF (t) = 0;
6963   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6964
6965   /* Splice the implicitly generated functions out of the TYPE_METHODS
6966      list.  */
6967   q = &TYPE_METHODS (t);
6968   while (*q)
6969     {
6970       if (DECL_ARTIFICIAL (*q))
6971         *q = TREE_CHAIN (*q);
6972       else
6973         q = &TREE_CHAIN (*q);
6974     }
6975
6976   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6977   if (TYPE_METHODS (t))
6978     error ("an anonymous union cannot have function members");
6979 }
6980
6981 /* Make sure that a declaration with no declarator is well-formed, i.e.
6982    just defines a tagged type or anonymous union.
6983
6984    Returns the type defined, if any.  */
6985
6986 tree
6987 check_tag_decl (declspecs)
6988      tree declspecs;
6989 {
6990   int found_type = 0;
6991   int saw_friend = 0;
6992   tree ob_modifier = NULL_TREE;
6993   register tree link;
6994   register tree t = NULL_TREE;
6995
6996   for (link = declspecs; link; link = TREE_CHAIN (link))
6997     {
6998       register tree value = TREE_VALUE (link);
6999
7000       if (TYPE_P (value)
7001           || (TREE_CODE (value) == IDENTIFIER_NODE
7002               && IDENTIFIER_GLOBAL_VALUE (value)
7003               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7004         {
7005           ++found_type;
7006
7007           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7008               || TREE_CODE (value) == ENUMERAL_TYPE)
7009             {
7010               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7011               t = value;
7012             }
7013         }
7014       else if (value == ridpointers[(int) RID_FRIEND])
7015         {
7016           if (current_class_type == NULL_TREE
7017               || current_scope () != current_class_type)
7018             ob_modifier = value;
7019           else
7020             saw_friend = 1;
7021         }
7022       else if (value == ridpointers[(int) RID_STATIC]
7023                || value == ridpointers[(int) RID_EXTERN]
7024                || value == ridpointers[(int) RID_AUTO]
7025                || value == ridpointers[(int) RID_REGISTER]
7026                || value == ridpointers[(int) RID_INLINE]
7027                || value == ridpointers[(int) RID_VIRTUAL]
7028                || value == ridpointers[(int) RID_CONST]
7029                || value == ridpointers[(int) RID_VOLATILE]
7030                || value == ridpointers[(int) RID_EXPLICIT])
7031         ob_modifier = value;
7032     }
7033
7034   if (found_type > 1)
7035     error ("multiple types in one declaration");
7036
7037   if (t == NULL_TREE && ! saw_friend)
7038     pedwarn ("declaration does not declare anything");
7039
7040   /* Check for an anonymous union.  We're careful
7041      accessing TYPE_IDENTIFIER because some built-in types, like
7042      pointer-to-member types, do not have TYPE_NAME.  */
7043   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7044            && TYPE_NAME (t)
7045            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7046     {
7047       /* Anonymous unions are objects, so they can have specifiers.  */;
7048       SET_ANON_AGGR_TYPE_P (t);
7049
7050       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7051         pedwarn ("ISO C++ prohibits anonymous structs");
7052     }
7053
7054   else if (ob_modifier)
7055     {
7056       if (ob_modifier == ridpointers[(int) RID_INLINE]
7057           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7058         cp_error ("`%D' can only be specified for functions", ob_modifier);
7059       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7060         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7061       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7062         cp_error ("`%D' can only be specified for constructors",
7063                   ob_modifier);
7064       else
7065         cp_error ("`%D' can only be specified for objects and functions",
7066                   ob_modifier);
7067     }
7068
7069   return t;
7070 }
7071
7072 /* Called when a declaration is seen that contains no names to declare.
7073    If its type is a reference to a structure, union or enum inherited
7074    from a containing scope, shadow that tag name for the current scope
7075    with a forward reference.
7076    If its type defines a new named structure or union
7077    or defines an enum, it is valid but we need not do anything here.
7078    Otherwise, it is an error.
7079
7080    C++: may have to grok the declspecs to learn about static,
7081    complain for anonymous unions.  */
7082
7083 void
7084 shadow_tag (declspecs)
7085      tree declspecs;
7086 {
7087   tree t = check_tag_decl (declspecs);
7088
7089   if (t)
7090     maybe_process_partial_specialization (t);
7091
7092   /* This is where the variables in an anonymous union are
7093      declared.  An anonymous union declaration looks like:
7094      union { ... } ;
7095      because there is no declarator after the union, the parser
7096      sends that declaration here.  */
7097   if (t && ANON_AGGR_TYPE_P (t))
7098     {
7099       fixup_anonymous_aggr (t);
7100
7101       if (TYPE_FIELDS (t))
7102         {
7103           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7104                                       NULL_TREE);
7105           finish_anon_union (decl);
7106         }
7107     }
7108 }
7109 \f
7110 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7111
7112 tree
7113 groktypename (typename)
7114      tree typename;
7115 {
7116   if (TREE_CODE (typename) != TREE_LIST)
7117     return typename;
7118   return grokdeclarator (TREE_VALUE (typename),
7119                          TREE_PURPOSE (typename),
7120                          TYPENAME, 0, NULL_TREE);
7121 }
7122
7123 /* Decode a declarator in an ordinary declaration or data definition.
7124    This is called as soon as the type information and variable name
7125    have been parsed, before parsing the initializer if any.
7126    Here we create the ..._DECL node, fill in its type,
7127    and put it on the list of decls for the current context.
7128    The ..._DECL node is returned as the value.
7129
7130    Exception: for arrays where the length is not specified,
7131    the type is left null, to be filled in by `cp_finish_decl'.
7132
7133    Function definitions do not come here; they go to start_function
7134    instead.  However, external and forward declarations of functions
7135    do go through here.  Structure field declarations are done by
7136    grokfield and not through here.  */
7137
7138 tree
7139 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7140      tree declarator, declspecs;
7141      int initialized;
7142      tree attributes, prefix_attributes;
7143 {
7144   register tree decl;
7145   register tree type, tem;
7146   tree context;
7147   extern int have_extern_spec;
7148   extern int used_extern_spec;
7149   tree attrlist;
7150
7151 #if 0
7152   /* See code below that used this.  */
7153   int init_written = initialized;
7154 #endif
7155
7156   /* This should only be done once on the top most decl.  */
7157   if (have_extern_spec && !used_extern_spec)
7158     {
7159       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7160                              declspecs);
7161       used_extern_spec = 1;
7162     }
7163
7164   if (attributes || prefix_attributes)
7165     attrlist = build_tree_list (attributes, prefix_attributes);
7166   else
7167     attrlist = NULL_TREE;
7168
7169   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7170                          attrlist);
7171
7172   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7173     return NULL_TREE;
7174
7175   type = TREE_TYPE (decl);
7176
7177   if (type == error_mark_node)
7178     return NULL_TREE;
7179
7180   context = DECL_CONTEXT (decl);
7181
7182   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7183       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7184     {
7185       /* When parsing the initializer, lookup should use the object's
7186          namespace. */
7187       push_decl_namespace (context);
7188     }
7189
7190   /* We are only interested in class contexts, later. */
7191   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7192     context = NULL_TREE;
7193
7194   if (initialized)
7195     /* Is it valid for this decl to have an initializer at all?
7196        If not, set INITIALIZED to zero, which will indirectly
7197        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7198     switch (TREE_CODE (decl))
7199       {
7200       case TYPE_DECL:
7201         /* typedef foo = bar  means give foo the same type as bar.
7202            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7203            Any other case of an initialization in a TYPE_DECL is an error.  */
7204         if (pedantic || list_length (declspecs) > 1)
7205           {
7206             cp_error ("typedef `%D' is initialized", decl);
7207             initialized = 0;
7208           }
7209         break;
7210
7211       case FUNCTION_DECL:
7212         cp_error ("function `%#D' is initialized like a variable", decl);
7213         initialized = 0;
7214         break;
7215
7216       default:
7217         break;
7218       }
7219
7220   if (initialized)
7221     {
7222       if (! toplevel_bindings_p ()
7223           && DECL_EXTERNAL (decl))
7224         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7225                     decl);
7226       DECL_EXTERNAL (decl) = 0;
7227       if (toplevel_bindings_p ())
7228         TREE_STATIC (decl) = 1;
7229
7230       /* Tell `pushdecl' this is an initialized decl
7231          even though we don't yet have the initializer expression.
7232          Also tell `cp_finish_decl' it may store the real initializer.  */
7233       DECL_INITIAL (decl) = error_mark_node;
7234     }
7235
7236 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7237   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7238 #endif
7239
7240   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7241   cplus_decl_attributes (decl, attributes, prefix_attributes);
7242
7243   if (context && COMPLETE_TYPE_P (complete_type (context)))
7244     {
7245       push_nested_class (context, 2);
7246
7247       if (TREE_CODE (decl) == VAR_DECL)
7248         {
7249           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7250           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7251             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7252           else
7253             {
7254               if (DECL_CONTEXT (field) != context)
7255                 {
7256                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7257                               DECL_CONTEXT (field), DECL_NAME (decl),
7258                               context, DECL_NAME (decl));
7259                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7260                 }
7261               /* Static data member are tricky; an in-class initialization
7262                  still doesn't provide a definition, so the in-class
7263                  declaration will have DECL_EXTERNAL set, but will have an
7264                  initialization.  Thus, duplicate_decls won't warn
7265                  about this situation, and so we check here.  */
7266               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7267                 cp_error ("duplicate initialization of %D", decl);
7268               if (duplicate_decls (decl, field))
7269                 decl = field;
7270             }
7271         }
7272       else
7273         {
7274           tree field = check_classfn (context, decl);
7275           if (field && duplicate_decls (decl, field))
7276             decl = field;
7277         }
7278
7279       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7280       DECL_IN_AGGR_P (decl) = 0;
7281       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7282           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7283         {
7284           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7285           /* [temp.expl.spec] An explicit specialization of a static data
7286              member of a template is a definition if the declaration
7287              includes an initializer; otherwise, it is a declaration.
7288
7289              We check for processing_specialization so this only applies
7290              to the new specialization syntax.  */
7291           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7292             DECL_EXTERNAL (decl) = 1;
7293         }
7294
7295       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7296         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7297                     decl);
7298     }
7299
7300   /* Enter this declaration into the symbol table.  */
7301   tem = maybe_push_decl (decl);
7302
7303   if (processing_template_decl)
7304     tem = push_template_decl (tem);
7305
7306 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7307   /* Tell the back-end to use or not use .common as appropriate.  If we say
7308      -fconserve-space, we want this to save .data space, at the expense of
7309      wrong semantics.  If we say -fno-conserve-space, we want this to
7310      produce errors about redefs; to do this we force variables into the
7311      data segment.  */
7312   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7313 #endif
7314
7315   if (! processing_template_decl)
7316     start_decl_1 (tem);
7317
7318   return tem;
7319 }
7320
7321 void
7322 start_decl_1 (decl)
7323      tree decl;
7324 {
7325   tree type = TREE_TYPE (decl);
7326   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7327
7328   if (type == error_mark_node)
7329     return;
7330
7331   /* If this type of object needs a cleanup, but we're not allowed to
7332      add any more objects with cleanups to the current scope, create a
7333      new binding level.  */
7334   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7335       && current_binding_level->more_cleanups_ok == 0)
7336     {
7337       keep_next_level (2);
7338       pushlevel (1);
7339       clear_last_expr ();
7340       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7341     }
7342
7343   if (initialized)
7344     /* Is it valid for this decl to have an initializer at all?
7345        If not, set INITIALIZED to zero, which will indirectly
7346        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7347     {
7348       /* Don't allow initializations for incomplete types except for
7349          arrays which might be completed by the initialization.  */
7350       if (COMPLETE_TYPE_P (complete_type (type)))
7351         ;                       /* A complete type is ok.  */
7352       else if (TREE_CODE (type) != ARRAY_TYPE)
7353         {
7354           cp_error ("variable `%#D' has initializer but incomplete type",
7355                     decl);
7356           initialized = 0;
7357           type = TREE_TYPE (decl) = error_mark_node;
7358         }
7359       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7360         {
7361           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7362             cp_error ("elements of array `%#D' have incomplete type", decl);
7363           /* else we already gave an error in start_decl.  */
7364           initialized = 0;
7365         }
7366     }
7367
7368   if (!initialized
7369       && TREE_CODE (decl) != TYPE_DECL
7370       && TREE_CODE (decl) != TEMPLATE_DECL
7371       && type != error_mark_node
7372       && IS_AGGR_TYPE (type)
7373       && ! DECL_EXTERNAL (decl))
7374     {
7375       if ((! processing_template_decl || ! uses_template_parms (type))
7376           && !COMPLETE_TYPE_P (complete_type (type)))
7377         {
7378           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7379                  decl);
7380           /* Change the type so that assemble_variable will give
7381              DECL an rtl we can live with: (mem (const_int 0)).  */
7382           type = TREE_TYPE (decl) = error_mark_node;
7383         }
7384       else
7385         {
7386           /* If any base type in the hierarchy of TYPE needs a constructor,
7387              then we set initialized to 1.  This way any nodes which are
7388              created for the purposes of initializing this aggregate
7389              will live as long as it does.  This is necessary for global
7390              aggregates which do not have their initializers processed until
7391              the end of the file.  */
7392           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7393         }
7394     }
7395
7396   if (! initialized)
7397     DECL_INITIAL (decl) = NULL_TREE;
7398 }
7399
7400 /* Handle initialization of references.
7401    These three arguments are from `cp_finish_decl', and have the
7402    same meaning here that they do there.
7403
7404    Quotes on semantics can be found in ARM 8.4.3.  */
7405
7406 static void
7407 grok_reference_init (decl, type, init)
7408      tree decl, type, init;
7409 {
7410   tree tmp;
7411
7412   if (init == NULL_TREE)
7413     {
7414       if ((DECL_LANG_SPECIFIC (decl) == 0
7415            || DECL_IN_AGGR_P (decl) == 0)
7416           && ! DECL_THIS_EXTERN (decl))
7417         cp_error ("`%D' declared as reference but not initialized", decl);
7418       return;
7419     }
7420
7421   if (init == error_mark_node)
7422     return;
7423
7424   if (TREE_CODE (init) == CONSTRUCTOR)
7425     {
7426       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7427       return;
7428     }
7429
7430   if (TREE_CODE (init) == TREE_LIST)
7431     init = build_compound_expr (init);
7432
7433   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7434     init = convert_from_reference (init);
7435
7436   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7437       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7438     {
7439       /* Note: default conversion is only called in very special cases.  */
7440       init = default_conversion (init);
7441     }
7442
7443   /* Convert INIT to the reference type TYPE.  This may involve the
7444      creation of a temporary, whose lifetime must be the same as that
7445      of the reference.  If so, a DECL_STMT for the temporary will be
7446      added just after the DECL_STMT for DECL.  That's why we don't set
7447      DECL_INITIAL for local references (instead assigning to them
7448      explicitly); we need to allow the temporary to be initialized
7449      first.  */
7450   tmp = convert_to_reference
7451     (type, init, CONV_IMPLICIT,
7452      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7453      decl);
7454
7455   if (tmp == error_mark_node)
7456     return;
7457   else if (tmp != NULL_TREE)
7458     {
7459       init = tmp;
7460       tmp = save_expr (tmp);
7461       if (building_stmt_tree ())
7462         {
7463           /* Initialize the declaration.  */
7464           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7465           finish_expr_stmt (tmp);
7466         }
7467       else
7468         DECL_INITIAL (decl) = tmp;
7469     }
7470   else
7471     {
7472       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7473       return;
7474     }
7475
7476   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7477     {
7478       expand_static_init (decl, DECL_INITIAL (decl));
7479       DECL_INITIAL (decl) = NULL_TREE;
7480     }
7481   return;
7482 }
7483
7484 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7485    mucking with forces it does not comprehend (i.e. initialization with a
7486    constructor).  If we are at global scope and won't go into COMMON, fill
7487    it in with a dummy CONSTRUCTOR to force the variable into .data;
7488    otherwise we can use error_mark_node.  */
7489
7490 static tree
7491 obscure_complex_init (decl, init)
7492      tree decl, init;
7493 {
7494   if (! flag_no_inline && TREE_STATIC (decl))
7495     {
7496       if (extract_init (decl, init))
7497         return NULL_TREE;
7498     }
7499
7500 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7501   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7502     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7503                                  NULL_TREE);
7504   else
7505 #endif
7506     DECL_INITIAL (decl) = error_mark_node;
7507
7508   return init;
7509 }
7510
7511 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7512    array until we finish parsing the initializer.  If that's the
7513    situation we're in, update DECL accordingly.  */
7514
7515 static void
7516 maybe_deduce_size_from_array_init (decl, init)
7517      tree decl;
7518      tree init;
7519 {
7520   tree type = TREE_TYPE (decl);
7521
7522   if (TREE_CODE (type) == ARRAY_TYPE
7523       && TYPE_DOMAIN (type) == NULL_TREE
7524       && TREE_CODE (decl) != TYPE_DECL)
7525     {
7526       /* do_default is really a C-ism to deal with tentative definitions.
7527          But let's leave it here to ease the eventual merge.  */
7528       int do_default = !DECL_EXTERNAL (decl);
7529       tree initializer = init ? init : DECL_INITIAL (decl);
7530       int failure = complete_array_type (type, initializer, do_default);
7531
7532       if (failure == 1)
7533         cp_error ("initializer fails to determine size of `%D'", decl);
7534
7535       if (failure == 2)
7536         {
7537           if (do_default)
7538             cp_error ("array size missing in `%D'", decl);
7539           /* If a `static' var's size isn't known, make it extern as
7540              well as static, so it does not get allocated.  If it's not
7541              `static', then don't mark it extern; finish_incomplete_decl
7542              will give it a default size and it will get allocated.  */
7543           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7544             DECL_EXTERNAL (decl) = 1;
7545         }
7546
7547       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7548           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7549                               integer_zero_node))
7550         cp_error ("zero-size array `%D'", decl);
7551
7552       layout_decl (decl, 0);
7553     }
7554 }
7555
7556 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7557    any appropriate error messages regarding the layout.  */
7558
7559 static void
7560 layout_var_decl (decl)
7561      tree decl;
7562 {
7563   tree type = TREE_TYPE (decl);
7564 #if 0
7565   tree ttype = target_type (type);
7566 #endif
7567
7568   /* If we haven't already layed out this declaration, do so now.
7569      Note that we must not call complete type for an external object
7570      because it's type might involve templates that we are not
7571      supposed to isntantiate yet.  (And it's perfectly legal to say
7572      `extern X x' for some incomplete type `X'.)  */
7573   if (!DECL_EXTERNAL (decl))
7574     complete_type (type);
7575   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7576     layout_decl (decl, 0);
7577
7578   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7579     {
7580       /* An automatic variable with an incomplete type: that is an error.
7581          Don't talk about array types here, since we took care of that
7582          message in grokdeclarator.  */
7583       cp_error ("storage size of `%D' isn't known", decl);
7584       TREE_TYPE (decl) = error_mark_node;
7585     }
7586 #if 0
7587   /* Keep this code around in case we later want to control debug info
7588      based on whether a type is "used".  (jason 1999-11-11) */
7589
7590   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7591     /* Let debugger know it should output info for this type.  */
7592     note_debug_info_needed (ttype);
7593
7594   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7595     note_debug_info_needed (DECL_CONTEXT (decl));
7596 #endif
7597
7598   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7599       && DECL_SIZE (decl) != NULL_TREE
7600       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7601     {
7602       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7603         constant_expression_warning (DECL_SIZE (decl));
7604       else
7605         cp_error ("storage size of `%D' isn't constant", decl);
7606     }
7607 }
7608
7609 /* If a local static variable is declared in an inline function, or if
7610    we have a weak definition, we must endeavor to create only one
7611    instance of the variable at link-time.  */
7612
7613 static void
7614 maybe_commonize_var (decl)
7615      tree decl;
7616 {
7617   /* Static data in a function with comdat linkage also has comdat
7618      linkage.  */
7619   if (TREE_STATIC (decl)
7620       /* Don't mess with __FUNCTION__.  */
7621       && ! DECL_ARTIFICIAL (decl)
7622       && current_function_decl
7623       && DECL_CONTEXT (decl) == current_function_decl
7624       && (DECL_THIS_INLINE (current_function_decl)
7625           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7626       && TREE_PUBLIC (current_function_decl))
7627     {
7628       /* Rather than try to get this right with inlining, we suppress
7629          inlining of such functions.  */
7630       current_function_cannot_inline
7631         = "function with static variable cannot be inline";
7632
7633       /* If flag_weak, we don't need to mess with this, as we can just
7634          make the function weak, and let it refer to its unique local
7635          copy.  This works because we don't allow the function to be
7636          inlined.  */
7637       if (! flag_weak)
7638         {
7639           if (DECL_INTERFACE_KNOWN (current_function_decl))
7640             {
7641               TREE_PUBLIC (decl) = 1;
7642               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7643             }
7644           else if (DECL_INITIAL (decl) == NULL_TREE
7645                    || DECL_INITIAL (decl) == error_mark_node)
7646             {
7647               TREE_PUBLIC (decl) = 1;
7648               DECL_COMMON (decl) = 1;
7649             }
7650           /* else we lose. We can only do this if we can use common,
7651              which we can't if it has been initialized.  */
7652
7653           if (TREE_PUBLIC (decl))
7654             DECL_ASSEMBLER_NAME (decl)
7655               = build_static_name (current_function_decl, DECL_NAME (decl));
7656           else
7657             {
7658               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7659               cp_warning_at ("  you can work around this by removing the initializer", decl);
7660             }
7661         }
7662     }
7663   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7664     /* Set it up again; we might have set DECL_INITIAL since the last
7665        time.  */
7666     comdat_linkage (decl);
7667 }
7668
7669 /* Issue an error message if DECL is an uninitialized const variable.  */
7670
7671 static void
7672 check_for_uninitialized_const_var (decl)
7673      tree decl;
7674 {
7675   tree type = TREE_TYPE (decl);
7676
7677   /* ``Unless explicitly declared extern, a const object does not have
7678      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7679      7.1.6 */
7680   if (TREE_CODE (decl) == VAR_DECL
7681       && TREE_CODE (type) != REFERENCE_TYPE
7682       && CP_TYPE_CONST_P (type)
7683       && !TYPE_NEEDS_CONSTRUCTING (type)
7684       && !DECL_INITIAL (decl))
7685     cp_error ("uninitialized const `%D'", decl);
7686 }
7687
7688 /* Verify INIT (the initializer for DECL), and record the
7689    initialization in DECL_INITIAL, if appropriate.  Returns a new
7690    value for INIT.  */
7691
7692 static tree
7693 check_initializer (decl, init)
7694      tree decl;
7695      tree init;
7696 {
7697   tree type;
7698
7699   if (TREE_CODE (decl) == FIELD_DECL)
7700     return init;
7701
7702   type = TREE_TYPE (decl);
7703
7704   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7705   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7706     init = NULL_TREE;
7707
7708   /* Check the initializer.  */
7709   if (init)
7710     {
7711       /* Things that are going to be initialized need to have complete
7712          type.  */
7713       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7714
7715       if (type == error_mark_node)
7716         /* We will have already complained.  */
7717         init = NULL_TREE;
7718       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7719         {
7720           cp_error ("variable-sized object `%D' may not be initialized", decl);
7721           init = NULL_TREE;
7722         }
7723       else if (TREE_CODE (type) == ARRAY_TYPE
7724                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7725         {
7726           cp_error ("elements of array `%#D' have incomplete type", decl);
7727           init = NULL_TREE;
7728         }
7729       else if (!COMPLETE_TYPE_P (type))
7730         {
7731           cp_error ("`%D' has incomplete type", decl);
7732           TREE_TYPE (decl) = error_mark_node;
7733           init = NULL_TREE;
7734         }
7735     }
7736
7737   if (TREE_CODE (decl) == CONST_DECL)
7738     {
7739       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7740
7741       DECL_INITIAL (decl) = init;
7742
7743       /* This will keep us from needing to worry about our obstacks.  */
7744       my_friendly_assert (init != NULL_TREE, 149);
7745       init = NULL_TREE;
7746     }
7747   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7748     {
7749       if (TREE_STATIC (decl))
7750         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7751       grok_reference_init (decl, type, init);
7752       init = NULL_TREE;
7753     }
7754   else if (init)
7755     {
7756       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7757         {
7758           if (TREE_CODE (type) == ARRAY_TYPE)
7759             init = digest_init (type, init, (tree *) 0);
7760           else if (TREE_CODE (init) == CONSTRUCTOR
7761                    && TREE_HAS_CONSTRUCTOR (init))
7762             {
7763               if (TYPE_NON_AGGREGATE_CLASS (type))
7764                 {
7765                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7766                             decl);
7767                   init = error_mark_node;
7768                 }
7769               else
7770                 goto dont_use_constructor;
7771             }
7772         }
7773       else
7774         {
7775         dont_use_constructor:
7776           if (TREE_CODE (init) != TREE_VEC)
7777             init = store_init_value (decl, init);
7778         }
7779
7780       if (init)
7781         /* We must hide the initializer so that expand_decl
7782            won't try to do something it does not understand.  */
7783         init = obscure_complex_init (decl, init);
7784     }
7785   else if (DECL_EXTERNAL (decl))
7786     ;
7787   else if (TYPE_P (type)
7788            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7789     {
7790       tree core_type = strip_array_types (type);
7791
7792       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7793         {
7794           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7795             cp_error ("structure `%D' with uninitialized const members", decl);
7796           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7797             cp_error ("structure `%D' with uninitialized reference members",
7798                       decl);
7799         }
7800
7801       check_for_uninitialized_const_var (decl);
7802
7803       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7804         init = obscure_complex_init (decl, NULL_TREE);
7805
7806     }
7807   else
7808     check_for_uninitialized_const_var (decl);
7809
7810   return init;
7811 }
7812
7813 /* If DECL is not a local variable, give it RTL.  */
7814
7815 static void
7816 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7817      tree decl;
7818      tree init;
7819      const char *asmspec;
7820 {
7821   int toplev = toplevel_bindings_p ();
7822   int defer_p;
7823
7824   /* Handle non-variables up front.  */
7825   if (TREE_CODE (decl) != VAR_DECL)
7826     {
7827       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7828       return;
7829     }
7830
7831   /* If we see a class member here, it should be a static data
7832      member.  */
7833   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7834     {
7835       my_friendly_assert (TREE_STATIC (decl), 19990828);
7836       /* An in-class declaration of a static data member should be
7837          external; it is only a declaration, and not a definition.  */
7838       if (init == NULL_TREE)
7839         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7840     }
7841
7842   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7843   if (asmspec)
7844     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7845
7846   /* We don't create any RTL for local variables.  */
7847   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7848     return;
7849
7850   /* We defer emission of local statics until the corresponding
7851      DECL_STMT is expanded.  */
7852   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7853
7854   /* We try to defer namespace-scope static constants so that they are
7855      not emitted into the object file unncessarily.  */
7856   if (!DECL_VIRTUAL_P (decl)
7857       && TREE_READONLY (decl)
7858       && DECL_INITIAL (decl) != NULL_TREE
7859       && DECL_INITIAL (decl) != error_mark_node
7860       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7861       && toplev
7862       && !TREE_PUBLIC (decl))
7863     {
7864       /* Fool with the linkage according to #pragma interface.  */
7865       if (!interface_unknown)
7866         {
7867           TREE_PUBLIC (decl) = 1;
7868           DECL_EXTERNAL (decl) = interface_only;
7869         }
7870
7871       defer_p = 1;
7872     }
7873
7874   /* If we're deferring the variable, just make RTL.  Do not actually
7875      emit the variable.  */
7876   if (defer_p)
7877     make_decl_rtl (decl, asmspec, toplev);
7878   /* If we're not deferring, go ahead and assemble the variable.  */
7879   else
7880     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7881 }
7882
7883 /* The old ARM scoping rules injected variables declared in the
7884    initialization statement of a for-statement into the surrounding
7885    scope.  We support this usage, in order to be backward-compatible.
7886    DECL is a just-declared VAR_DECL; if necessary inject its
7887    declaration into the surrounding scope.  */
7888
7889 void
7890 maybe_inject_for_scope_var (decl)
7891      tree decl;
7892 {
7893   if (!DECL_NAME (decl))
7894     return;
7895
7896   if (current_binding_level->is_for_scope)
7897     {
7898       struct binding_level *outer
7899         = current_binding_level->level_chain;
7900
7901       /* Check to see if the same name is already bound at the outer
7902          level, either because it was directly declared, or because a
7903          dead for-decl got preserved.  In either case, the code would
7904          not have been valid under the ARM scope rules, so clear
7905          is_for_scope for the current_binding_level.
7906
7907          Otherwise, we need to preserve the temp slot for decl to last
7908          into the outer binding level.  */
7909
7910       tree outer_binding
7911         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7912
7913       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7914           && (TREE_CODE (BINDING_VALUE (outer_binding))
7915               == VAR_DECL)
7916           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7917         {
7918           BINDING_VALUE (outer_binding)
7919             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7920           current_binding_level->is_for_scope = 0;
7921         }
7922       else if (DECL_IN_MEMORY_P (decl))
7923         preserve_temp_slots (DECL_RTL (decl));
7924     }
7925 }
7926
7927 /* Generate code to initialize DECL (a local variable).  */
7928
7929 void
7930 initialize_local_var (decl, init, flags)
7931      tree decl;
7932      tree init;
7933      int flags;
7934 {
7935   tree type = TREE_TYPE (decl);
7936
7937   /* If the type is bogus, don't bother initializing the variable.  */
7938   if (type == error_mark_node)
7939     return;
7940
7941   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7942     {
7943       /* If we used it already as memory, it must stay in memory.  */
7944       DECL_INITIAL (decl) = NULL_TREE;
7945       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7946     }
7947
7948   /* Local statics are handled differently from ordinary automatic
7949      variables.  */
7950   if (TREE_STATIC (decl))
7951     {
7952       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7953           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7954         expand_static_init (decl, init);
7955       return;
7956     }
7957
7958   if (DECL_SIZE (decl) && type != error_mark_node)
7959     {
7960       int already_used;
7961
7962       /* Compute and store the initial value.  */
7963       already_used = TREE_USED (decl) || TREE_USED (type);
7964
7965       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7966         {
7967           int saved_stmts_are_full_exprs_p;
7968
7969           my_friendly_assert (building_stmt_tree (), 20000906);
7970           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7971           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7972           finish_expr_stmt (build_aggr_init (decl, init, flags));
7973           current_stmt_tree ()->stmts_are_full_exprs_p =
7974             saved_stmts_are_full_exprs_p;
7975         }
7976
7977       /* Set this to 0 so we can tell whether an aggregate which was
7978          initialized was ever used.  Don't do this if it has a
7979          destructor, so we don't complain about the 'resource
7980          allocation is initialization' idiom.  Now set
7981          attribute((unused)) on types so decls of that type will be
7982          marked used. (see TREE_USED, above.)  */
7983       if (TYPE_NEEDS_CONSTRUCTING (type)
7984           && ! already_used
7985           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7986           && DECL_NAME (decl))
7987         TREE_USED (decl) = 0;
7988       else if (already_used)
7989         TREE_USED (decl) = 1;
7990     }
7991 }
7992
7993 /* Generate code to destroy DECL (a local variable).  */
7994
7995 static void
7996 destroy_local_var (decl)
7997      tree decl;
7998 {
7999   tree type = TREE_TYPE (decl);
8000   tree cleanup;
8001
8002   /* Only variables get cleaned up.  */
8003   if (TREE_CODE (decl) != VAR_DECL)
8004     return;
8005
8006   /* And only things with destructors need cleaning up.  */
8007   if (type == error_mark_node
8008       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8009     return;
8010
8011   if (TREE_CODE (decl) == VAR_DECL &&
8012       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8013     /* We don't clean up things that aren't defined in this
8014        translation unit, or that need a static cleanup.  The latter
8015        are handled by finish_file.  */
8016     return;
8017
8018   /* Compute the cleanup.  */
8019   cleanup = maybe_build_cleanup (decl);
8020
8021   /* Record the cleanup required for this declaration.  */
8022   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8023       && cleanup)
8024     finish_decl_cleanup (decl, cleanup);
8025 }
8026
8027 /* Finish processing of a declaration;
8028    install its line number and initial value.
8029    If the length of an array type is not known before,
8030    it must be determined now, from the initial value, or it is an error.
8031
8032    INIT holds the value of an initializer that should be allowed to escape
8033    the normal rules.
8034
8035    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8036    if the (init) syntax was used.  */
8037
8038 void
8039 cp_finish_decl (decl, init, asmspec_tree, flags)
8040      tree decl, init;
8041      tree asmspec_tree;
8042      int flags;
8043 {
8044   register tree type;
8045   tree ttype = NULL_TREE;
8046   const char *asmspec = NULL;
8047   int was_readonly = 0;
8048
8049   if (! decl)
8050     {
8051       if (init)
8052         error ("assignment (not initialization) in declaration");
8053       return;
8054     }
8055
8056   /* If a name was specified, get the string.  */
8057   if (asmspec_tree)
8058       asmspec = TREE_STRING_POINTER (asmspec_tree);
8059
8060   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8061     {
8062       cp_error ("cannot initialize `%D' to namespace `%D'",
8063                 decl, init);
8064       init = NULL_TREE;
8065     }
8066
8067   if (current_class_type
8068       && CP_DECL_CONTEXT (decl) == current_class_type
8069       && TYPE_BEING_DEFINED (current_class_type)
8070       && (DECL_INITIAL (decl) || init))
8071     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8072
8073   if (TREE_CODE (decl) == VAR_DECL
8074       && DECL_CONTEXT (decl)
8075       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8076       && DECL_CONTEXT (decl) != current_namespace
8077       && init)
8078     {
8079       /* Leave the namespace of the object. */
8080       pop_decl_namespace ();
8081     }
8082
8083   type = TREE_TYPE (decl);
8084
8085   if (type == error_mark_node)
8086     return;
8087
8088   /* Add this declaration to the statement-tree.  */
8089   if (building_stmt_tree ()
8090       && at_function_scope_p ()
8091       && TREE_CODE (decl) != RESULT_DECL)
8092     add_decl_stmt (decl);
8093
8094   if (TYPE_HAS_MUTABLE_P (type))
8095     TREE_READONLY (decl) = 0;
8096
8097   if (processing_template_decl)
8098     {
8099       if (init && DECL_INITIAL (decl))
8100         DECL_INITIAL (decl) = init;
8101       goto finish_end0;
8102     }
8103
8104   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8105   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8106
8107   /* Take care of TYPE_DECLs up front.  */
8108   if (TREE_CODE (decl) == TYPE_DECL)
8109     {
8110       if (init && DECL_INITIAL (decl))
8111         {
8112           /* typedef foo = bar; store the type of bar as the type of foo.  */
8113           TREE_TYPE (decl) = type = TREE_TYPE (init);
8114           DECL_INITIAL (decl) = init = NULL_TREE;
8115         }
8116       if (type != error_mark_node
8117           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8118         {
8119           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8120             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8121           set_identifier_type_value (DECL_NAME (decl), type);
8122           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8123         }
8124       GNU_xref_decl (current_function_decl, decl);
8125
8126       /* If we have installed this as the canonical typedef for this
8127          type, and that type has not been defined yet, delay emitting
8128          the debug information for it, as we will emit it later.  */
8129       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8130           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8131         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8132
8133       rest_of_decl_compilation (decl, NULL_PTR,
8134                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8135       goto finish_end;
8136     }
8137
8138   if (TREE_CODE (decl) != FUNCTION_DECL)
8139     ttype = target_type (type);
8140
8141   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8142       && TYPE_NEEDS_CONSTRUCTING (type))
8143     {
8144       /* Currently, GNU C++ puts constants in text space, making them
8145          impossible to initialize.  In the future, one would hope for
8146          an operating system which understood the difference between
8147          initialization and the running of a program.  */
8148       was_readonly = 1;
8149       TREE_READONLY (decl) = 0;
8150     }
8151
8152   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8153     {
8154       /* This must override the asm specifier which was placed by
8155          grokclassfn.  Lay this out fresh.  */
8156       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8157       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8158       make_decl_rtl (decl, asmspec, 0);
8159     }
8160
8161   /* Deduce size of array from initialization, if not already known.  */
8162   maybe_deduce_size_from_array_init (decl, init);
8163   init = check_initializer (decl, init);
8164
8165   GNU_xref_decl (current_function_decl, decl);
8166
8167   if (TREE_CODE (decl) == VAR_DECL)
8168     layout_var_decl (decl);
8169
8170   /* Output the assembler code and/or RTL code for variables and functions,
8171      unless the type is an undefined structure or union.
8172      If not, it will get done when the type is completed.  */
8173   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8174       || TREE_CODE (decl) == RESULT_DECL)
8175     {
8176       if (TREE_CODE (decl) == VAR_DECL)
8177         maybe_commonize_var (decl);
8178
8179       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8180
8181       if (TREE_CODE (type) == FUNCTION_TYPE
8182           || TREE_CODE (type) == METHOD_TYPE)
8183         abstract_virtuals_error (decl,
8184                                  strip_array_types (TREE_TYPE (type)));
8185       else
8186         abstract_virtuals_error (decl, strip_array_types (type));
8187
8188       if (TREE_CODE (decl) == FUNCTION_DECL)
8189         ;
8190       else if (DECL_EXTERNAL (decl)
8191                && ! (DECL_LANG_SPECIFIC (decl)
8192                      && DECL_NOT_REALLY_EXTERN (decl)))
8193         {
8194           if (init)
8195             DECL_INITIAL (decl) = init;
8196         }
8197       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8198         {
8199           /* This is a local declaration.  */
8200           if (doing_semantic_analysis_p ())
8201             maybe_inject_for_scope_var (decl);
8202           /* Initialize the local variable.  But, if we're building a
8203              statement-tree, we'll do the initialization when we
8204              expand the tree.  */
8205           if (processing_template_decl)
8206             {
8207               if (init || DECL_INITIAL (decl) == error_mark_node)
8208                 DECL_INITIAL (decl) = init;
8209             }
8210           else
8211             {
8212               /* If we're not building RTL, then we need to do so
8213                  now.  */
8214               my_friendly_assert (building_stmt_tree (), 20000906);
8215               /* Initialize the variable.  */
8216               initialize_local_var (decl, init, flags);
8217               /* Clean up the variable.  */
8218               destroy_local_var (decl);
8219             }
8220         }
8221       else if (TREE_STATIC (decl) && type != error_mark_node)
8222         {
8223           /* Cleanups for static variables are handled by `finish_file'.  */
8224           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8225               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8226             expand_static_init (decl, init);
8227         }
8228     finish_end0:
8229
8230       /* Undo call to `pushclass' that was done in `start_decl'
8231          due to initialization of qualified member variable.
8232          I.e., Foo::x = 10;  */
8233       {
8234         tree context = CP_DECL_CONTEXT (decl);
8235         if (context
8236             && TYPE_P (context)
8237             && (TREE_CODE (decl) == VAR_DECL
8238                 /* We also have a pushclass done that we need to undo here
8239                    if we're at top level and declare a method.  */
8240                 || TREE_CODE (decl) == FUNCTION_DECL)
8241             /* If size hasn't been set, we're still defining it,
8242                and therefore inside the class body; don't pop
8243                the binding level..  */
8244             && COMPLETE_TYPE_P (context)
8245             && context == current_class_type)
8246           pop_nested_class ();
8247       }
8248     }
8249
8250  finish_end:
8251
8252   if (was_readonly)
8253     TREE_READONLY (decl) = 1;
8254 }
8255
8256 /* This is here for a midend callback from c-common.c */
8257
8258 void
8259 finish_decl (decl, init, asmspec_tree)
8260      tree decl, init;
8261      tree asmspec_tree;
8262 {
8263   cp_finish_decl (decl, init, asmspec_tree, 0);
8264 }
8265
8266 /* Returns a declaration for a VAR_DECL as if:
8267
8268      extern "C" TYPE NAME;
8269
8270    had been seen.  Used to create compiler-generated global
8271    variables.  */
8272
8273 tree
8274 declare_global_var (name, type)
8275      tree name;
8276      tree type;
8277 {
8278   tree decl;
8279
8280   push_to_top_level ();
8281   decl = build_decl (VAR_DECL, name, type);
8282   TREE_PUBLIC (decl) = 1;
8283   DECL_EXTERNAL (decl) = 1;
8284   DECL_ARTIFICIAL (decl) = 1;
8285   pushdecl (decl);
8286   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8287   pop_from_top_level ();
8288
8289   return decl;
8290 }
8291
8292 /* Returns a pointer to the `atexit' function.  Note that if
8293    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8294    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8295
8296 static tree
8297 get_atexit_node ()
8298 {
8299   tree atexit_fndecl;
8300   tree arg_types;
8301   tree fn_type;
8302   tree fn_ptr_type;
8303   const char *name;
8304
8305   if (atexit_node)
8306     return atexit_node;
8307
8308   if (flag_use_cxa_atexit)
8309     {
8310       /* The declaration for `__cxa_atexit' is:
8311
8312            int __cxa_atexit (void (*)(void *), void *, void *)
8313
8314          We build up the argument types and then then function type
8315          itself.  */
8316
8317       /* First, build the pointer-to-function type for the first
8318          argument.  */
8319       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8320       fn_type = build_function_type (void_type_node, arg_types);
8321       fn_ptr_type = build_pointer_type (fn_type);
8322       /* Then, build the rest of the argument types.  */
8323       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8324       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8325       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8326       /* And the final __cxa_atexit type.  */
8327       fn_type = build_function_type (integer_type_node, arg_types);
8328       fn_ptr_type = build_pointer_type (fn_type);
8329       name = "__cxa_atexit";
8330     }
8331   else
8332     {
8333       /* The declaration for `atexit' is:
8334
8335            int atexit (void (*)());
8336
8337          We build up the argument types and then then function type
8338          itself.  */
8339       fn_type = build_function_type (void_type_node, void_list_node);
8340       fn_ptr_type = build_pointer_type (fn_type);
8341       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8342       /* Build the final atexit type.  */
8343       fn_type = build_function_type (integer_type_node, arg_types);
8344       name = "atexit";
8345     }
8346
8347   /* Now, build the function declaration.  */
8348   push_lang_context (lang_name_c);
8349   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8350   mark_used (atexit_fndecl);
8351   pop_lang_context ();
8352   atexit_node = default_conversion (atexit_fndecl);
8353
8354   return atexit_node;
8355 }
8356
8357 /* Returns the __dso_handle VAR_DECL.  */
8358
8359 static tree
8360 get_dso_handle_node ()
8361 {
8362   if (dso_handle_node)
8363     return dso_handle_node;
8364
8365   /* Declare the variable.  */
8366   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8367                                         ptr_type_node);
8368
8369   return dso_handle_node;
8370 }
8371
8372 /* Begin a new function with internal linkage whose job will be simply
8373    to destroy some particular variable.  */
8374
8375 static tree
8376 start_cleanup_fn ()
8377 {
8378   static int counter = 0;
8379   int old_interface_unknown = interface_unknown;
8380   char name[32];
8381   tree parmtypes;
8382   tree fntype;
8383   tree fndecl;
8384
8385   push_to_top_level ();
8386
8387   /* No need to mangle this.  */
8388   push_lang_context (lang_name_c);
8389
8390   interface_unknown = 1;
8391
8392   /* Build the parameter-types.  */
8393   parmtypes = void_list_node;
8394   /* Functions passed to __cxa_atexit take an additional parameter.
8395      We'll just ignore it.  After we implement the new calling
8396      convention for destructors, we can eliminate the use of
8397      additional cleanup functions entirely in the -fnew-abi case.  */
8398   if (flag_use_cxa_atexit)
8399     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8400   /* Build the function type itself.  */
8401   fntype = build_function_type (void_type_node, parmtypes);
8402   /* Build the name of the function.  */
8403   sprintf (name, "__tcf_%d", counter++);
8404   /* Build the function declaration.  */
8405   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8406   /* It's a function with internal linkage, generated by the
8407      compiler.  */
8408   TREE_PUBLIC (fndecl) = 0;
8409   DECL_ARTIFICIAL (fndecl) = 1;
8410   /* Make the function `inline' so that it is only emitted if it is
8411      actually needed.  It is unlikely that it will be inlined, since
8412      it is only called via a function pointer, but we avoid unncessary
8413      emissions this way.  */
8414   DECL_INLINE (fndecl) = 1;
8415   /* Build the parameter.  */
8416   if (flag_use_cxa_atexit)
8417     {
8418       tree parmdecl;
8419
8420       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8421       DECL_CONTEXT (parmdecl) = fndecl;
8422       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8423       TREE_USED (parmdecl) = 1;
8424       DECL_ARGUMENTS (fndecl) = parmdecl;
8425     }
8426
8427   pushdecl (fndecl);
8428   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8429   do_pushlevel ();
8430
8431   interface_unknown = old_interface_unknown;
8432
8433   pop_lang_context ();
8434
8435   return current_function_decl;
8436 }
8437
8438 /* Finish the cleanup function begun by start_cleanup_fn.  */
8439
8440 static void
8441 end_cleanup_fn ()
8442 {
8443   do_poplevel ();
8444
8445   expand_body (finish_function (0));
8446
8447   pop_from_top_level ();
8448 }
8449
8450 /* Generate code to handle the destruction of DECL, an object with
8451    static storage duration.  */
8452
8453 void
8454 register_dtor_fn (decl)
8455      tree decl;
8456 {
8457   tree cleanup;
8458   tree compound_stmt;
8459   tree args;
8460   tree fcall;
8461
8462   int saved_flag_access_control;
8463
8464   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8465     return;
8466
8467   /* Call build_cleanup before we enter the anonymous function so that
8468      any access checks will be done relative to the current scope,
8469      rather than the scope of the anonymous function.  */
8470   build_cleanup (decl);
8471
8472   /* Now start the function.  */
8473   cleanup = start_cleanup_fn ();
8474
8475   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8476      to the original function, rather than the anonymous one.  That
8477      will make the back-end think that nested functions are in use,
8478      which causes confusion.  */
8479   saved_flag_access_control = flag_access_control;
8480   flag_access_control = 0;
8481   fcall = build_cleanup (decl);
8482   flag_access_control = saved_flag_access_control;
8483
8484   /* Create the body of the anonymous function.  */
8485   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8486   finish_expr_stmt (fcall);
8487   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8488   end_cleanup_fn ();
8489
8490   /* Call atexit with the cleanup function.  */
8491   mark_addressable (cleanup);
8492   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8493   if (flag_use_cxa_atexit)
8494     {
8495       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8496       args = tree_cons (NULL_TREE, null_pointer_node, args);
8497       args = tree_cons (NULL_TREE, cleanup, args);
8498     }
8499   else
8500     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8501   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8502 }
8503
8504 void
8505 expand_static_init (decl, init)
8506      tree decl;
8507      tree init;
8508 {
8509   tree oldstatic = value_member (decl, static_aggregates);
8510
8511   if (oldstatic)
8512     {
8513       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8514         cp_error ("multiple initializations given for `%D'", decl);
8515     }
8516   else if (! toplevel_bindings_p ())
8517     {
8518       /* Emit code to perform this initialization but once.  */
8519       tree if_stmt;
8520       tree then_clause;
8521       tree assignment;
8522       tree guard;
8523       tree guard_init;
8524
8525       /* Emit code to perform this initialization but once.  This code
8526          looks like:
8527
8528            static int guard = 0;
8529            if (!guard) {
8530              // Do initialization.
8531              guard = 1;
8532              // Register variable for destruction at end of program.
8533            }
8534
8535          Note that the `temp' variable is only set to 1 *after* the
8536          initialization is complete.  This ensures that an exception,
8537          thrown during the construction, will cause the variable to
8538          reinitialized when we pass through this code again, as per:
8539
8540            [stmt.dcl]
8541
8542            If the initialization exits by throwing an exception, the
8543            initialization is not complete, so it will be tried again
8544            the next time control enters the declaration.
8545
8546          In theory, this process should be thread-safe, too; multiple
8547          threads should not be able to initialize the variable more
8548          than once.  We don't yet attempt to ensure thread-safety.  */
8549
8550       /* Create the guard variable.  */
8551       guard = get_guard (decl);
8552
8553       /* Begin the conditional initialization.  */
8554       if_stmt = begin_if_stmt ();
8555       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8556       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8557
8558       /* Do the initialization itself.  */
8559       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8560           || (init && TREE_CODE (init) == TREE_LIST))
8561         assignment = build_aggr_init (decl, init, 0);
8562       else if (init)
8563         /* The initialization we're doing here is just a bitwise
8564            copy.  */
8565         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8566       else
8567         assignment = NULL_TREE;
8568
8569       /* Once the assignment is complete, set TEMP to 1.  Since the
8570          construction of the static object is complete at this point,
8571          we want to make sure TEMP is set to 1 even if a temporary
8572          constructed during the initialization throws an exception
8573          when it is destroyed.  So, we combine the initialization and
8574          the assignment to TEMP into a single expression, ensuring
8575          that when we call finish_expr_stmt the cleanups will not be
8576          run until after TEMP is set to 1.  */
8577       guard_init = set_guard (guard);
8578       if (assignment)
8579         {
8580           assignment = tree_cons (NULL_TREE, assignment,
8581                                   build_tree_list (NULL_TREE,
8582                                                    guard_init));
8583           assignment = build_compound_expr (assignment);
8584         }
8585       else
8586         assignment = guard_init;
8587       finish_expr_stmt (assignment);
8588
8589       /* Use atexit to register a function for destroying this static
8590          variable.  */
8591       register_dtor_fn (decl);
8592
8593       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8594       finish_then_clause (if_stmt);
8595       finish_if_stmt ();
8596     }
8597   else
8598     static_aggregates = tree_cons (init, decl, static_aggregates);
8599 }
8600
8601 /* Finish the declaration of a catch-parameter.  */
8602
8603 tree
8604 start_handler_parms (declspecs, declarator)
8605      tree declspecs;
8606      tree declarator;
8607 {
8608   tree decl;
8609   if (declspecs)
8610     {
8611       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8612                              1, NULL_TREE);
8613       if (decl == NULL_TREE)
8614         error ("invalid catch parameter");
8615     }
8616   else
8617     decl = NULL_TREE;
8618
8619   return decl;
8620 }
8621
8622 \f
8623 /* Make TYPE a complete type based on INITIAL_VALUE.
8624    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8625    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8626
8627 int
8628 complete_array_type (type, initial_value, do_default)
8629      tree type, initial_value;
8630      int do_default;
8631 {
8632   register tree maxindex = NULL_TREE;
8633   int value = 0;
8634
8635   if (initial_value)
8636     {
8637       /* An array of character type can be initialized from a
8638          brace-enclosed string constant.  */
8639       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8640           && TREE_CODE (initial_value) == CONSTRUCTOR
8641           && CONSTRUCTOR_ELTS (initial_value)
8642           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8643               == STRING_CST)
8644           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8645         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8646
8647       /* Note MAXINDEX is really the maximum index, one less than the
8648          size.  */
8649       if (TREE_CODE (initial_value) == STRING_CST)
8650         {
8651           int eltsize
8652             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8653           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8654                                    / eltsize) - 1, 0);
8655         }
8656       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8657         {
8658           tree elts = CONSTRUCTOR_ELTS (initial_value);
8659
8660           maxindex = ssize_int (-1);
8661           for (; elts; elts = TREE_CHAIN (elts))
8662             {
8663               if (TREE_PURPOSE (elts))
8664                 maxindex = TREE_PURPOSE (elts);
8665               else
8666                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8667             }
8668           maxindex = copy_node (maxindex);
8669         }
8670       else
8671         {
8672           /* Make an error message unless that happened already.  */
8673           if (initial_value != error_mark_node)
8674             value = 1;
8675           else
8676             initial_value = NULL_TREE;
8677
8678           /* Prevent further error messages.  */
8679           maxindex = build_int_2 (0, 0);
8680         }
8681     }
8682
8683   if (!maxindex)
8684     {
8685       if (do_default)
8686         maxindex = build_int_2 (0, 0);
8687       value = 2;
8688     }
8689
8690   if (maxindex)
8691     {
8692       tree itype;
8693       tree domain;
8694
8695       domain = build_index_type (maxindex);
8696       TYPE_DOMAIN (type) = domain;
8697
8698       if (! TREE_TYPE (maxindex))
8699         TREE_TYPE (maxindex) = domain;
8700       if (initial_value)
8701         itype = TREE_TYPE (initial_value);
8702       else
8703         itype = NULL;
8704       if (itype && !TYPE_DOMAIN (itype))
8705         TYPE_DOMAIN (itype) = domain;
8706       /* The type of the main variant should never be used for arrays
8707          of different sizes.  It should only ever be completed with the
8708          size of the array.  */
8709       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8710         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8711     }
8712
8713   /* Lay out the type now that we can get the real answer.  */
8714
8715   layout_type (type);
8716
8717   return value;
8718 }
8719 \f
8720 /* Return zero if something is declared to be a member of type
8721    CTYPE when in the context of CUR_TYPE.  STRING is the error
8722    message to print in that case.  Otherwise, quietly return 1.  */
8723
8724 static int
8725 member_function_or_else (ctype, cur_type, flags)
8726      tree ctype, cur_type;
8727      enum overload_flags flags;
8728 {
8729   if (ctype && ctype != cur_type)
8730     {
8731       if (flags == DTOR_FLAG)
8732         cp_error ("destructor for alien class `%T' cannot be a member",
8733                   ctype);
8734       else
8735         cp_error ("constructor for alien class `%T' cannot be a member",
8736                   ctype);
8737       return 0;
8738     }
8739   return 1;
8740 }
8741 \f
8742 /* Subroutine of `grokdeclarator'.  */
8743
8744 /* Generate errors possibly applicable for a given set of specifiers.
8745    This is for ARM $7.1.2.  */
8746
8747 static void
8748 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8749      tree object;
8750      const char *type;
8751      int virtualp, quals, friendp, raises, inlinep;
8752 {
8753   if (virtualp)
8754     cp_error ("`%D' declared as a `virtual' %s", object, type);
8755   if (inlinep)
8756     cp_error ("`%D' declared as an `inline' %s", object, type);
8757   if (quals)
8758     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8759               object, type);
8760   if (friendp)
8761     cp_error_at ("`%D' declared as a friend", object);
8762   if (raises)
8763     cp_error_at ("`%D' declared with an exception specification", object);
8764 }
8765
8766 /* CTYPE is class type, or null if non-class.
8767    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8768    or METHOD_TYPE.
8769    DECLARATOR is the function's name.
8770    VIRTUALP is truthvalue of whether the function is virtual or not.
8771    FLAGS are to be passed through to `grokclassfn'.
8772    QUALS are qualifiers indicating whether the function is `const'
8773    or `volatile'.
8774    RAISES is a list of exceptions that this function can raise.
8775    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8776    not look, and -1 if we should not call `grokclassfn' at all.
8777
8778    Returns `NULL_TREE' if something goes wrong, after issuing
8779    applicable error messages.  */
8780
8781 static tree
8782 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8783             raises, check, friendp, publicp, inlinep, funcdef_flag,
8784             template_count, in_namespace)
8785      tree ctype, type;
8786      tree declarator;
8787      tree orig_declarator;
8788      int virtualp;
8789      enum overload_flags flags;
8790      tree quals, raises;
8791      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8792      tree in_namespace;
8793 {
8794   tree cname, decl;
8795   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8796   int has_default_arg = 0;
8797   tree t;
8798
8799   if (ctype)
8800     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8801       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8802   else
8803     cname = NULL_TREE;
8804
8805   if (raises)
8806     {
8807       type = build_exception_variant (type, raises);
8808     }
8809
8810   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8811   /* Propagate volatile out from type to decl. */
8812   if (TYPE_VOLATILE (type))
8813     TREE_THIS_VOLATILE (decl) = 1;
8814
8815   /* If this decl has namespace scope, set that up.  */
8816   if (in_namespace)
8817     set_decl_namespace (decl, in_namespace, friendp);
8818   else if (!ctype)
8819     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8820
8821   /* `main' and builtins have implicit 'C' linkage.  */
8822   if ((MAIN_NAME_P (declarator)
8823        || (IDENTIFIER_LENGTH (declarator) > 10
8824            && IDENTIFIER_POINTER (declarator)[0] == '_'
8825            && IDENTIFIER_POINTER (declarator)[1] == '_'
8826            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8827       && current_lang_name == lang_name_cplusplus
8828       && ctype == NULL_TREE
8829       /* NULL_TREE means global namespace.  */
8830       && DECL_CONTEXT (decl) == NULL_TREE)
8831     DECL_LANGUAGE (decl) = lang_c;
8832
8833   /* Should probably propagate const out from type to decl I bet (mrs).  */
8834   if (staticp)
8835     {
8836       DECL_STATIC_FUNCTION_P (decl) = 1;
8837       DECL_CONTEXT (decl) = ctype;
8838     }
8839
8840   if (ctype)
8841     DECL_CONTEXT (decl) = ctype;
8842
8843   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8844     {
8845       if (processing_template_decl)
8846         error ("cannot declare `::main' to be a template");
8847       if (inlinep)
8848         error ("cannot declare `::main' to be inline");
8849       if (!publicp)
8850         error ("cannot declare `::main' to be static");
8851       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8852                         integer_type_node))
8853         error ("`main' must return `int'");
8854       inlinep = 0;
8855       publicp = 1;
8856     }
8857
8858   /* Members of anonymous types and local classes have no linkage; make
8859      them internal.  */
8860   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8861                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8862     publicp = 0;
8863
8864   if (publicp)
8865     {
8866       /* [basic.link]: A name with no linkage (notably, the name of a class
8867          or enumeration declared in a local scope) shall not be used to
8868          declare an entity with linkage.
8869
8870          Only check this for public decls for now.  */
8871       t = no_linkage_check (TREE_TYPE (decl));
8872       if (t)
8873         {
8874           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8875             {
8876               if (DECL_EXTERN_C_P (decl))
8877                 /* Allow this; it's pretty common in C.  */;
8878               else
8879                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8880                             decl);
8881             }
8882           else
8883             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8884                         decl, t);
8885         }
8886     }
8887
8888   TREE_PUBLIC (decl) = publicp;
8889   if (! publicp)
8890     {
8891       DECL_INTERFACE_KNOWN (decl) = 1;
8892       DECL_NOT_REALLY_EXTERN (decl) = 1;
8893     }
8894
8895   if (inlinep)
8896     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8897
8898   DECL_EXTERNAL (decl) = 1;
8899   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8900     {
8901       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8902                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8903       quals = NULL_TREE;
8904     }
8905
8906   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8907     grok_op_properties (decl, virtualp, check < 0);
8908
8909   if (ctype && decl_function_context (decl))
8910     DECL_NO_STATIC_CHAIN (decl) = 1;
8911
8912   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8913     if (TREE_PURPOSE (t)
8914         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8915       {
8916         has_default_arg = 1;
8917         break;
8918       }
8919
8920   if (friendp
8921       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8922     {
8923       if (funcdef_flag)
8924         cp_error
8925           ("defining explicit specialization `%D' in friend declaration",
8926            orig_declarator);
8927       else
8928         {
8929           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8930             {
8931               /* Something like `template <class T> friend void f<T>()'.  */
8932               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8933                         orig_declarator);
8934               return NULL_TREE;
8935             }
8936
8937
8938           /* A friend declaration of the form friend void f<>().  Record
8939              the information in the TEMPLATE_ID_EXPR.  */
8940           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8941           DECL_TEMPLATE_INFO (decl)
8942             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8943                          TREE_OPERAND (orig_declarator, 1),
8944                          NULL_TREE);
8945
8946           if (has_default_arg)
8947             {
8948               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8949                         decl);
8950               return NULL_TREE;
8951             }
8952
8953           if (inlinep)
8954             {
8955               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8956                         decl);
8957               return NULL_TREE;
8958             }
8959         }
8960     }
8961
8962   if (has_default_arg)
8963     add_defarg_fn (decl);
8964
8965   /* Plain overloading: will not be grok'd by grokclassfn.  */
8966   if (! ctype && ! processing_template_decl
8967       && !DECL_EXTERN_C_P (decl)
8968       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8969     set_mangled_name_for_decl (decl);
8970
8971   if (funcdef_flag)
8972     /* Make the init_value nonzero so pushdecl knows this is not
8973        tentative.  error_mark_node is replaced later with the BLOCK.  */
8974     DECL_INITIAL (decl) = error_mark_node;
8975
8976   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8977     TREE_NOTHROW (decl) = 1;
8978
8979   /* Caller will do the rest of this.  */
8980   if (check < 0)
8981     return decl;
8982
8983   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8984     DECL_CONSTRUCTOR_P (decl) = 1;
8985
8986   /* Function gets the ugly name, field gets the nice one.  This call
8987      may change the type of the function (because of default
8988      parameters)!  */
8989   if (ctype != NULL_TREE)
8990     grokclassfn (ctype, decl, flags, quals);
8991
8992   decl = check_explicit_specialization (orig_declarator, decl,
8993                                         template_count,
8994                                         2 * (funcdef_flag != 0) +
8995                                         4 * (friendp != 0));
8996   if (decl == error_mark_node)
8997     return NULL_TREE;
8998
8999   if (ctype != NULL_TREE
9000       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9001       && check)
9002     {
9003       tree old_decl;
9004
9005       old_decl = check_classfn (ctype, decl);
9006
9007       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9008         /* Because grokfndecl is always supposed to return a
9009            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9010            here.  We depend on our callers to figure out that its
9011            really a template that's being returned.  */
9012         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9013
9014       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9015           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9016         {
9017           /* Remove the `this' parm added by grokclassfn.
9018              XXX Isn't this done in start_function, too?  */
9019           revert_static_member_fn (decl);
9020           last_function_parms = TREE_CHAIN (last_function_parms);
9021         }
9022       if (old_decl && DECL_ARTIFICIAL (old_decl))
9023         cp_error ("definition of implicitly-declared `%D'", old_decl);
9024
9025       if (old_decl)
9026         {
9027           /* Since we've smashed OLD_DECL to its
9028              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9029           if (TREE_CODE (decl) == TEMPLATE_DECL)
9030             decl = DECL_TEMPLATE_RESULT (decl);
9031
9032           /* Attempt to merge the declarations.  This can fail, in
9033              the case of some illegal specialization declarations.  */
9034           if (!duplicate_decls (decl, old_decl))
9035             cp_error ("no `%#D' member function declared in class `%T'",
9036                       decl, ctype);
9037           return old_decl;
9038         }
9039     }
9040
9041   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9042     return NULL_TREE;
9043
9044   if (ctype == NULL_TREE || check)
9045     return decl;
9046
9047   if (virtualp)
9048     {
9049       DECL_VIRTUAL_P (decl) = 1;
9050       if (DECL_VINDEX (decl) == NULL_TREE)
9051         DECL_VINDEX (decl) = error_mark_node;
9052       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9053     }
9054
9055   return decl;
9056 }
9057
9058 static tree
9059 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9060      tree type;
9061      tree declarator;
9062      RID_BIT_TYPE *specbits_in;
9063      int initialized;
9064      int constp;
9065      tree in_namespace;
9066 {
9067   tree decl;
9068   RID_BIT_TYPE specbits;
9069
9070   specbits = *specbits_in;
9071
9072   if (TREE_CODE (type) == OFFSET_TYPE)
9073     {
9074       /* If you declare a static member so that it
9075          can be initialized, the code will reach here.  */
9076       tree basetype = TYPE_OFFSET_BASETYPE (type);
9077       type = TREE_TYPE (type);
9078       decl = build_lang_decl (VAR_DECL, declarator, type);
9079       DECL_CONTEXT (decl) = basetype;
9080       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9081          templates.  */
9082       if (!uses_template_parms (decl))
9083         {
9084           if (flag_new_abi)
9085             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9086           else
9087             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9088                                                             declarator);
9089         }
9090     }
9091   else
9092     {
9093       tree context;
9094
9095       if (in_namespace)
9096         context = in_namespace;
9097       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9098         context = current_namespace;
9099       else
9100         context = NULL_TREE;
9101
9102       if (processing_template_decl && context)
9103         /* For global variables, declared in a template, we need the
9104            full lang_decl.  */
9105         decl = build_lang_decl (VAR_DECL, declarator, type);
9106       else
9107         decl = build_decl (VAR_DECL, declarator, type);
9108
9109       if (context)
9110         set_decl_namespace (decl, context, 0);
9111
9112       context = DECL_CONTEXT (decl);
9113       if (declarator && context && current_lang_name != lang_name_c)
9114         {
9115           if (flag_new_abi)
9116             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9117           else
9118             DECL_ASSEMBLER_NAME (decl)
9119               = build_static_name (context, declarator);
9120         }
9121     }
9122
9123   if (in_namespace)
9124     set_decl_namespace (decl, in_namespace, 0);
9125
9126   if (RIDBIT_SETP (RID_EXTERN, specbits))
9127     {
9128       DECL_THIS_EXTERN (decl) = 1;
9129       DECL_EXTERNAL (decl) = !initialized;
9130     }
9131
9132   /* In class context, static means one per class,
9133      public access, and static storage.  */
9134   if (DECL_CLASS_SCOPE_P (decl))
9135     {
9136       TREE_PUBLIC (decl) = 1;
9137       TREE_STATIC (decl) = 1;
9138       DECL_EXTERNAL (decl) = 0;
9139     }
9140   /* At top level, either `static' or no s.c. makes a definition
9141      (perhaps tentative), and absence of `static' makes it public.  */
9142   else if (toplevel_bindings_p ())
9143     {
9144       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9145                             && (DECL_THIS_EXTERN (decl) || ! constp));
9146       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9147     }
9148   /* Not at top level, only `static' makes a static definition.  */
9149   else
9150     {
9151       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9152       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9153     }
9154
9155   if (TREE_PUBLIC (decl))
9156     {
9157       /* [basic.link]: A name with no linkage (notably, the name of a class
9158          or enumeration declared in a local scope) shall not be used to
9159          declare an entity with linkage.
9160
9161          Only check this for public decls for now.  */
9162       tree t = no_linkage_check (TREE_TYPE (decl));
9163       if (t)
9164         {
9165           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9166             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9167           else
9168             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9169                         decl, t);
9170         }
9171     }
9172
9173   return decl;
9174 }
9175
9176 /* Create and return a canonical pointer to member function type, for
9177    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9178
9179 tree
9180 build_ptrmemfunc_type (type)
9181      tree type;
9182 {
9183   tree fields[4];
9184   tree t;
9185   tree u;
9186   tree unqualified_variant = NULL_TREE;
9187
9188   /* If a canonical type already exists for this type, use it.  We use
9189      this method instead of type_hash_canon, because it only does a
9190      simple equality check on the list of field members.  */
9191
9192   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9193     return t;
9194
9195   /* Make sure that we always have the unqualified pointer-to-member
9196      type first.  */
9197   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9198     unqualified_variant
9199       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9200
9201   t = make_aggr_type (RECORD_TYPE);
9202   /* Let the front-end know this is a pointer to member function...  */
9203   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9204   /* ... and not really an aggregate.  */
9205   SET_IS_AGGR_TYPE (t, 0);
9206
9207   if (!flag_new_abi)
9208     {
9209       u = make_aggr_type (UNION_TYPE);
9210       SET_IS_AGGR_TYPE (u, 0);
9211       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9212       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9213                               delta_type_node);
9214       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9215       TYPE_NAME (u) = NULL_TREE;
9216
9217       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9218                               delta_type_node);
9219       fields[1] = build_decl (FIELD_DECL, index_identifier,
9220                               delta_type_node);
9221       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9222       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9223     }
9224   else
9225     {
9226       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9227       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9228                               delta_type_node);
9229       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9230     }
9231
9232   /* Zap out the name so that the back-end will give us the debugging
9233      information for this anonymous RECORD_TYPE.  */
9234   TYPE_NAME (t) = NULL_TREE;
9235
9236   /* If this is not the unqualified form of this pointer-to-member
9237      type, set the TYPE_MAIN_VARIANT for this type to be the
9238      unqualified type.  Since they are actually RECORD_TYPEs that are
9239      not variants of each other, we must do this manually.  */
9240   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9241     {
9242       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9243       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9244       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9245       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9246     }
9247
9248   /* Cache this pointer-to-member type so that we can find it again
9249      later.  */
9250   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9251
9252   /* Seems to be wanted.  */
9253   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9254
9255   return t;
9256 }
9257
9258 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9259    Check to see that the definition is valid.  Issue appropriate error
9260    messages.  Return 1 if the definition is particularly bad, or 0
9261    otherwise.  */
9262
9263 int
9264 check_static_variable_definition (decl, type)
9265      tree decl;
9266      tree type;
9267 {
9268   /* Motion 10 at San Diego: If a static const integral data member is
9269      initialized with an integral constant expression, the initializer
9270      may appear either in the declaration (within the class), or in
9271      the definition, but not both.  If it appears in the class, the
9272      member is a member constant.  The file-scope definition is always
9273      required.  */
9274   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9275     {
9276       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9277                 type);
9278       /* If we just return the declaration, crashes will sometimes
9279          occur.  We therefore return void_type_node, as if this was a
9280          friend declaration, to cause callers to completely ignore
9281          this declaration.  */
9282       return 1;
9283     }
9284   else if (!CP_TYPE_CONST_P (type))
9285     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9286               decl);
9287   else if (pedantic && !INTEGRAL_TYPE_P (type))
9288     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9289
9290   return 0;
9291 }
9292
9293 /* Given the SIZE (i.e., number of elements) in an array, compute an
9294    appropriate index type for the array.  If non-NULL, NAME is the
9295    name of the thing being declared.  */
9296
9297 tree
9298 compute_array_index_type (name, size)
9299      tree name;
9300      tree size;
9301 {
9302   tree itype;
9303
9304   /* The size might be the result of a cast. */
9305   STRIP_TYPE_NOPS (size);
9306
9307   /* It might be a const variable or enumeration constant.  */
9308   size = decl_constant_value (size);
9309
9310   /* If this involves a template parameter, it will be a constant at
9311      instantiation time, but we don't know what the value is yet.
9312      Even if no template parameters are involved, we may an expression
9313      that is not a constant; we don't even simplify `1 + 2' when
9314      processing a template.  */
9315   if (processing_template_decl)
9316     {
9317       /* Resolve a qualified reference to an enumerator or static
9318          const data member of ours.  */
9319       if (TREE_CODE (size) == SCOPE_REF
9320           && TREE_OPERAND (size, 0) == current_class_type)
9321         {
9322           tree t = lookup_field (current_class_type,
9323                                  TREE_OPERAND (size, 1), 0, 0);
9324           if (t)
9325             size = t;
9326         }
9327
9328       return build_index_type (build_min (MINUS_EXPR, sizetype,
9329                                           size, integer_one_node));
9330     }
9331
9332   /* The array bound must be an integer type.  */
9333   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9334       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9335       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9336     {
9337       if (name)
9338         cp_error ("size of array `%D' has non-integer type", name);
9339       else
9340         cp_error ("size of array has non-integer type");
9341       size = integer_one_node;
9342     }
9343
9344   /* Normally, the array-bound will be a constant.  */
9345   if (TREE_CODE (size) == INTEGER_CST)
9346     {
9347       /* Check to see if the array bound overflowed.  Make that an
9348          error, no matter how generous we're being.  */
9349       int old_flag_pedantic_errors = flag_pedantic_errors;
9350       int old_pedantic = pedantic;
9351       pedantic = flag_pedantic_errors = 1;
9352       constant_expression_warning (size);
9353       pedantic = old_pedantic;
9354       flag_pedantic_errors = old_flag_pedantic_errors;
9355
9356       /* An array must have a positive number of elements.  */
9357       if (INT_CST_LT (size, integer_zero_node))
9358         {
9359           if (name)
9360             cp_error ("size of array `%D' is negative", name);
9361           else
9362             cp_error ("size of array is negative");
9363           size = integer_one_node;
9364         }
9365       /* Except that an extension we allow zero-sized arrays.  We
9366          always allow them in system headers because glibc uses
9367          them.  */
9368       else if (integer_zerop (size) && pedantic && !in_system_header)
9369         {
9370           if (name)
9371             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9372           else
9373             cp_pedwarn ("ISO C++ forbids zero-size array");
9374         }
9375     }
9376   else if (TREE_CONSTANT (size))
9377     {
9378       /* `(int) &fn' is not a valid array bound.  */
9379       if (name)
9380         cp_error ("size of array `%D' is not an integral constant-expression",
9381                   name);
9382       else
9383         cp_error ("size of array is not an integral constant-expression");
9384     }
9385
9386   /* Compute the index of the largest element in the array.  It is
9387      one less than the number of elements in the array.  */
9388   itype
9389     = fold (cp_build_binary_op (MINUS_EXPR,
9390                                 cp_convert (ssizetype, size),
9391                                 cp_convert (ssizetype,
9392                                             integer_one_node)));
9393
9394   /* Check for variable-sized arrays.  We allow such things as an
9395      extension, even though they are not allowed in ANSI/ISO C++.  */
9396   if (!TREE_CONSTANT (itype))
9397     {
9398       if (pedantic)
9399         {
9400           if (name)
9401             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9402                         name);
9403           else
9404             cp_pedwarn ("ISO C++ forbids variable-size array");
9405         }
9406
9407       /* Create a variable-sized array index type.  */
9408       itype = variable_size (itype);
9409     }
9410   /* Make sure that there was no overflow when creating to a signed
9411      index type.  (For example, on a 32-bit machine, an array with
9412      size 2^32 - 1 is too big.)  */
9413   else if (TREE_OVERFLOW (itype))
9414     {
9415       error ("overflow in array dimension");
9416       TREE_OVERFLOW (itype) = 0;
9417     }
9418
9419   /* Create and return the appropriate index type.  */
9420   return build_index_type (itype);
9421 }
9422
9423 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9424    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9425    with this type.  */
9426
9427 static tree
9428 create_array_type_for_decl (name, type, size)
9429      tree name;
9430      tree type;
9431      tree size;
9432 {
9433   tree itype = NULL_TREE;
9434   const char* error_msg;
9435
9436   /* If things have already gone awry, bail now.  */
9437   if (type == error_mark_node || size == error_mark_node)
9438     return error_mark_node;
9439
9440   /* Assume that everything will go OK.  */
9441   error_msg = NULL;
9442
9443   /* There are some types which cannot be array elements.  */
9444   switch (TREE_CODE (type))
9445     {
9446     case VOID_TYPE:
9447       error_msg = "array of void";
9448       break;
9449
9450     case FUNCTION_TYPE:
9451       error_msg = "array of functions";
9452       break;
9453
9454     case REFERENCE_TYPE:
9455       error_msg = "array of references";
9456       break;
9457
9458     case OFFSET_TYPE:
9459       error_msg = "array of data members";
9460       break;
9461
9462     case METHOD_TYPE:
9463       error_msg = "array of function members";
9464       break;
9465
9466     default:
9467       break;
9468     }
9469
9470   /* If something went wrong, issue an error-message and return.  */
9471   if (error_msg)
9472     {
9473       if (name)
9474         cp_error ("declaration of `%D' as %s", name, error_msg);
9475       else
9476         cp_error ("creating %s", error_msg);
9477
9478       return error_mark_node;
9479     }
9480
9481   /* [dcl.array]
9482
9483      The constant expressions that specify the bounds of the arrays
9484      can be omitted only for the first member of the sequence.  */
9485   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9486     {
9487       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9488                 name);
9489
9490       return error_mark_node;
9491     }
9492
9493   /* Figure out the index type for the array.  */
9494   if (size)
9495     itype = compute_array_index_type (name, size);
9496
9497   return build_cplus_array_type (type, itype);
9498 }
9499
9500 /* Check that it's OK to declare a function with the indicated TYPE.
9501    SFK indicates the kind of special function (if any) that this
9502    function is.  CTYPE is the class of which this function is a
9503    member.  OPTYPE is the type given in a conversion operator
9504    declaration.  Returns the actual return type of the function; that
9505    may be different than TYPE if an error occurs, or for certain
9506    special functions.  */
9507
9508 static tree
9509 check_special_function_return_type (sfk, type, ctype, optype)
9510      special_function_kind sfk;
9511      tree type;
9512      tree ctype;
9513      tree optype;
9514 {
9515   switch (sfk)
9516     {
9517     case sfk_constructor:
9518       if (type)
9519         cp_error ("return type specification for constructor invalid");
9520
9521       /* In the old ABI, we return `this'; in the new ABI we don't
9522          bother.  */
9523       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9524       break;
9525
9526     case sfk_destructor:
9527       if (type)
9528         cp_error ("return type specification for destructor invalid");
9529       type = void_type_node;
9530       break;
9531
9532     case sfk_conversion:
9533       if (type && !same_type_p (type, optype))
9534         cp_error ("operator `%T' declared to return `%T'", optype, type);
9535       else if (type)
9536         cp_pedwarn ("return type specified for `operator %T'",  optype);
9537       type = optype;
9538       break;
9539
9540     default:
9541       my_friendly_abort (20000408);
9542       break;
9543     }
9544
9545   return type;
9546 }
9547
9548 /* Given declspecs and a declarator,
9549    determine the name and type of the object declared
9550    and construct a ..._DECL node for it.
9551    (In one case we can return a ..._TYPE node instead.
9552     For invalid input we sometimes return 0.)
9553
9554    DECLSPECS is a chain of tree_list nodes whose value fields
9555     are the storage classes and type specifiers.
9556
9557    DECL_CONTEXT says which syntactic context this declaration is in:
9558      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9559      FUNCDEF for a function definition.  Like NORMAL but a few different
9560       error messages in each case.  Return value may be zero meaning
9561       this definition is too screwy to try to parse.
9562      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9563       handle member functions (which have FIELD context).
9564       Return value may be zero meaning this definition is too screwy to
9565       try to parse.
9566      PARM for a parameter declaration (either within a function prototype
9567       or before a function body).  Make a PARM_DECL, or return void_type_node.
9568      CATCHPARM for a parameter declaration before a catch clause.
9569      TYPENAME if for a typename (in a cast or sizeof).
9570       Don't make a DECL node; just return the ..._TYPE node.
9571      FIELD for a struct or union field; make a FIELD_DECL.
9572      BITFIELD for a field with specified width.
9573    INITIALIZED is 1 if the decl has an initializer.
9574
9575    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9576    normal attributes in TREE_PURPOSE, or NULL_TREE.
9577
9578    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9579    It may also be so in the PARM case, for a prototype where the
9580    argument type is specified but not the name.
9581
9582    This function is where the complicated C meanings of `static'
9583    and `extern' are interpreted.
9584
9585    For C++, if there is any monkey business to do, the function which
9586    calls this one must do it, i.e., prepending instance variables,
9587    renaming overloaded function names, etc.
9588
9589    Note that for this C++, it is an error to define a method within a class
9590    which does not belong to that class.
9591
9592    Except in the case where SCOPE_REFs are implicitly known (such as
9593    methods within a class being redundantly qualified),
9594    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9595    (class_name::decl_name).  The caller must also deal with this.
9596
9597    If a constructor or destructor is seen, and the context is FIELD,
9598    then the type gains the attribute TREE_HAS_x.  If such a declaration
9599    is erroneous, NULL_TREE is returned.
9600
9601    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9602    function, these are the qualifiers to give to the `this' pointer. We
9603    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9604
9605    May return void_type_node if the declarator turned out to be a friend.
9606    See grokfield for details.  */
9607
9608 tree
9609 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9610      tree declspecs;
9611      tree declarator;
9612      enum decl_context decl_context;
9613      int initialized;
9614      tree attrlist;
9615 {
9616   RID_BIT_TYPE specbits;
9617   int nclasses = 0;
9618   tree spec;
9619   tree type = NULL_TREE;
9620   int longlong = 0;
9621   int constp;
9622   int restrictp;
9623   int volatilep;
9624   int type_quals;
9625   int virtualp, explicitp, friendp, inlinep, staticp;
9626   int explicit_int = 0;
9627   int explicit_char = 0;
9628   int defaulted_int = 0;
9629   tree typedef_decl = NULL_TREE;
9630   const char *name;
9631   tree typedef_type = NULL_TREE;
9632   int funcdef_flag = 0;
9633   enum tree_code innermost_code = ERROR_MARK;
9634   int bitfield = 0;
9635 #if 0
9636   /* See the code below that used this.  */
9637   tree decl_machine_attr = NULL_TREE;
9638 #endif
9639   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9640      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9641   tree init = NULL_TREE;
9642
9643   /* Keep track of what sort of function is being processed
9644      so that we can warn about default return values, or explicit
9645      return values which do not match prescribed defaults.  */
9646   special_function_kind sfk = sfk_none;
9647
9648   tree dname = NULL_TREE;
9649   tree ctype = current_class_type;
9650   tree ctor_return_type = NULL_TREE;
9651   enum overload_flags flags = NO_SPECIAL;
9652   tree quals = NULL_TREE;
9653   tree raises = NULL_TREE;
9654   int template_count = 0;
9655   tree in_namespace = NULL_TREE;
9656   tree inner_attrs;
9657   int ignore_attrs;
9658
9659   RIDBIT_RESET_ALL (specbits);
9660   if (decl_context == FUNCDEF)
9661     funcdef_flag = 1, decl_context = NORMAL;
9662   else if (decl_context == MEMFUNCDEF)
9663     funcdef_flag = -1, decl_context = FIELD;
9664   else if (decl_context == BITFIELD)
9665     bitfield = 1, decl_context = FIELD;
9666
9667   /* Look inside a declarator for the name being declared
9668      and get it as a string, for an error message.  */
9669   {
9670     tree *next = &declarator;
9671     register tree decl;
9672     name = NULL;
9673
9674     while (next && *next)
9675       {
9676         decl = *next;
9677         switch (TREE_CODE (decl))
9678           {
9679           case TREE_LIST:
9680             /* For attributes.  */
9681             next = &TREE_VALUE (decl);
9682             break;
9683
9684           case COND_EXPR:
9685             ctype = NULL_TREE;
9686             next = &TREE_OPERAND (decl, 0);
9687             break;
9688
9689           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9690             {
9691               tree name = TREE_OPERAND (decl, 0);
9692               tree rename = NULL_TREE;
9693
9694               my_friendly_assert (flags == NO_SPECIAL, 152);
9695               flags = DTOR_FLAG;
9696               sfk = sfk_destructor;
9697               if (TREE_CODE (name) == TYPE_DECL)
9698                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9699               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9700               if (ctype == NULL_TREE)
9701                 {
9702                   if (current_class_type == NULL_TREE)
9703                     {
9704                       error ("destructors must be member functions");
9705                       flags = NO_SPECIAL;
9706                     }
9707                   else
9708                     {
9709                       tree t = constructor_name (current_class_name);
9710                       if (t != name)
9711                         rename = t;
9712                     }
9713                 }
9714               else
9715                 {
9716                   tree t = constructor_name (ctype);
9717                   if (t != name)
9718                     rename = t;
9719                 }
9720
9721               if (rename)
9722                 {
9723                   cp_error ("destructor `%T' must match class name `%T'",
9724                             name, rename);
9725                   TREE_OPERAND (decl, 0) = rename;
9726                 }
9727               next = &name;
9728             }
9729             break;
9730
9731           case ADDR_EXPR:       /* C++ reference declaration */
9732             /* Fall through. */
9733           case ARRAY_REF:
9734           case INDIRECT_REF:
9735             ctype = NULL_TREE;
9736             innermost_code = TREE_CODE (decl);
9737             next = &TREE_OPERAND (decl, 0);
9738             break;
9739
9740           case CALL_EXPR:
9741             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9742               {
9743                 /* This is actually a variable declaration using
9744                    constructor syntax.  We need to call start_decl and
9745                    cp_finish_decl so we can get the variable
9746                    initialized...  */
9747
9748                 tree attributes, prefix_attributes;
9749
9750                 *next = TREE_OPERAND (decl, 0);
9751                 init = CALL_DECLARATOR_PARMS (decl);
9752
9753                 if (attrlist)
9754                   {
9755                     attributes = TREE_PURPOSE (attrlist);
9756                     prefix_attributes = TREE_VALUE (attrlist);
9757                   }
9758                 else
9759                   {
9760                     attributes = NULL_TREE;
9761                     prefix_attributes = NULL_TREE;
9762                   }
9763
9764                 decl = start_decl (declarator, declspecs, 1,
9765                                    attributes, prefix_attributes);
9766                 decl_type_access_control (decl);
9767                 if (decl)
9768                   {
9769                     /* Look for __unused__ attribute */
9770                     if (TREE_USED (TREE_TYPE (decl)))
9771                       TREE_USED (decl) = 1;
9772                     finish_decl (decl, init, NULL_TREE);
9773                   }
9774                 else
9775                   cp_error ("invalid declarator");
9776                 return 0;
9777               }
9778             innermost_code = TREE_CODE (decl);
9779             if (decl_context == FIELD && ctype == NULL_TREE)
9780               ctype = current_class_type;
9781             if (ctype
9782                 && TREE_OPERAND (decl, 0)
9783                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9784                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9785                          == constructor_name_full (ctype))
9786                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9787                             == constructor_name (ctype)))))
9788               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9789             next = &TREE_OPERAND (decl, 0);
9790             decl = *next;
9791             if (ctype != NULL_TREE
9792                 && decl != NULL_TREE && flags != DTOR_FLAG
9793                 && decl == constructor_name (ctype))
9794               {
9795                 sfk = sfk_constructor;
9796                 ctor_return_type = ctype;
9797               }
9798             ctype = NULL_TREE;
9799             break;
9800
9801           case TEMPLATE_ID_EXPR:
9802               {
9803                 tree fns = TREE_OPERAND (decl, 0);
9804
9805                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9806                   fns = TREE_OPERAND (fns, 0);
9807
9808                 dname = fns;
9809                 if (TREE_CODE (dname) == COMPONENT_REF)
9810                   dname = TREE_OPERAND (dname, 1);
9811                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9812                   {
9813                     my_friendly_assert (is_overloaded_fn (dname),
9814                                         19990331);
9815                     dname = DECL_NAME (get_first_fn (dname));
9816                   }
9817               }
9818           /* Fall through. */
9819
9820           case IDENTIFIER_NODE:
9821             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9822               dname = decl;
9823
9824             next = 0;
9825
9826             if (C_IS_RESERVED_WORD (dname))
9827               {
9828                 cp_error ("declarator-id missing; using reserved word `%D'",
9829                           dname);
9830                 name = IDENTIFIER_POINTER (dname);
9831               }
9832             else if (!IDENTIFIER_TYPENAME_P (dname))
9833               name = IDENTIFIER_POINTER (dname);
9834             else
9835               {
9836                 my_friendly_assert (flags == NO_SPECIAL, 154);
9837                 flags = TYPENAME_FLAG;
9838                 ctor_return_type = TREE_TYPE (dname);
9839                 sfk = sfk_conversion;
9840                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9841                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9842                         == TYPE_DECL))
9843                   name = IDENTIFIER_POINTER (dname);
9844                 else
9845                   name = "<invalid operator>";
9846               }
9847             break;
9848
9849             /* C++ extension */
9850           case SCOPE_REF:
9851             {
9852               /* Perform error checking, and decide on a ctype.  */
9853               tree cname = TREE_OPERAND (decl, 0);
9854               if (cname == NULL_TREE)
9855                 ctype = NULL_TREE;
9856               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9857                 {
9858                   ctype = NULL_TREE;
9859                   in_namespace = TREE_OPERAND (decl, 0);
9860                   TREE_OPERAND (decl, 0) = NULL_TREE;
9861                 }
9862               else if (! is_aggr_type (cname, 1))
9863                 TREE_OPERAND (decl, 0) = NULL_TREE;
9864               /* Must test TREE_OPERAND (decl, 1), in case user gives
9865                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9866               else if (TREE_OPERAND (decl, 1)
9867                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9868                 ctype = cname;
9869               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9870                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9871                 {
9872                   cp_error ("`%T::%D' is not a valid declarator", cname,
9873                             TREE_OPERAND (decl, 1));
9874                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9875                             cname, TREE_OPERAND (decl, 1));
9876                   return void_type_node;
9877                 }
9878               else if (ctype == NULL_TREE)
9879                 ctype = cname;
9880               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9881                 TREE_OPERAND (decl, 0) = ctype;
9882               else
9883                 {
9884                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9885                     {
9886                       cp_error ("type `%T' is not derived from type `%T'",
9887                                 cname, ctype);
9888                       TREE_OPERAND (decl, 0) = NULL_TREE;
9889                     }
9890                   else
9891                     ctype = cname;
9892                 }
9893
9894               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9895                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9896                        == constructor_name_full (ctype))
9897                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9898                           == constructor_name (ctype))))
9899                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9900               next = &TREE_OPERAND (decl, 1);
9901               decl = *next;
9902               if (ctype)
9903                 {
9904                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9905                       && constructor_name (ctype) == decl)
9906                     {
9907                       sfk = sfk_constructor;
9908                       ctor_return_type = ctype;
9909                     }
9910                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9911                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9912                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9913                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9914                     {
9915                       sfk = sfk_destructor;
9916                       ctor_return_type = ctype;
9917                       flags = DTOR_FLAG;
9918                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9919                       next = &TREE_OPERAND (decl, 0);
9920                     }
9921                 }
9922             }
9923             break;
9924
9925           case ERROR_MARK:
9926             next = 0;
9927             break;
9928
9929           case TYPE_DECL:
9930             /* Parse error puts this typespec where
9931                a declarator should go.  */
9932             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9933             if (TREE_TYPE (decl) == current_class_type)
9934               cp_error ("  perhaps you want `%T' for a constructor",
9935                         current_class_name);
9936             dname = DECL_NAME (decl);
9937             name = IDENTIFIER_POINTER (dname);
9938
9939             /* Avoid giving two errors for this.  */
9940             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9941
9942             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9943             *next = dname;
9944             next = 0;
9945             break;
9946
9947           default:
9948             cp_compiler_error ("`%D' as declarator", decl);
9949             return 0; /* We used to do a 155 abort here.  */
9950           }
9951       }
9952   }
9953
9954   /* A function definition's declarator must have the form of
9955      a function declarator.  */
9956
9957   if (funcdef_flag && innermost_code != CALL_EXPR)
9958     return 0;
9959
9960   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9961       && innermost_code != CALL_EXPR
9962       && ! (ctype && declspecs == NULL_TREE))
9963     {
9964       cp_error ("declaration of `%D' as non-function", dname);
9965       return void_type_node;
9966     }
9967
9968   /* Anything declared one level down from the top level
9969      must be one of the parameters of a function
9970      (because the body is at least two levels down).  */
9971
9972   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9973      by not allowing C++ class definitions to specify their parameters
9974      with xdecls (must be spec.d in the parmlist).
9975
9976      Since we now wait to push a class scope until we are sure that
9977      we are in a legitimate method context, we must set oldcname
9978      explicitly (since current_class_name is not yet alive).
9979
9980      We also want to avoid calling this a PARM if it is in a namespace.  */
9981
9982   if (decl_context == NORMAL && !toplevel_bindings_p ())
9983     {
9984       struct binding_level *b = current_binding_level;
9985       current_binding_level = b->level_chain;
9986       if (current_binding_level != 0 && toplevel_bindings_p ())
9987         decl_context = PARM;
9988       current_binding_level = b;
9989     }
9990
9991   if (name == NULL)
9992     name = decl_context == PARM ? "parameter" : "type name";
9993
9994   /* Look through the decl specs and record which ones appear.
9995      Some typespecs are defined as built-in typenames.
9996      Others, the ones that are modifiers of other types,
9997      are represented by bits in SPECBITS: set the bits for
9998      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9999
10000      If there is a typedef name or a type, store the type in TYPE.
10001      This includes builtin typedefs such as `int'.
10002
10003      Set EXPLICIT_INT if the type is `int' or `char' and did not
10004      come from a user typedef.
10005
10006      Set LONGLONG if `long' is mentioned twice.
10007
10008      For C++, constructors and destructors have their own fast treatment.  */
10009
10010   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10011     {
10012       register int i;
10013       register tree id;
10014
10015       /* Certain parse errors slip through.  For example,
10016          `int class;' is not caught by the parser. Try
10017          weakly to recover here.  */
10018       if (TREE_CODE (spec) != TREE_LIST)
10019         return 0;
10020
10021       id = TREE_VALUE (spec);
10022
10023       if (TREE_CODE (id) == IDENTIFIER_NODE)
10024         {
10025           if (id == ridpointers[(int) RID_INT]
10026               || id == ridpointers[(int) RID_CHAR]
10027               || id == ridpointers[(int) RID_BOOL]
10028               || id == ridpointers[(int) RID_WCHAR])
10029             {
10030               if (type)
10031                 {
10032                   if (id == ridpointers[(int) RID_BOOL])
10033                     error ("`bool' is now a keyword");
10034                   else
10035                     cp_error ("extraneous `%T' ignored", id);
10036                 }
10037               else
10038                 {
10039                   if (id == ridpointers[(int) RID_INT])
10040                     explicit_int = 1;
10041                   else if (id == ridpointers[(int) RID_CHAR])
10042                     explicit_char = 1;
10043                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10044                 }
10045               goto found;
10046             }
10047           /* C++ aggregate types.  */
10048           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10049             {
10050               if (type)
10051                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10052               else
10053                 type = IDENTIFIER_TYPE_VALUE (id);
10054               goto found;
10055             }
10056
10057           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10058             {
10059               if (ridpointers[i] == id)
10060                 {
10061                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10062                     {
10063                       if (pedantic && ! in_system_header && warn_long_long)
10064                         pedwarn ("ISO C++ does not support `long long'");
10065                       if (longlong)
10066                         error ("`long long long' is too long for GCC");
10067                       else
10068                         longlong = 1;
10069                     }
10070                   else if (RIDBIT_SETP (i, specbits))
10071                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10072                   RIDBIT_SET (i, specbits);
10073                   goto found;
10074                 }
10075             }
10076         }
10077       /* C++ aggregate types.  */
10078       else if (TREE_CODE (id) == TYPE_DECL)
10079         {
10080           if (type)
10081             cp_error ("multiple declarations `%T' and `%T'", type,
10082                       TREE_TYPE (id));
10083           else
10084             {
10085               type = TREE_TYPE (id);
10086               TREE_VALUE (spec) = type;
10087             }
10088           goto found;
10089         }
10090       if (type)
10091         error ("two or more data types in declaration of `%s'", name);
10092       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10093         {
10094           register tree t = lookup_name (id, 1);
10095           if (!t || TREE_CODE (t) != TYPE_DECL)
10096             error ("`%s' fails to be a typedef or built in type",
10097                    IDENTIFIER_POINTER (id));
10098           else
10099             {
10100               type = TREE_TYPE (t);
10101 #if 0
10102               /* See the code below that used this.  */
10103               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10104 #endif
10105               typedef_decl = t;
10106             }
10107         }
10108       else if (id != error_mark_node)
10109         /* Can't change CLASS nodes into RECORD nodes here!  */
10110         type = id;
10111
10112     found: ;
10113     }
10114
10115   typedef_type = type;
10116
10117   /* No type at all: default to `int', and set DEFAULTED_INT
10118      because it was not a user-defined typedef.  */
10119
10120   if (type == NULL_TREE
10121       && (RIDBIT_SETP (RID_SIGNED, specbits)
10122           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10123           || RIDBIT_SETP (RID_LONG, specbits)
10124           || RIDBIT_SETP (RID_SHORT, specbits)))
10125     {
10126       /* These imply 'int'.  */
10127       type = integer_type_node;
10128       defaulted_int = 1;
10129     }
10130
10131   if (sfk != sfk_none)
10132     type = check_special_function_return_type (sfk, type,
10133                                                ctor_return_type,
10134                                                ctor_return_type);
10135   else if (type == NULL_TREE)
10136     {
10137       int is_main;
10138
10139       explicit_int = -1;
10140
10141           /* We handle `main' specially here, because 'main () { }' is so
10142              common.  With no options, it is allowed.  With -Wreturn-type,
10143              it is a warning.  It is only an error with -pedantic-errors.  */
10144       is_main = (funcdef_flag
10145                  && MAIN_NAME_P (dname)
10146                  && ctype == NULL_TREE
10147                  && in_namespace == NULL_TREE
10148                  && current_namespace == global_namespace);
10149
10150       if (in_system_header || flag_ms_extensions)
10151         /* Allow it, sigh.  */;
10152       else if (pedantic || ! is_main)
10153         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10154                     name);
10155       else if (warn_return_type)
10156         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10157                     name);
10158
10159       type = integer_type_node;
10160     }
10161
10162   ctype = NULL_TREE;
10163
10164   /* Now process the modifiers that were specified
10165      and check for invalid combinations.  */
10166
10167   /* Long double is a special combination.  */
10168
10169   if (RIDBIT_SETP (RID_LONG, specbits)
10170       && TYPE_MAIN_VARIANT (type) == double_type_node)
10171     {
10172       RIDBIT_RESET (RID_LONG, specbits);
10173       type = build_qualified_type (long_double_type_node,
10174                                    CP_TYPE_QUALS (type));
10175     }
10176
10177   /* Check all other uses of type modifiers.  */
10178
10179   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10180       || RIDBIT_SETP (RID_SIGNED, specbits)
10181       || RIDBIT_SETP (RID_LONG, specbits)
10182       || RIDBIT_SETP (RID_SHORT, specbits))
10183     {
10184       int ok = 0;
10185
10186       if (TREE_CODE (type) == REAL_TYPE)
10187         error ("short, signed or unsigned invalid for `%s'", name);
10188       else if (TREE_CODE (type) != INTEGER_TYPE)
10189         error ("long, short, signed or unsigned invalid for `%s'", name);
10190       else if (RIDBIT_SETP (RID_LONG, specbits)
10191                && RIDBIT_SETP (RID_SHORT, specbits))
10192         error ("long and short specified together for `%s'", name);
10193       else if ((RIDBIT_SETP (RID_LONG, specbits)
10194                 || RIDBIT_SETP (RID_SHORT, specbits))
10195                && explicit_char)
10196         error ("long or short specified with char for `%s'", name);
10197       else if ((RIDBIT_SETP (RID_LONG, specbits)
10198                 || RIDBIT_SETP (RID_SHORT, specbits))
10199                && TREE_CODE (type) == REAL_TYPE)
10200         error ("long or short specified with floating type for `%s'", name);
10201       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10202                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10203         error ("signed and unsigned given together for `%s'", name);
10204       else
10205         {
10206           ok = 1;
10207           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10208             {
10209               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10210                        name);
10211               if (flag_pedantic_errors)
10212                 ok = 0;
10213             }
10214         }
10215
10216       /* Discard the type modifiers if they are invalid.  */
10217       if (! ok)
10218         {
10219           RIDBIT_RESET (RID_UNSIGNED, specbits);
10220           RIDBIT_RESET (RID_SIGNED, specbits);
10221           RIDBIT_RESET (RID_LONG, specbits);
10222           RIDBIT_RESET (RID_SHORT, specbits);
10223           longlong = 0;
10224         }
10225     }
10226
10227   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10228       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10229     {
10230       error ("complex invalid for `%s'", name);
10231       RIDBIT_RESET (RID_COMPLEX, specbits);
10232     }
10233
10234   /* Decide whether an integer type is signed or not.
10235      Optionally treat bitfields as signed by default.  */
10236   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10237       /* [class.bit]
10238
10239          It is implementation-defined whether a plain (neither
10240          explicitly signed or unsigned) char, short, int, or long
10241          bit-field is signed or unsigned.
10242
10243          Naturally, we extend this to long long as well.  Note that
10244          this does not include wchar_t.  */
10245       || (bitfield && !flag_signed_bitfields
10246           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10247           /* A typedef for plain `int' without `signed' can be
10248              controlled just like plain `int', but a typedef for
10249              `signed int' cannot be so controlled.  */
10250           && !(typedef_decl
10251                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10252           && (TREE_CODE (type) == INTEGER_TYPE
10253               || TREE_CODE (type) == CHAR_TYPE)
10254           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10255     {
10256       if (longlong)
10257         type = long_long_unsigned_type_node;
10258       else if (RIDBIT_SETP (RID_LONG, specbits))
10259         type = long_unsigned_type_node;
10260       else if (RIDBIT_SETP (RID_SHORT, specbits))
10261         type = short_unsigned_type_node;
10262       else if (type == char_type_node)
10263         type = unsigned_char_type_node;
10264       else if (typedef_decl)
10265         type = unsigned_type (type);
10266       else
10267         type = unsigned_type_node;
10268     }
10269   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10270            && type == char_type_node)
10271     type = signed_char_type_node;
10272   else if (longlong)
10273     type = long_long_integer_type_node;
10274   else if (RIDBIT_SETP (RID_LONG, specbits))
10275     type = long_integer_type_node;
10276   else if (RIDBIT_SETP (RID_SHORT, specbits))
10277     type = short_integer_type_node;
10278
10279   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10280     {
10281       /* If we just have "complex", it is equivalent to
10282          "complex double", but if any modifiers at all are specified it is
10283          the complex form of TYPE.  E.g, "complex short" is
10284          "complex short int".  */
10285
10286       if (defaulted_int && ! longlong
10287           && ! (RIDBIT_SETP (RID_LONG, specbits)
10288                 || RIDBIT_SETP (RID_SHORT, specbits)
10289                 || RIDBIT_SETP (RID_SIGNED, specbits)
10290                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10291         type = complex_double_type_node;
10292       else if (type == integer_type_node)
10293         type = complex_integer_type_node;
10294       else if (type == float_type_node)
10295         type = complex_float_type_node;
10296       else if (type == double_type_node)
10297         type = complex_double_type_node;
10298       else if (type == long_double_type_node)
10299         type = complex_long_double_type_node;
10300       else
10301         type = build_complex_type (type);
10302     }
10303
10304   if (sfk == sfk_conversion
10305       && (RIDBIT_SETP (RID_CONST, specbits)
10306           || RIDBIT_SETP (RID_VOLATILE, specbits)
10307           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10308     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10309               ctor_return_type);
10310
10311   /* Set CONSTP if this declaration is `const', whether by
10312      explicit specification or via a typedef.
10313      Likewise for VOLATILEP.  */
10314
10315   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10316   restrictp =
10317     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10318   volatilep =
10319     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10320   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10321                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10322                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10323   type = cp_build_qualified_type (type, type_quals);
10324   staticp = 0;
10325   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10326   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10327   RIDBIT_RESET (RID_VIRTUAL, specbits);
10328   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10329   RIDBIT_RESET (RID_EXPLICIT, specbits);
10330
10331   if (RIDBIT_SETP (RID_STATIC, specbits))
10332     staticp = 1 + (decl_context == FIELD);
10333
10334   if (virtualp && staticp == 2)
10335     {
10336       cp_error ("member `%D' cannot be declared both virtual and static",
10337                 dname);
10338       staticp = 0;
10339     }
10340   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10341   RIDBIT_RESET (RID_FRIEND, specbits);
10342
10343   /* Warn if two storage classes are given. Default to `auto'.  */
10344
10345   if (RIDBIT_ANY_SET (specbits))
10346     {
10347       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10348       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10349       if (decl_context == PARM && nclasses > 0)
10350         error ("storage class specifiers invalid in parameter declarations");
10351       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10352         {
10353           if (decl_context == PARM)
10354             error ("typedef declaration invalid in parameter declaration");
10355           nclasses++;
10356         }
10357       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10358       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10359     }
10360
10361   /* Give error if `virtual' is used outside of class declaration.  */
10362   if (virtualp
10363       && (current_class_name == NULL_TREE || decl_context != FIELD))
10364     {
10365       error ("virtual outside class declaration");
10366       virtualp = 0;
10367     }
10368
10369   /* Static anonymous unions are dealt with here.  */
10370   if (staticp && decl_context == TYPENAME
10371       && TREE_CODE (declspecs) == TREE_LIST
10372       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10373     decl_context = FIELD;
10374
10375   /* Warn about storage classes that are invalid for certain
10376      kinds of declarations (parameters, typenames, etc.).  */
10377
10378   if (nclasses > 1)
10379     error ("multiple storage classes in declaration of `%s'", name);
10380   else if (decl_context != NORMAL && nclasses > 0)
10381     {
10382       if ((decl_context == PARM || decl_context == CATCHPARM)
10383           && (RIDBIT_SETP (RID_REGISTER, specbits)
10384               || RIDBIT_SETP (RID_AUTO, specbits)))
10385         ;
10386       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10387         ;
10388       else if (decl_context == FIELD
10389                /* C++ allows static class elements  */
10390                && RIDBIT_SETP (RID_STATIC, specbits))
10391         /* C++ also allows inlines and signed and unsigned elements,
10392            but in those cases we don't come in here.  */
10393         ;
10394       else
10395         {
10396           if (decl_context == FIELD)
10397             {
10398               tree tmp = NULL_TREE;
10399               register int op = 0;
10400
10401               if (declarator)
10402                 {
10403                   /* Avoid trying to get an operand off an identifier node.  */
10404                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10405                     tmp = declarator;
10406                   else
10407                     tmp = TREE_OPERAND (declarator, 0);
10408                   op = IDENTIFIER_OPNAME_P (tmp);
10409                   if (IDENTIFIER_TYPENAME_P (tmp))
10410                     {
10411                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10412                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10413                               == TYPE_DECL))
10414                         name = IDENTIFIER_POINTER (tmp);
10415                       else
10416                         name = "<invalid operator>";
10417                     }
10418                 }
10419               error ("storage class specified for %s `%s'",
10420                      op ? "member operator" : "field",
10421                      name);
10422             }
10423           else
10424             {
10425               if (decl_context == PARM || decl_context == CATCHPARM)
10426                 error ("storage class specified for parameter `%s'", name);
10427               else
10428                 error ("storage class specified for typename");
10429             }
10430           RIDBIT_RESET (RID_REGISTER, specbits);
10431           RIDBIT_RESET (RID_AUTO, specbits);
10432           RIDBIT_RESET (RID_EXTERN, specbits);
10433         }
10434     }
10435   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10436     {
10437       if (toplevel_bindings_p ())
10438         {
10439           /* It's common practice (and completely valid) to have a const
10440              be initialized and declared extern.  */
10441           if (!(type_quals & TYPE_QUAL_CONST))
10442             warning ("`%s' initialized and declared `extern'", name);
10443         }
10444       else
10445         error ("`%s' has both `extern' and initializer", name);
10446     }
10447   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10448            && ! toplevel_bindings_p ())
10449     error ("nested function `%s' declared `extern'", name);
10450   else if (toplevel_bindings_p ())
10451     {
10452       if (RIDBIT_SETP (RID_AUTO, specbits))
10453         error ("top-level declaration of `%s' specifies `auto'", name);
10454     }
10455
10456   if (nclasses > 0 && friendp)
10457     error ("storage class specifiers invalid in friend function declarations");
10458
10459   /* Now figure out the structure of the declarator proper.
10460      Descend through it, creating more complex types, until we reach
10461      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10462
10463   inner_attrs = NULL_TREE;
10464   ignore_attrs = 0;
10465
10466   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10467          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10468     {
10469       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10470          an INDIRECT_REF (for *...),
10471          a CALL_EXPR (for ...(...)),
10472          an identifier (for the name being declared)
10473          or a null pointer (for the place in an absolute declarator
10474          where the name was omitted).
10475          For the last two cases, we have just exited the loop.
10476
10477          For C++ it could also be
10478          a SCOPE_REF (for class :: ...).  In this case, we have converted
10479          sensible names to types, and those are the values we use to
10480          qualify the member name.
10481          an ADDR_EXPR (for &...),
10482          a BIT_NOT_EXPR (for destructors)
10483
10484          At this point, TYPE is the type of elements of an array,
10485          or for a function to return, or for a pointer to point to.
10486          After this sequence of ifs, TYPE is the type of the
10487          array or function or pointer, and DECLARATOR has had its
10488          outermost layer removed.  */
10489
10490       if (type == error_mark_node)
10491         {
10492           if (TREE_CODE (declarator) == SCOPE_REF)
10493             declarator = TREE_OPERAND (declarator, 1);
10494           else
10495             declarator = TREE_OPERAND (declarator, 0);
10496           continue;
10497         }
10498       if (quals != NULL_TREE
10499           && (declarator == NULL_TREE
10500               || TREE_CODE (declarator) != SCOPE_REF))
10501         {
10502           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10503             ctype = TYPE_METHOD_BASETYPE (type);
10504           if (ctype != NULL_TREE)
10505             {
10506               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10507               grok_method_quals (ctype, dummy, quals);
10508               type = TREE_TYPE (dummy);
10509               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10510               quals = NULL_TREE;
10511             }
10512         }
10513
10514       /* See the comment for the TREE_LIST case, below.  */
10515       if (ignore_attrs)
10516         ignore_attrs = 0;
10517       else if (inner_attrs)
10518         {
10519           decl_attributes (type, inner_attrs, NULL_TREE);
10520           inner_attrs = NULL_TREE;
10521         }
10522
10523       switch (TREE_CODE (declarator))
10524         {
10525         case TREE_LIST:
10526           {
10527             /* We encode a declarator with embedded attributes using
10528                a TREE_LIST.  The attributes apply to the declarator
10529                directly inside them, so we have to skip an iteration
10530                before applying them to the type.  If the declarator just
10531                inside is the declarator-id, we apply the attrs to the
10532                decl itself.  */
10533             inner_attrs = TREE_PURPOSE (declarator);
10534             ignore_attrs = 1;
10535             declarator = TREE_VALUE (declarator);
10536           }
10537           break;
10538
10539         case ARRAY_REF:
10540           {
10541             register tree size;
10542
10543             size = TREE_OPERAND (declarator, 1);
10544
10545             /* VC++ spells a zero-sized array with [].  */
10546             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10547                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10548               size = integer_zero_node;
10549
10550             declarator = TREE_OPERAND (declarator, 0);
10551
10552             type = create_array_type_for_decl (dname, type, size);
10553
10554             /* VLAs never work as fields. */
10555             if (decl_context == FIELD && !processing_template_decl
10556                 && TREE_CODE (type) == ARRAY_TYPE
10557                 && TYPE_DOMAIN (type) != NULL_TREE
10558                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10559               {
10560                 cp_error ("size of member `%D' is not constant", dname);
10561                 /* Proceed with arbitrary constant size, so that offset
10562                    computations don't get confused. */
10563                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10564                                                    integer_one_node);
10565               }
10566
10567             ctype = NULL_TREE;
10568           }
10569           break;
10570
10571         case CALL_EXPR:
10572           {
10573             tree arg_types;
10574             int funcdecl_p;
10575             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10576             tree inner_decl = TREE_OPERAND (declarator, 0);
10577
10578             /* Declaring a function type.
10579                Make sure we have a valid type for the function to return.  */
10580
10581             /* We now know that the TYPE_QUALS don't apply to the
10582                decl, but to its return type.  */
10583             type_quals = TYPE_UNQUALIFIED;
10584
10585             /* Warn about some types functions can't return.  */
10586
10587             if (TREE_CODE (type) == FUNCTION_TYPE)
10588               {
10589                 error ("`%s' declared as function returning a function", name);
10590                 type = integer_type_node;
10591               }
10592             if (TREE_CODE (type) == ARRAY_TYPE)
10593               {
10594                 error ("`%s' declared as function returning an array", name);
10595                 type = integer_type_node;
10596               }
10597
10598             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10599               inner_decl = TREE_OPERAND (inner_decl, 1);
10600
10601             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10602               inner_decl = dname;
10603
10604             /* Pick up type qualifiers which should be applied to `this'.  */
10605             quals = CALL_DECLARATOR_QUALS (declarator);
10606
10607             /* Pick up the exception specifications.  */
10608             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10609
10610             /* Say it's a definition only for the CALL_EXPR
10611                closest to the identifier.  */
10612             funcdecl_p
10613               = inner_decl
10614               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10615                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10616                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10617
10618             if (ctype == NULL_TREE
10619                 && decl_context == FIELD
10620                 && funcdecl_p
10621                 && (friendp == 0 || dname == current_class_name))
10622               ctype = current_class_type;
10623
10624             if (ctype && sfk == sfk_conversion)
10625               TYPE_HAS_CONVERSION (ctype) = 1;
10626             if (ctype && constructor_name (ctype) == dname)
10627               {
10628                 /* We are within a class's scope. If our declarator name
10629                    is the same as the class name, and we are defining
10630                    a function, then it is a constructor/destructor, and
10631                    therefore returns a void type.  */
10632
10633                 if (flags == DTOR_FLAG)
10634                   {
10635                     /* ISO C++ 12.4/2.  A destructor may not be
10636                        declared const or volatile.  A destructor may
10637                        not be static.  */
10638                     if (staticp == 2)
10639                       error ("destructor cannot be static member function");
10640                     if (quals)
10641                       {
10642                         cp_error ("destructors may not be `%s'",
10643                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10644                         quals = NULL_TREE;
10645                       }
10646                     if (decl_context == FIELD)
10647                       {
10648                         if (! member_function_or_else (ctype,
10649                                                        current_class_type,
10650                                                        flags))
10651                           return void_type_node;
10652                       }
10653                   }
10654                 else            /* It's a constructor.  */
10655                   {
10656                     if (explicitp == 1)
10657                       explicitp = 2;
10658                     /* ISO C++ 12.1.  A constructor may not be
10659                        declared const or volatile.  A constructor may
10660                        not be virtual.  A constructor may not be
10661                        static.  */
10662                     if (staticp == 2)
10663                       error ("constructor cannot be static member function");
10664                     if (virtualp)
10665                       {
10666                         pedwarn ("constructors cannot be declared virtual");
10667                         virtualp = 0;
10668                       }
10669                     if (quals)
10670                       {
10671                         cp_error ("constructors may not be `%s'",
10672                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10673                         quals = NULL_TREE;
10674                       }
10675                     {
10676                       RID_BIT_TYPE tmp_bits;
10677                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10678                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10679                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10680                       if (RIDBIT_ANY_SET (tmp_bits))
10681                         error ("return value type specifier for constructor ignored");
10682                     }
10683                     if (decl_context == FIELD)
10684                       {
10685                         if (! member_function_or_else (ctype,
10686                                                        current_class_type,
10687                                                        flags))
10688                           return void_type_node;
10689                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10690                         if (sfk != sfk_constructor)
10691                           return NULL_TREE;
10692                       }
10693                   }
10694                 if (decl_context == FIELD)
10695                   staticp = 0;
10696               }
10697             else if (friendp)
10698               {
10699                 if (initialized)
10700                   error ("can't initialize friend function `%s'", name);
10701                 if (virtualp)
10702                   {
10703                     /* Cannot be both friend and virtual.  */
10704                     error ("virtual functions cannot be friends");
10705                     RIDBIT_RESET (RID_FRIEND, specbits);
10706                     friendp = 0;
10707                   }
10708                 if (decl_context == NORMAL)
10709                   error ("friend declaration not in class definition");
10710                 if (current_function_decl && funcdef_flag)
10711                   cp_error ("can't define friend function `%s' in a local class definition",
10712                             name);
10713               }
10714
10715             /* Construct the function type and go to the next
10716                inner layer of declarator.  */
10717
10718             declarator = TREE_OPERAND (declarator, 0);
10719
10720             /* FIXME: This is where default args should be fully
10721                processed.  */
10722
10723             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10724
10725             if (declarator && flags == DTOR_FLAG)
10726               {
10727                 /* A destructor declared in the body of a class will
10728                    be represented as a BIT_NOT_EXPR.  But, we just
10729                    want the underlying IDENTIFIER.  */
10730                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10731                   declarator = TREE_OPERAND (declarator, 0);
10732
10733                 if (arg_types != void_list_node)
10734                   {
10735                     cp_error ("destructors may not have parameters");
10736                     arg_types = void_list_node;
10737                     last_function_parms = NULL_TREE;
10738                   }
10739               }
10740
10741             /* ANSI says that `const int foo ();'
10742                does not make the function foo const.  */
10743             type = build_function_type (type, arg_types);
10744
10745             {
10746               tree t;
10747               for (t = arg_types; t; t = TREE_CHAIN (t))
10748                 if (TREE_PURPOSE (t)
10749                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10750                   {
10751                     add_defarg_fn (type);
10752                     break;
10753                   }
10754             }
10755           }
10756           break;
10757
10758         case ADDR_EXPR:
10759         case INDIRECT_REF:
10760           /* Filter out pointers-to-references and references-to-references.
10761              We can get these if a TYPE_DECL is used.  */
10762
10763           if (TREE_CODE (type) == REFERENCE_TYPE)
10764             {
10765               error ("cannot declare %s to references",
10766                      TREE_CODE (declarator) == ADDR_EXPR
10767                      ? "references" : "pointers");
10768               declarator = TREE_OPERAND (declarator, 0);
10769               continue;
10770             }
10771
10772           if (TREE_CODE (type) == OFFSET_TYPE
10773               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10774                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10775             {
10776               cp_error ("cannot declare pointer to `%#T' member",
10777                         TREE_TYPE (type));
10778               type = TREE_TYPE (type);
10779             }
10780
10781           /* Merge any constancy or volatility into the target type
10782              for the pointer.  */
10783
10784           /* We now know that the TYPE_QUALS don't apply to the decl,
10785              but to the target of the pointer.  */
10786           type_quals = TYPE_UNQUALIFIED;
10787
10788           if (TREE_CODE (declarator) == ADDR_EXPR)
10789             {
10790               if (TREE_CODE (type) == VOID_TYPE)
10791                 error ("invalid type: `void &'");
10792               else
10793                 type = build_reference_type (type);
10794             }
10795           else if (TREE_CODE (type) == METHOD_TYPE)
10796             type = build_ptrmemfunc_type (build_pointer_type (type));
10797           else
10798             type = build_pointer_type (type);
10799
10800           /* Process a list of type modifier keywords (such as
10801              const or volatile) that were given inside the `*' or `&'.  */
10802
10803           if (TREE_TYPE (declarator))
10804             {
10805               register tree typemodlist;
10806               int erred = 0;
10807
10808               constp = 0;
10809               volatilep = 0;
10810               restrictp = 0;
10811               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10812                    typemodlist = TREE_CHAIN (typemodlist))
10813                 {
10814                   tree qualifier = TREE_VALUE (typemodlist);
10815
10816                   if (qualifier == ridpointers[(int) RID_CONST])
10817                     constp++;
10818                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10819                     volatilep++;
10820                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10821                     restrictp++;
10822                   else if (!erred)
10823                     {
10824                       erred = 1;
10825                       error ("invalid type modifier within pointer declarator");
10826                     }
10827                 }
10828               if (constp > 1)
10829                 pedwarn ("duplicate `const'");
10830               if (volatilep > 1)
10831                 pedwarn ("duplicate `volatile'");
10832               if (restrictp > 1)
10833                 pedwarn ("duplicate `restrict'");
10834
10835               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10836                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10837                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10838               if (TREE_CODE (declarator) == ADDR_EXPR
10839                   && (constp || volatilep))
10840                 {
10841                   if (constp)
10842                     pedwarn ("discarding `const' applied to a reference");
10843                   if (volatilep)
10844                     pedwarn ("discarding `volatile' applied to a reference");
10845                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10846                 }
10847               type = cp_build_qualified_type (type, type_quals);
10848             }
10849           declarator = TREE_OPERAND (declarator, 0);
10850           ctype = NULL_TREE;
10851           break;
10852
10853         case SCOPE_REF:
10854           {
10855             /* We have converted type names to NULL_TREE if the
10856                name was bogus, or to a _TYPE node, if not.
10857
10858                The variable CTYPE holds the type we will ultimately
10859                resolve to.  The code here just needs to build
10860                up appropriate member types.  */
10861             tree sname = TREE_OPERAND (declarator, 1);
10862             tree t;
10863
10864             /* Destructors can have their visibilities changed as well.  */
10865             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10866               sname = TREE_OPERAND (sname, 0);
10867
10868             if (TREE_COMPLEXITY (declarator) == 0)
10869               /* This needs to be here, in case we are called
10870                  multiple times.  */ ;
10871             else if (TREE_COMPLEXITY (declarator) == -1)
10872               /* Namespace member. */
10873               pop_decl_namespace ();
10874             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10875               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10876             else if (! IS_AGGR_TYPE_CODE
10877                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10878               ;
10879             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10880               {
10881                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10882                    that refer to ctype.  They couldn't be resolved earlier
10883                    because we hadn't pushed into the class yet.
10884                    Example: resolve 'B<T>::type' in
10885                    'B<typename B<T>::type> B<T>::f () { }'.  */
10886                 if (current_template_parms
10887                     && uses_template_parms (type)
10888                     && uses_template_parms (current_class_type))
10889                   {
10890                     tree args = current_template_args ();
10891                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10892                   }
10893
10894                 /* This pop_nested_class corresponds to the
10895                    push_nested_class used to push into class scope for
10896                    parsing the argument list of a function decl, in
10897                    qualified_id.  */
10898                 pop_nested_class ();
10899                 TREE_COMPLEXITY (declarator) = current_class_depth;
10900               }
10901             else
10902               my_friendly_abort (16);
10903
10904             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10905               {
10906                 /* We had a reference to a global decl, or
10907                    perhaps we were given a non-aggregate typedef,
10908                    in which case we cleared this out, and should just
10909                    keep going as though it wasn't there.  */
10910                 declarator = sname;
10911                 continue;
10912               }
10913             ctype = TREE_OPERAND (declarator, 0);
10914
10915             t = ctype;
10916             while (t != NULL_TREE && CLASS_TYPE_P (t))
10917               {
10918                 /* You're supposed to have one `template <...>'
10919                    for every template class, but you don't need one
10920                    for a full specialization.  For example:
10921
10922                      template <class T> struct S{};
10923                      template <> struct S<int> { void f(); };
10924                      void S<int>::f () {}
10925
10926                    is correct; there shouldn't be a `template <>' for
10927                    the definition of `S<int>::f'.  */
10928                 if (CLASSTYPE_TEMPLATE_INFO (t)
10929                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10930                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10931                   template_count += 1;
10932
10933                 t = TYPE_MAIN_DECL (t);
10934                 if (DECL_LANG_SPECIFIC (t))
10935                   t = DECL_CONTEXT (t);
10936                 else
10937                   t = NULL_TREE;
10938               }
10939
10940             if (sname == NULL_TREE)
10941               goto done_scoping;
10942
10943             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10944               {
10945                 /* This is the `standard' use of the scoping operator:
10946                    basetype :: member .  */
10947
10948                 if (ctype == current_class_type)
10949                   {
10950                     /* class A {
10951                          void A::f ();
10952                        };
10953
10954                        Is this ill-formed?  */
10955
10956                     if (pedantic)
10957                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10958                                   ctype, name);
10959                   }
10960                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10961                   {
10962                     if (current_class_type == NULL_TREE
10963                         || friendp)
10964                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10965                                                       TYPE_ARG_TYPES (type));
10966                     else
10967                       {
10968                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10969                                   ctype, name, current_class_type);
10970                         return void_type_node;
10971                       }
10972                   }
10973                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10974                          || COMPLETE_TYPE_P (complete_type (ctype)))
10975                   {
10976                     /* Have to move this code elsewhere in this function.
10977                        this code is used for i.e., typedef int A::M; M *pm;
10978
10979                        It is?  How? jason 10/2/94 */
10980
10981                     if (current_class_type)
10982                       {
10983                         cp_error ("cannot declare member `%T::%s' within `%T'",
10984                                   ctype, name, current_class_type);
10985                         return void_type_node;
10986                       }
10987                     type = build_offset_type (ctype, type);
10988                   }
10989                 else if (uses_template_parms (ctype))
10990                   {
10991                     if (TREE_CODE (type) == FUNCTION_TYPE)
10992                       type
10993                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10994                                                    TYPE_ARG_TYPES (type));
10995                   }
10996                 else
10997                   {
10998                     cp_error ("structure `%T' not yet defined", ctype);
10999                     return error_mark_node;
11000                   }
11001
11002                 declarator = sname;
11003               }
11004             else if (TREE_CODE (sname) == SCOPE_REF)
11005               my_friendly_abort (17);
11006             else
11007               {
11008               done_scoping:
11009                 declarator = TREE_OPERAND (declarator, 1);
11010                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11011                   /* In this case, we will deal with it later.  */
11012                   ;
11013                 else
11014                   {
11015                     if (TREE_CODE (type) == FUNCTION_TYPE)
11016                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11017                                                       TYPE_ARG_TYPES (type));
11018                     else
11019                       type = build_offset_type (ctype, type);
11020                   }
11021               }
11022           }
11023           break;
11024
11025         case BIT_NOT_EXPR:
11026           declarator = TREE_OPERAND (declarator, 0);
11027           break;
11028
11029         case RECORD_TYPE:
11030         case UNION_TYPE:
11031         case ENUMERAL_TYPE:
11032           declarator = NULL_TREE;
11033           break;
11034
11035         case ERROR_MARK:
11036           declarator = NULL_TREE;
11037           break;
11038
11039         default:
11040           my_friendly_abort (158);
11041         }
11042     }
11043
11044   /* See the comment for the TREE_LIST case, above.  */
11045   if (inner_attrs)
11046     {
11047       if (! ignore_attrs)
11048         decl_attributes (type, inner_attrs, NULL_TREE);
11049       else if (attrlist)
11050         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11051       else
11052         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11053     }
11054
11055   /* Now TYPE has the actual type.  */
11056
11057   if (explicitp == 1 || (explicitp && friendp))
11058     {
11059       /* [dcl.fct.spec] The explicit specifier shall only be used in
11060          declarations of constructors within a class definition.  */
11061       error ("only declarations of constructors can be `explicit'");
11062       explicitp = 0;
11063     }
11064
11065   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11066     {
11067       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11068         {
11069           error ("non-member `%s' cannot be declared `mutable'", name);
11070           RIDBIT_RESET (RID_MUTABLE, specbits);
11071         }
11072       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11073         {
11074           error ("non-object member `%s' cannot be declared `mutable'", name);
11075           RIDBIT_RESET (RID_MUTABLE, specbits);
11076         }
11077       else if (TREE_CODE (type) == FUNCTION_TYPE
11078                || TREE_CODE (type) == METHOD_TYPE)
11079         {
11080           error ("function `%s' cannot be declared `mutable'", name);
11081           RIDBIT_RESET (RID_MUTABLE, specbits);
11082         }
11083       else if (staticp)
11084         {
11085           error ("static `%s' cannot be declared `mutable'", name);
11086           RIDBIT_RESET (RID_MUTABLE, specbits);
11087         }
11088       else if (type_quals & TYPE_QUAL_CONST)
11089         {
11090           error ("const `%s' cannot be declared `mutable'", name);
11091           RIDBIT_RESET (RID_MUTABLE, specbits);
11092         }
11093     }
11094
11095   if (declarator == NULL_TREE
11096       || TREE_CODE (declarator) == IDENTIFIER_NODE
11097       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11098           && (TREE_CODE (type) == FUNCTION_TYPE
11099               || TREE_CODE (type) == METHOD_TYPE)))
11100     /* OK */;
11101   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11102     {
11103       cp_error ("template-id `%D' used as a declarator", declarator);
11104       declarator = dname;
11105     }
11106   else
11107     /* Unexpected declarator format.  */
11108     my_friendly_abort (990210);
11109
11110   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11111
11112   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11113     {
11114       tree decl;
11115
11116       /* Note that the grammar rejects storage classes
11117          in typenames, fields or parameters.  */
11118       if (current_lang_name == lang_name_java)
11119         TYPE_FOR_JAVA (type) = 1;
11120
11121       if (decl_context == FIELD)
11122         {
11123           if (declarator == constructor_name (current_class_type))
11124             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11125                         declarator);
11126           decl = build_lang_decl (TYPE_DECL, declarator, type);
11127         }
11128       else
11129         decl = build_decl (TYPE_DECL, declarator, type);
11130
11131       /* If the user declares "typedef struct {...} foo" then the
11132          struct will have an anonymous name.  Fill that name in now.
11133          Nothing can refer to it, so nothing needs know about the name
11134          change.  */
11135       if (type != error_mark_node
11136           && declarator
11137           && TYPE_NAME (type)
11138           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11139           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11140           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11141         {
11142           tree oldname = TYPE_NAME (type);
11143           tree t;
11144
11145           /* Replace the anonymous name with the real name everywhere.  */
11146           lookup_tag_reverse (type, declarator);
11147           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11148             if (TYPE_NAME (t) == oldname)
11149               TYPE_NAME (t) = decl;
11150
11151           if (TYPE_LANG_SPECIFIC (type))
11152             TYPE_WAS_ANONYMOUS (type) = 1;
11153
11154           /* If this is a typedef within a template class, the nested
11155              type is a (non-primary) template.  The name for the
11156              template needs updating as well.  */
11157           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11158             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11159               = TYPE_IDENTIFIER (type);
11160
11161           if (flag_new_abi)
11162             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11163           else
11164             {
11165               /* XXX Temporarily set the scope.
11166                  When returning, start_decl expects it as NULL_TREE,
11167                  and will then then set it using pushdecl. */
11168               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11169               if (current_class_type)
11170                 DECL_CONTEXT (decl) = current_class_type;
11171               else
11172                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11173
11174               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11175               DECL_ASSEMBLER_NAME (decl)
11176                 = get_identifier (build_overload_name (type, 1, 1));
11177               DECL_CONTEXT (decl) = NULL_TREE;
11178             }
11179
11180           /* FIXME remangle member functions; member functions of a
11181              type with external linkage have external linkage.  */
11182         }
11183
11184       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11185         {
11186           cp_error_at ("typedef name may not be class-qualified", decl);
11187           return NULL_TREE;
11188         }
11189       else if (quals)
11190         {
11191           if (ctype == NULL_TREE)
11192             {
11193               if (TREE_CODE (type) != METHOD_TYPE)
11194                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11195               else
11196                 ctype = TYPE_METHOD_BASETYPE (type);
11197             }
11198           if (ctype != NULL_TREE)
11199             grok_method_quals (ctype, decl, quals);
11200         }
11201
11202       if (RIDBIT_SETP (RID_SIGNED, specbits)
11203           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11204         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11205
11206       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11207                       inlinep, friendp, raises != NULL_TREE);
11208
11209       if (initialized)
11210         error ("typedef declaration includes an initializer");
11211
11212       return decl;
11213     }
11214
11215   /* Detect the case of an array type of unspecified size
11216      which came, as such, direct from a typedef name.
11217      We must copy the type, so that each identifier gets
11218      a distinct type, so that each identifier's size can be
11219      controlled separately by its own initializer.  */
11220
11221   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11222       && TYPE_DOMAIN (type) == NULL_TREE)
11223     {
11224       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11225     }
11226
11227   /* If this is a type name (such as, in a cast or sizeof),
11228      compute the type and return it now.  */
11229
11230   if (decl_context == TYPENAME)
11231     {
11232       /* Note that the grammar rejects storage classes
11233          in typenames, fields or parameters.  */
11234       if (type_quals != TYPE_UNQUALIFIED)
11235         type_quals = TYPE_UNQUALIFIED;
11236
11237       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11238       if (friendp)
11239         {
11240           if (type_quals != TYPE_UNQUALIFIED)
11241             {
11242               cp_error ("type qualifiers specified for friend class declaration");
11243               type_quals = TYPE_UNQUALIFIED;
11244             }
11245           if (inlinep)
11246             {
11247               cp_error ("`inline' specified for friend class declaration");
11248               inlinep = 0;
11249             }
11250
11251           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11252              But don't allow implicit typenames.  */
11253           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11254                                 || IMPLICIT_TYPENAME_P (type)))
11255             {
11256               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11257                 cp_pedwarn ("template parameters cannot be friends");
11258               else if (TREE_CODE (type) == TYPENAME_TYPE)
11259                 cp_pedwarn ("\
11260 friend declaration requires class-key, i.e. `friend class %T::%T'",
11261                             constructor_name (current_class_type),
11262                             TYPE_IDENTIFIER (type));
11263               else
11264                 cp_pedwarn ("\
11265 friend declaration requires class-key, i.e. `friend %#T'",
11266                             type);
11267             }
11268
11269           /* Only try to do this stuff if we didn't already give up.  */
11270           if (type != integer_type_node)
11271             {
11272               /* A friendly class?  */
11273               if (current_class_type)
11274                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11275               else
11276                 cp_error ("trying to make class `%T' a friend of global scope",
11277                           type);
11278               type = void_type_node;
11279             }
11280         }
11281       else if (quals)
11282         {
11283           if (ctype == NULL_TREE)
11284             {
11285               if (TREE_CODE (type) != METHOD_TYPE)
11286                 cp_error ("invalid qualifiers on non-member function type");
11287               else
11288                 ctype = TYPE_METHOD_BASETYPE (type);
11289             }
11290           if (ctype)
11291             {
11292               tree dummy = build_decl (TYPE_DECL, declarator, type);
11293               grok_method_quals (ctype, dummy, quals);
11294               type = TREE_TYPE (dummy);
11295             }
11296         }
11297
11298       return type;
11299     }
11300   else if (declarator == NULL_TREE && decl_context != PARM
11301            && decl_context != CATCHPARM
11302            && TREE_CODE (type) != UNION_TYPE
11303            && ! bitfield)
11304     {
11305       cp_error ("abstract declarator `%T' used as declaration", type);
11306       declarator = make_anon_name ();
11307     }
11308
11309   /* `void' at top level (not within pointer)
11310      is allowed only in typedefs or type names.
11311      We don't complain about parms either, but that is because
11312      a better error message can be made later.  */
11313
11314   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11315     {
11316       if (! declarator)
11317         error ("unnamed variable or field declared void");
11318       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11319         {
11320           if (IDENTIFIER_OPNAME_P (declarator))
11321             my_friendly_abort (356);
11322           else
11323             error ("variable or field `%s' declared void", name);
11324         }
11325       else
11326         error ("variable or field declared void");
11327       type = integer_type_node;
11328     }
11329
11330   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11331      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11332
11333   if (decl_context == PARM || decl_context == CATCHPARM)
11334     {
11335       if (ctype || in_namespace)
11336         error ("cannot use `::' in parameter declaration");
11337
11338       /* A parameter declared as an array of T is really a pointer to T.
11339          One declared as a function is really a pointer to a function.
11340          One declared as a member is really a pointer to member.  */
11341
11342       if (TREE_CODE (type) == ARRAY_TYPE)
11343         {
11344           /* Transfer const-ness of array into that of type pointed to.  */
11345           type = build_pointer_type (TREE_TYPE (type));
11346           type_quals = TYPE_UNQUALIFIED;
11347         }
11348       else if (TREE_CODE (type) == FUNCTION_TYPE)
11349         type = build_pointer_type (type);
11350       else if (TREE_CODE (type) == OFFSET_TYPE)
11351         type = build_pointer_type (type);
11352       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11353         {
11354           error ("declaration of `%s' as void", name);
11355           return NULL_TREE;
11356         }
11357     }
11358
11359   {
11360     register tree decl;
11361
11362     if (decl_context == PARM)
11363       {
11364         decl = build_decl (PARM_DECL, declarator, type);
11365
11366         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11367                         inlinep, friendp, raises != NULL_TREE);
11368
11369         /* Compute the type actually passed in the parmlist,
11370            for the case where there is no prototype.
11371            (For example, shorts and chars are passed as ints.)
11372            When there is a prototype, this is overridden later.  */
11373
11374         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11375       }
11376     else if (decl_context == FIELD)
11377       {
11378         if (type == error_mark_node)
11379           {
11380             /* Happens when declaring arrays of sizes which
11381                are error_mark_node, for example.  */
11382             decl = NULL_TREE;
11383           }
11384         else if (in_namespace && !friendp)
11385           {
11386             /* Something like struct S { int N::j; };  */
11387             cp_error ("invalid use of `::'");
11388             decl = NULL_TREE;
11389           }
11390         else if (TREE_CODE (type) == FUNCTION_TYPE)
11391           {
11392             int publicp = 0;
11393             tree function_context;
11394
11395             /* We catch the others as conflicts with the builtin
11396                typedefs.  */
11397             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11398               {
11399                 cp_error ("function `%D' cannot be declared friend",
11400                           declarator);
11401                 friendp = 0;
11402               }
11403
11404             if (friendp == 0)
11405               {
11406                 if (ctype == NULL_TREE)
11407                   ctype = current_class_type;
11408
11409                 if (ctype == NULL_TREE)
11410                   {
11411                     cp_error ("can't make `%D' into a method -- not in a class",
11412                               declarator);
11413                     return void_type_node;
11414                   }
11415
11416                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11417                    ARM 9.5 */
11418                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11419                   {
11420                     cp_error ("function `%D' declared virtual inside a union",
11421                               declarator);
11422                     return void_type_node;
11423                   }
11424
11425                 if (declarator == ansi_opname (NEW_EXPR)
11426                     || declarator == ansi_opname (VEC_NEW_EXPR)
11427                     || declarator == ansi_opname (DELETE_EXPR)
11428                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11429                   {
11430                     if (virtualp)
11431                       {
11432                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11433                                   declarator);
11434                         virtualp = 0;
11435                       }
11436                   }
11437                 else if (staticp < 2)
11438                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11439                                                   TYPE_ARG_TYPES (type));
11440               }
11441
11442             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11443             function_context = (ctype != NULL_TREE) ?
11444               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11445             publicp = (! friendp || ! staticp)
11446               && function_context == NULL_TREE;
11447             decl = grokfndecl (ctype, type,
11448                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11449                                ? declarator : dname,
11450                                declarator,
11451                                virtualp, flags, quals, raises,
11452                                friendp ? -1 : 0, friendp, publicp, inlinep,
11453                                funcdef_flag, template_count, in_namespace);
11454             if (decl == NULL_TREE)
11455               return decl;
11456 #if 0
11457             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11458             /* The decl and setting of decl_machine_attr is also turned off.  */
11459             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11460 #endif
11461
11462             /* [class.conv.ctor]
11463
11464                A constructor declared without the function-specifier
11465                explicit that can be called with a single parameter
11466                specifies a conversion from the type of its first
11467                parameter to the type of its class.  Such a constructor
11468                is called a converting constructor.  */
11469             if (explicitp == 2)
11470               DECL_NONCONVERTING_P (decl) = 1;
11471             else if (DECL_CONSTRUCTOR_P (decl))
11472               {
11473                 /* The constructor can be called with exactly one
11474                    parameter if there is at least one parameter, and
11475                    any subsequent parameters have default arguments.
11476                    We don't look at the first parameter, which is
11477                    really just the `this' parameter for the new
11478                    object.  */
11479                 tree arg_types =
11480                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11481
11482                 /* Skip the `in_chrg' argument too, if present.  */
11483                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11484                   arg_types = TREE_CHAIN (arg_types);
11485
11486                 if (arg_types == void_list_node
11487                     || (arg_types
11488                         && TREE_CHAIN (arg_types)
11489                         && TREE_CHAIN (arg_types) != void_list_node
11490                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11491                   DECL_NONCONVERTING_P (decl) = 1;
11492               }
11493           }
11494         else if (TREE_CODE (type) == METHOD_TYPE)
11495           {
11496             /* We only get here for friend declarations of
11497                members of other classes.  */
11498             /* All method decls are public, so tell grokfndecl to set
11499                TREE_PUBLIC, also.  */
11500             decl = grokfndecl (ctype, type, declarator, declarator,
11501                                virtualp, flags, quals, raises,
11502                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11503                                template_count, in_namespace);
11504             if (decl == NULL_TREE)
11505               return NULL_TREE;
11506           }
11507         else if (!staticp && ! processing_template_decl
11508                  && !COMPLETE_TYPE_P (complete_type (type))
11509                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11510           {
11511             if (declarator)
11512               cp_error ("field `%D' has incomplete type", declarator);
11513             else
11514               cp_error ("name `%T' has incomplete type", type);
11515
11516             /* If we're instantiating a template, tell them which
11517                instantiation made the field's type be incomplete.  */
11518             if (current_class_type
11519                 && TYPE_NAME (current_class_type)
11520                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11521                 && declspecs && TREE_VALUE (declspecs)
11522                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11523               cp_error ("  in instantiation of template `%T'",
11524                         current_class_type);
11525
11526             type = error_mark_node;
11527             decl = NULL_TREE;
11528           }
11529         else
11530           {
11531             if (friendp)
11532               {
11533                 error ("`%s' is neither function nor member function; cannot be declared friend",
11534                        IDENTIFIER_POINTER (declarator));
11535                 friendp = 0;
11536               }
11537             decl = NULL_TREE;
11538           }
11539
11540         if (friendp)
11541           {
11542             /* Friends are treated specially.  */
11543             if (ctype == current_class_type)
11544               warning ("member functions are implicitly friends of their class");
11545             else
11546               {
11547                 tree t = NULL_TREE;
11548                 if (decl && DECL_NAME (decl))
11549                   {
11550                     if (template_class_depth (current_class_type) == 0)
11551                       {
11552                         decl
11553                           = check_explicit_specialization
11554                           (declarator, decl,
11555                            template_count, 2 * (funcdef_flag != 0) + 4);
11556                         if (decl == error_mark_node)
11557                           return error_mark_node;
11558                       }
11559
11560                     t = do_friend (ctype, declarator, decl,
11561                                    last_function_parms, attrlist, flags, quals,
11562                                    funcdef_flag);
11563                   }
11564                 if (t && funcdef_flag)
11565                   return t;
11566
11567                 return void_type_node;
11568               }
11569           }
11570
11571         /* Structure field.  It may not be a function, except for C++ */
11572
11573         if (decl == NULL_TREE)
11574           {
11575             if (initialized)
11576               {
11577                 if (!staticp)
11578                   {
11579                     /* An attempt is being made to initialize a non-static
11580                        member.  But, from [class.mem]:
11581
11582                        4 A member-declarator can contain a
11583                        constant-initializer only if it declares a static
11584                        member (_class.static_) of integral or enumeration
11585                        type, see _class.static.data_.
11586
11587                        This used to be relatively common practice, but
11588                        the rest of the compiler does not correctly
11589                        handle the initialization unless the member is
11590                        static so we make it static below.  */
11591                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11592                                 declarator);
11593                     cp_pedwarn ("making `%D' static", declarator);
11594                     staticp = 1;
11595                   }
11596
11597                 if (uses_template_parms (type))
11598                   /* We'll check at instantiation time.  */
11599                   ;
11600                 else if (check_static_variable_definition (declarator,
11601                                                            type))
11602                   /* If we just return the declaration, crashes
11603                      will sometimes occur.  We therefore return
11604                      void_type_node, as if this was a friend
11605                      declaration, to cause callers to completely
11606                      ignore this declaration.  */
11607                   return void_type_node;
11608               }
11609
11610             /* 9.2p13 [class.mem] */
11611             if (declarator == constructor_name (current_class_type)
11612                 /* The standard does not allow non-static data members
11613                    here either, but we agreed at the 10/99 meeting
11614                    to change that in TC 1 so that they are allowed in
11615                    classes with no user-defined constructors.  */
11616                 && staticp)
11617               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11618                           declarator);
11619
11620             if (staticp)
11621               {
11622                 /* C++ allows static class members.  All other work
11623                    for this is done by grokfield.  */
11624                 decl = build_lang_decl (VAR_DECL, declarator, type);
11625                 TREE_STATIC (decl) = 1;
11626                 /* In class context, 'static' means public access.  */
11627                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11628               }
11629             else
11630               {
11631                 decl = build_decl (FIELD_DECL, declarator, type);
11632                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11633                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11634                   {
11635                     DECL_MUTABLE_P (decl) = 1;
11636                     RIDBIT_RESET (RID_MUTABLE, specbits);
11637                   }
11638               }
11639
11640             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11641                             inlinep, friendp, raises != NULL_TREE);
11642           }
11643       }
11644     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11645       {
11646         tree original_name;
11647         int publicp = 0;
11648
11649         if (! declarator)
11650           return NULL_TREE;
11651
11652         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11653           original_name = dname;
11654         else
11655           original_name = declarator;
11656
11657         if (RIDBIT_SETP (RID_AUTO, specbits))
11658           error ("storage class `auto' invalid for function `%s'", name);
11659         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11660           error ("storage class `register' invalid for function `%s'", name);
11661
11662         /* Function declaration not at top level.
11663            Storage classes other than `extern' are not allowed
11664            and `extern' makes no difference.  */
11665         if (! toplevel_bindings_p ()
11666             && (RIDBIT_SETP (RID_STATIC, specbits)
11667                 || RIDBIT_SETP (RID_INLINE, specbits))
11668             && pedantic)
11669           {
11670             if (RIDBIT_SETP (RID_STATIC, specbits))
11671               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11672             else
11673               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11674           }
11675
11676         if (ctype == NULL_TREE)
11677           {
11678             if (virtualp)
11679               {
11680                 error ("virtual non-class function `%s'", name);
11681                 virtualp = 0;
11682               }
11683           }
11684         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11685           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11686                                           TYPE_ARG_TYPES (type));
11687
11688         /* Record presence of `static'.  */
11689         publicp = (ctype != NULL_TREE
11690                    || RIDBIT_SETP (RID_EXTERN, specbits)
11691                    || !RIDBIT_SETP (RID_STATIC, specbits));
11692
11693         decl = grokfndecl (ctype, type, original_name, declarator,
11694                            virtualp, flags, quals, raises,
11695                            1, friendp,
11696                            publicp, inlinep, funcdef_flag,
11697                            template_count, in_namespace);
11698         if (decl == NULL_TREE)
11699           return NULL_TREE;
11700
11701         if (staticp == 1)
11702           {
11703             int illegal_static = 0;
11704
11705             /* Don't allow a static member function in a class, and forbid
11706                declaring main to be static.  */
11707             if (TREE_CODE (type) == METHOD_TYPE)
11708               {
11709                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11710                 illegal_static = 1;
11711               }
11712             else if (current_function_decl)
11713               {
11714                 /* FIXME need arm citation */
11715                 error ("cannot declare static function inside another function");
11716                 illegal_static = 1;
11717               }
11718
11719             if (illegal_static)
11720               {
11721                 staticp = 0;
11722                 RIDBIT_RESET (RID_STATIC, specbits);
11723               }
11724           }
11725       }
11726     else
11727       {
11728         /* It's a variable.  */
11729
11730         /* An uninitialized decl with `extern' is a reference.  */
11731         decl = grokvardecl (type, declarator, &specbits,
11732                             initialized,
11733                             (type_quals & TYPE_QUAL_CONST) != 0,
11734                             in_namespace);
11735         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11736                         inlinep, friendp, raises != NULL_TREE);
11737
11738         if (ctype)
11739           {
11740             DECL_CONTEXT (decl) = ctype;
11741             if (staticp == 1)
11742               {
11743                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11744                 staticp = 0;
11745                 RIDBIT_RESET (RID_STATIC, specbits);
11746               }
11747             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11748               {
11749                 cp_error ("static member `%D' declared `register'", decl);
11750                 RIDBIT_RESET (RID_REGISTER, specbits);
11751               }
11752             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11753               {
11754                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11755                             decl);
11756                 RIDBIT_RESET (RID_EXTERN, specbits);
11757               }
11758           }
11759       }
11760
11761     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11762
11763     /* Record `register' declaration for warnings on &
11764        and in case doing stupid register allocation.  */
11765
11766     if (RIDBIT_SETP (RID_REGISTER, specbits))
11767       DECL_REGISTER (decl) = 1;
11768
11769     if (RIDBIT_SETP (RID_EXTERN, specbits))
11770       DECL_THIS_EXTERN (decl) = 1;
11771
11772     if (RIDBIT_SETP (RID_STATIC, specbits))
11773       DECL_THIS_STATIC (decl) = 1;
11774
11775     /* Record constancy and volatility.  There's no need to do this
11776        when processing a template; we'll do this for the instantiated
11777        declaration based on the type of DECL.  */
11778     if (!processing_template_decl)
11779       c_apply_type_quals_to_decl (type_quals, decl);
11780
11781     return decl;
11782   }
11783 }
11784 \f
11785 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11786    An empty exprlist is a parmlist.  An exprlist which
11787    contains only identifiers at the global level
11788    is a parmlist.  Otherwise, it is an exprlist.  */
11789
11790 int
11791 parmlist_is_exprlist (exprs)
11792      tree exprs;
11793 {
11794   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11795     return 0;
11796
11797   if (toplevel_bindings_p ())
11798     {
11799       /* At the global level, if these are all identifiers,
11800          then it is a parmlist.  */
11801       while (exprs)
11802         {
11803           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11804             return 1;
11805           exprs = TREE_CHAIN (exprs);
11806         }
11807       return 0;
11808     }
11809   return 1;
11810 }
11811
11812 /* Subroutine of start_function.  Ensure that each of the parameter
11813    types (as listed in PARMS) is complete, as is required for a
11814    function definition.  */
11815
11816 static void
11817 require_complete_types_for_parms (parms)
11818      tree parms;
11819 {
11820   for (; parms; parms = TREE_CHAIN (parms))
11821     {
11822       tree type = TREE_TYPE (parms);
11823
11824       /* Try to complete the TYPE.  */
11825       type = complete_type (type);
11826
11827       if (type == error_mark_node)
11828         continue;
11829
11830       if (!COMPLETE_TYPE_P (type))
11831         {
11832           if (DECL_NAME (parms))
11833             error ("parameter `%s' has incomplete type",
11834                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11835           else
11836             error ("parameter has incomplete type");
11837           TREE_TYPE (parms) = error_mark_node;
11838         }
11839       else
11840         layout_decl (parms, 0);
11841     }
11842 }
11843
11844 /* Returns non-zero if T is a local variable.  */
11845
11846 int
11847 local_variable_p (t)
11848      tree t;
11849 {
11850   if ((TREE_CODE (t) == VAR_DECL
11851        /* A VAR_DECL with a context that is a _TYPE is a static data
11852           member.  */
11853        && !TYPE_P (CP_DECL_CONTEXT (t))
11854        /* Any other non-local variable must be at namespace scope.  */
11855        && !DECL_NAMESPACE_SCOPE_P (t))
11856       || (TREE_CODE (t) == PARM_DECL))
11857     return 1;
11858
11859   return 0;
11860 }
11861
11862 /* Returns non-zero if T is an automatic local variable or a label.
11863    (These are the declarations that need to be remapped when the code
11864    containing them is duplicated.)  */
11865
11866 int
11867 nonstatic_local_decl_p (t)
11868      tree t;
11869 {
11870   return ((local_variable_p (t) && !TREE_STATIC (t))
11871           || TREE_CODE (t) == LABEL_DECL
11872           || TREE_CODE (t) == RESULT_DECL);
11873 }
11874
11875 /* Like local_variable_p, but suitable for use as a tree-walking
11876    function.  */
11877
11878 static tree
11879 local_variable_p_walkfn (tp, walk_subtrees, data)
11880      tree *tp;
11881      int *walk_subtrees ATTRIBUTE_UNUSED;
11882      void *data ATTRIBUTE_UNUSED;
11883 {
11884   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11885           ? *tp : NULL_TREE);
11886 }
11887
11888 /* Check that ARG, which is a default-argument expression for a
11889    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11890    something goes wrong.  DECL may also be a _TYPE node, rather than a
11891    DECL, if there is no DECL available.  */
11892
11893 tree
11894 check_default_argument (decl, arg)
11895      tree decl;
11896      tree arg;
11897 {
11898   tree var;
11899   tree decl_type;
11900
11901   if (TREE_CODE (arg) == DEFAULT_ARG)
11902     /* We get a DEFAULT_ARG when looking at an in-class declaration
11903        with a default argument.  Ignore the argument for now; we'll
11904        deal with it after the class is complete.  */
11905     return arg;
11906
11907   if (processing_template_decl || uses_template_parms (arg))
11908     /* We don't do anything checking until instantiation-time.  Note
11909        that there may be uninstantiated arguments even for an
11910        instantiated function, since default arguments are not
11911        instantiated until they are needed.  */
11912     return arg;
11913
11914   if (TYPE_P (decl))
11915     {
11916       decl_type = decl;
11917       decl = NULL_TREE;
11918     }
11919   else
11920     decl_type = TREE_TYPE (decl);
11921
11922   if (arg == error_mark_node
11923       || decl == error_mark_node
11924       || TREE_TYPE (arg) == error_mark_node
11925       || decl_type == error_mark_node)
11926     /* Something already went wrong.  There's no need to check
11927        further.  */
11928     return error_mark_node;
11929
11930   /* [dcl.fct.default]
11931
11932      A default argument expression is implicitly converted to the
11933      parameter type.  */
11934   if (!TREE_TYPE (arg)
11935       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11936     {
11937       if (decl)
11938         cp_error ("default argument for `%#D' has type `%T'",
11939                   decl, TREE_TYPE (arg));
11940       else
11941         cp_error ("default argument for parameter of type `%T' has type `%T'",
11942                   decl_type, TREE_TYPE (arg));
11943
11944       return error_mark_node;
11945     }
11946
11947   /* [dcl.fct.default]
11948
11949      Local variables shall not be used in default argument
11950      expressions.
11951
11952      The keyword `this' shall not be used in a default argument of a
11953      member function.  */
11954   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11955                                       NULL);
11956   if (var)
11957     {
11958       cp_error ("default argument `%E' uses local variable `%D'",
11959                 arg, var);
11960       return error_mark_node;
11961     }
11962
11963   /* All is well.  */
11964   return arg;
11965 }
11966
11967 /* Decode the list of parameter types for a function type.
11968    Given the list of things declared inside the parens,
11969    return a list of types.
11970
11971    The list we receive can have three kinds of elements:
11972    an IDENTIFIER_NODE for names given without types,
11973    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11974    or void_type_node, to mark the end of an argument list
11975    when additional arguments are not permitted (... was not used).
11976
11977    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11978    a mere declaration.  A nonempty identifier-list gets an error message
11979    when FUNCDEF_FLAG is zero.
11980    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11981    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11982
11983    If all elements of the input list contain types,
11984    we return a list of the types.
11985    If all elements contain no type (except perhaps a void_type_node
11986    at the end), we return a null list.
11987    If some have types and some do not, it is an error, and we
11988    return a null list.
11989
11990    Also set last_function_parms to either
11991    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11992    A list of names is converted to a chain of PARM_DECLs
11993    by store_parm_decls so that ultimately it is always a chain of decls.
11994
11995    Note that in C++, parameters can take default values.  These default
11996    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11997    an error to specify default values which are followed by parameters
11998    that have no default values, or an ELLIPSES.  For simplicities sake,
11999    only parameters which are specified with their types can take on
12000    default values.  */
12001
12002 static tree
12003 grokparms (first_parm, funcdef_flag)
12004      tree first_parm;
12005      int funcdef_flag;
12006 {
12007   tree result = NULL_TREE;
12008   tree decls = NULL_TREE;
12009
12010   if (first_parm != NULL_TREE
12011       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12012     {
12013       if (! funcdef_flag)
12014         pedwarn ("parameter names (without types) in function declaration");
12015       last_function_parms = first_parm;
12016       return NULL_TREE;
12017     }
12018   else if (first_parm != NULL_TREE
12019            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12020            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12021     my_friendly_abort (145);
12022   else
12023     {
12024       /* Types were specified.  This is a list of declarators
12025          each represented as a TREE_LIST node.  */
12026       register tree parm, chain;
12027       int any_init = 0, any_error = 0;
12028
12029       if (first_parm != NULL_TREE)
12030         {
12031           tree last_result = NULL_TREE;
12032           tree last_decl = NULL_TREE;
12033
12034           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12035             {
12036               tree type = NULL_TREE, list_node = parm;
12037               register tree decl = TREE_VALUE (parm);
12038               tree init = TREE_PURPOSE (parm);
12039
12040               chain = TREE_CHAIN (parm);
12041               /* @@ weak defense against parse errors.  */
12042               if (TREE_CODE (decl) != VOID_TYPE
12043                   && TREE_CODE (decl) != TREE_LIST)
12044                 {
12045                   /* Give various messages as the need arises.  */
12046                   if (TREE_CODE (decl) == STRING_CST)
12047                     cp_error ("invalid string constant `%E'", decl);
12048                   else if (TREE_CODE (decl) == INTEGER_CST)
12049                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12050                   continue;
12051                 }
12052
12053               if (TREE_CODE (decl) != VOID_TYPE)
12054                 {
12055                   decl = grokdeclarator (TREE_VALUE (decl),
12056                                          TREE_PURPOSE (decl),
12057                                          PARM, init != NULL_TREE,
12058                                          NULL_TREE);
12059                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12060                     continue;
12061
12062                   /* Top-level qualifiers on the parameters are
12063                      ignored for function types.  */
12064                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12065
12066                   if (TREE_CODE (type) == VOID_TYPE)
12067                     decl = void_type_node;
12068                   else if (TREE_CODE (type) == METHOD_TYPE)
12069                     {
12070                       if (DECL_NAME (decl))
12071                         /* Cannot use the decl here because
12072                            we don't have DECL_CONTEXT set up yet.  */
12073                         cp_error ("parameter `%D' invalidly declared method type",
12074                                   DECL_NAME (decl));
12075                       else
12076                         error ("parameter invalidly declared method type");
12077                       type = build_pointer_type (type);
12078                       TREE_TYPE (decl) = type;
12079                     }
12080                   else if (TREE_CODE (type) == OFFSET_TYPE)
12081                     {
12082                       if (DECL_NAME (decl))
12083                         cp_error ("parameter `%D' invalidly declared offset type",
12084                                   DECL_NAME (decl));
12085                       else
12086                         error ("parameter invalidly declared offset type");
12087                       type = build_pointer_type (type);
12088                       TREE_TYPE (decl) = type;
12089                     }
12090                   else if (abstract_virtuals_error (decl, type))
12091                     any_error = 1;  /* Seems like a good idea. */
12092                   else if (POINTER_TYPE_P (type))
12093                     {
12094                       tree t = type;
12095                       while (POINTER_TYPE_P (t)
12096                              || (TREE_CODE (t) == ARRAY_TYPE
12097                                  && TYPE_DOMAIN (t) != NULL_TREE))
12098                         t = TREE_TYPE (t);
12099                       if (TREE_CODE (t) == ARRAY_TYPE)
12100                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12101                                   type,
12102                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12103                     }
12104                 }
12105
12106               if (TREE_CODE (decl) == VOID_TYPE)
12107                 {
12108                   if (result == NULL_TREE)
12109                     {
12110                       result = void_list_node;
12111                       last_result = result;
12112                     }
12113                   else
12114                     {
12115                       TREE_CHAIN (last_result) = void_list_node;
12116                       last_result = void_list_node;
12117                     }
12118                   if (chain
12119                       && (chain != void_list_node || TREE_CHAIN (chain)))
12120                     error ("`void' in parameter list must be entire list");
12121                   break;
12122                 }
12123
12124               /* Since there is a prototype, args are passed in their own types.  */
12125               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12126               if (PROMOTE_PROTOTYPES
12127                   && (TREE_CODE (type) == INTEGER_TYPE
12128                       || TREE_CODE (type) == ENUMERAL_TYPE)
12129                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12130                 DECL_ARG_TYPE (decl) = integer_type_node;
12131               if (!any_error && init)
12132                 {
12133                   any_init++;
12134                   init = check_default_argument (decl, init);
12135                 }
12136               else
12137                 init = NULL_TREE;
12138
12139               if (decls == NULL_TREE)
12140                 {
12141                   decls = decl;
12142                   last_decl = decls;
12143                 }
12144               else
12145                 {
12146                   TREE_CHAIN (last_decl) = decl;
12147                   last_decl = decl;
12148                 }
12149               list_node = tree_cons (init, type, NULL_TREE);
12150               if (result == NULL_TREE)
12151                 {
12152                   result = list_node;
12153                   last_result = result;
12154                 }
12155               else
12156                 {
12157                   TREE_CHAIN (last_result) = list_node;
12158                   last_result = list_node;
12159                 }
12160             }
12161           if (last_result)
12162             TREE_CHAIN (last_result) = NULL_TREE;
12163           /* If there are no parameters, and the function does not end
12164              with `...', then last_decl will be NULL_TREE.  */
12165           if (last_decl != NULL_TREE)
12166             TREE_CHAIN (last_decl) = NULL_TREE;
12167         }
12168     }
12169
12170   last_function_parms = decls;
12171
12172   return result;
12173 }
12174
12175 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12176    FUNCTION_TYPE with the newly parsed version of its default argument, which
12177    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12178
12179 void
12180 replace_defarg (arg, init)
12181      tree arg, init;
12182 {
12183   if (! processing_template_decl
12184       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12185     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12186                 TREE_TYPE (init), TREE_VALUE (arg));
12187   TREE_PURPOSE (arg) = init;
12188 }
12189 \f
12190 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12191    D's arguments allow it to be a copy constructor, or copy assignment
12192    operator.  */
12193
12194 int
12195 copy_args_p (d)
12196      tree d;
12197 {
12198   tree t;
12199
12200   if (!DECL_FUNCTION_MEMBER_P (d))
12201     return 0;
12202
12203   t = FUNCTION_ARG_CHAIN (d);
12204   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12205     t = TREE_CHAIN (t);
12206   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12207       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12208           == DECL_CONTEXT (d))
12209       && (TREE_CHAIN (t) == NULL_TREE
12210           || TREE_CHAIN (t) == void_list_node
12211           || TREE_PURPOSE (TREE_CHAIN (t))))
12212     return 1;
12213   return 0;
12214 }
12215
12216 /* These memoizing functions keep track of special properties which
12217    a class may have.  `grok_ctor_properties' notices whether a class
12218    has a constructor of the form X(X&), and also complains
12219    if the class has a constructor of the form X(X).
12220    `grok_op_properties' takes notice of the various forms of
12221    operator= which are defined, as well as what sorts of type conversion
12222    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12223
12224 int
12225 grok_ctor_properties (ctype, decl)
12226      tree ctype, decl;
12227 {
12228   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12229   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12230
12231   /* When a type has virtual baseclasses, a magical first int argument is
12232      added to any ctor so we can tell if the class has been initialized
12233      yet.  This could screw things up in this function, so we deliberately
12234      ignore the leading int if we're in that situation.  */
12235   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12236     {
12237       my_friendly_assert (parmtypes
12238                           && TREE_VALUE (parmtypes) == integer_type_node,
12239                           980529);
12240       parmtypes = TREE_CHAIN (parmtypes);
12241       parmtype = TREE_VALUE (parmtypes);
12242     }
12243
12244   /* [class.copy]
12245
12246      A non-template constructor for class X is a copy constructor if
12247      its first parameter is of type X&, const X&, volatile X& or const
12248      volatile X&, and either there are no other parameters or else all
12249      other parameters have default arguments.  */
12250   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12251       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12252       && (TREE_CHAIN (parmtypes) == NULL_TREE
12253           || TREE_CHAIN (parmtypes) == void_list_node
12254           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12255       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12256            && is_member_template (DECL_TI_TEMPLATE (decl))))
12257     {
12258       TYPE_HAS_INIT_REF (ctype) = 1;
12259       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12260         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12261     }
12262   /* [class.copy]
12263
12264      A declaration of a constructor for a class X is ill-formed if its
12265      first parameter is of type (optionally cv-qualified) X and either
12266      there are no other parameters or else all other parameters have
12267      default arguments.
12268
12269      We *don't* complain about member template instantiations that
12270      have this form, though; they can occur as we try to decide what
12271      constructor to use during overload resolution.  Since overload
12272      resolution will never prefer such a constructor to the
12273      non-template copy constructor (which is either explicitly or
12274      implicitly defined), there's no need to worry about their
12275      existence.  Theoretically, they should never even be
12276      instantiated, but that's hard to forestall.  */
12277   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12278            && (TREE_CHAIN (parmtypes) == NULL_TREE
12279                || TREE_CHAIN (parmtypes) == void_list_node
12280                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12281            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12282                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12283     {
12284       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12285                 ctype, ctype);
12286       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12287       return 0;
12288     }
12289   else if (TREE_CODE (parmtype) == VOID_TYPE
12290            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12291     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12292
12293   return 1;
12294 }
12295
12296 /* An operator with this code is unary, but can also be binary.  */
12297
12298 static int
12299 ambi_op_p (code)
12300      enum tree_code code;
12301 {
12302   return (code == INDIRECT_REF
12303           || code == ADDR_EXPR
12304           || code == CONVERT_EXPR
12305           || code == NEGATE_EXPR
12306           || code == PREINCREMENT_EXPR
12307           || code == PREDECREMENT_EXPR);
12308 }
12309
12310 /* An operator with this name can only be unary.  */
12311
12312 static int
12313 unary_op_p (code)
12314      enum tree_code code;
12315 {
12316   return (code == TRUTH_NOT_EXPR
12317           || code == BIT_NOT_EXPR
12318           || code == COMPONENT_REF
12319           || code == TYPE_EXPR);
12320 }
12321
12322 /* Do a little sanity-checking on how they declared their operator.  */
12323
12324 void
12325 grok_op_properties (decl, virtualp, friendp)
12326      tree decl;
12327      int virtualp, friendp;
12328 {
12329   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12330   tree argtype;
12331   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12332   tree name = DECL_NAME (decl);
12333   enum tree_code operator_code;
12334   int arity;
12335
12336   /* Count the number of arguments.  */
12337   for (argtype = argtypes, arity = 0;
12338        argtype && argtype != void_list_node;
12339        argtype = TREE_CHAIN (argtype))
12340     ++arity;
12341
12342   if (current_class_type == NULL_TREE)
12343     friendp = 1;
12344
12345   if (DECL_CONV_FN_P (decl))
12346     operator_code = TYPE_EXPR;
12347   else
12348     do
12349       {
12350 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12351         if (ansi_opname (CODE) == name)                                     \
12352           {                                                                 \
12353             operator_code = CODE;                                           \
12354             break;                                                          \
12355           }                                                                 \
12356         else if (ansi_assopname (CODE) == name)                             \
12357           {                                                                 \
12358             operator_code = CODE;                                           \
12359             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12360             break;                                                          \
12361           }
12362
12363 #include "operators.def"
12364 #undef DEF_OPERATOR
12365
12366         my_friendly_abort (20000527);
12367       }
12368     while (0);
12369   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12370   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12371
12372   if (! friendp)
12373     {
12374       switch (operator_code)
12375         {
12376         case CALL_EXPR:
12377           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12378           break;
12379
12380         case ARRAY_REF:
12381           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12382           break;
12383
12384         case COMPONENT_REF:
12385         case MEMBER_REF:
12386           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12387           break;
12388
12389         case NEW_EXPR:
12390           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12391           break;
12392
12393         case DELETE_EXPR:
12394           TYPE_GETS_DELETE (current_class_type) |= 1;
12395           break;
12396
12397         case VEC_NEW_EXPR:
12398           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12399           break;
12400
12401         case VEC_DELETE_EXPR:
12402           TYPE_GETS_DELETE (current_class_type) |= 2;
12403           break;
12404
12405         default:
12406           break;
12407         }
12408     }
12409
12410   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12411     {
12412       /* When the compiler encounters the definition of A::operator new, it
12413          doesn't look at the class declaration to find out if it's static.  */
12414       if (methodp)
12415         revert_static_member_fn (decl);
12416
12417       /* Take care of function decl if we had syntax errors.  */
12418       if (argtypes == NULL_TREE)
12419         TREE_TYPE (decl)
12420           = build_function_type (ptr_type_node,
12421                                  hash_tree_chain (integer_type_node,
12422                                                   void_list_node));
12423       else
12424         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12425     }
12426   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12427     {
12428       if (methodp)
12429         revert_static_member_fn (decl);
12430
12431       if (argtypes == NULL_TREE)
12432         TREE_TYPE (decl)
12433           = build_function_type (void_type_node,
12434                                  hash_tree_chain (ptr_type_node,
12435                                                   void_list_node));
12436       else
12437         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12438     }
12439   else
12440     {
12441       /* An operator function must either be a non-static member function
12442          or have at least one parameter of a class, a reference to a class,
12443          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12444       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12445         {
12446           if (operator_code == TYPE_EXPR
12447               || operator_code == CALL_EXPR
12448               || operator_code == COMPONENT_REF
12449               || operator_code == ARRAY_REF
12450               || operator_code == NOP_EXPR)
12451             cp_error ("`%D' must be a nonstatic member function", decl);
12452           else
12453             {
12454               tree p = argtypes;
12455
12456               if (DECL_STATIC_FUNCTION_P (decl))
12457                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12458
12459               if (p)
12460                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12461                   {
12462                     tree arg = TREE_VALUE (p);
12463                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12464                       arg = TREE_TYPE (arg);
12465
12466                     /* This lets bad template code slip through.  */
12467                     if (IS_AGGR_TYPE (arg)
12468                         || TREE_CODE (arg) == ENUMERAL_TYPE
12469                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12470                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12471                       goto foundaggr;
12472                   }
12473               cp_error
12474                 ("`%D' must have an argument of class or enumerated type",
12475                  decl);
12476             foundaggr:
12477               ;
12478             }
12479         }
12480
12481       if (operator_code == CALL_EXPR)
12482         return;                 /* No restrictions on args. */
12483
12484       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12485         {
12486           tree t = TREE_TYPE (name);
12487           if (! friendp)
12488             {
12489               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12490               const char *what = 0;
12491
12492               if (ref)
12493                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12494
12495               if (TREE_CODE (t) == VOID_TYPE)
12496                 what = "void";
12497               else if (t == current_class_type)
12498                 what = "the same type";
12499               /* Don't force t to be complete here.  */
12500               else if (IS_AGGR_TYPE (t)
12501                        && COMPLETE_TYPE_P (t)
12502                        && DERIVED_FROM_P (t, current_class_type))
12503                 what = "a base class";
12504
12505               if (what)
12506                 warning ("conversion to %s%s will never use a type conversion operator",
12507                          ref ? "a reference to " : "", what);
12508             }
12509         }
12510
12511       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12512           && operator_code == NOP_EXPR)
12513         {
12514           tree parmtype;
12515
12516           if (arity != 2 && methodp)
12517             {
12518               cp_error ("`%D' must take exactly one argument", decl);
12519               return;
12520             }
12521           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12522
12523           /* [class.copy]
12524
12525              A user-declared copy assignment operator X::operator= is
12526              a non-static non-template member function of class X with
12527              exactly one parameter of type X, X&, const X&, volatile
12528              X& or const volatile X&.  */
12529           if (copy_assignment_arg_p (parmtype, virtualp)
12530               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12531                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12532               && ! friendp)
12533             {
12534               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12535               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12536                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12537                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12538             }
12539         }
12540       else if (operator_code == COND_EXPR)
12541         {
12542           /* 13.4.0.3 */
12543           cp_error ("ISO C++ prohibits overloading operator ?:");
12544         }
12545       else if (ambi_op_p (operator_code))
12546         {
12547           if (arity == 1)
12548             /* We pick the one-argument operator codes by default, so
12549                we don't have to change anything.  */
12550             ;
12551           else if (arity == 2)
12552             {
12553               /* If we thought this was a unary operator, we now know
12554                  it to be a binary operator.  */
12555               switch (operator_code)
12556                 {
12557                 case INDIRECT_REF:
12558                   operator_code = MULT_EXPR;
12559                   break;
12560
12561                 case ADDR_EXPR:
12562                   operator_code = BIT_AND_EXPR;
12563                   break;
12564
12565                 case CONVERT_EXPR:
12566                   operator_code = PLUS_EXPR;
12567                   break;
12568
12569                 case NEGATE_EXPR:
12570                   operator_code = MINUS_EXPR;
12571                   break;
12572
12573                 case PREINCREMENT_EXPR:
12574                   operator_code = POSTINCREMENT_EXPR;
12575                   break;
12576
12577                 case PREDECREMENT_EXPR:
12578                   operator_code = POSTDECREMENT_EXPR;
12579                   break;
12580
12581                 default:
12582                   my_friendly_abort (20000527);
12583                 }
12584
12585               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12586
12587               if ((operator_code == POSTINCREMENT_EXPR
12588                    || operator_code == POSTDECREMENT_EXPR)
12589                   && ! processing_template_decl
12590                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12591                 {
12592                   if (methodp)
12593                     cp_error ("postfix `%D' must take `int' as its argument",
12594                               decl);
12595                   else
12596                     cp_error
12597                       ("postfix `%D' must take `int' as its second argument",
12598                        decl);
12599                 }
12600             }
12601           else
12602             {
12603               if (methodp)
12604                 cp_error ("`%D' must take either zero or one argument", decl);
12605               else
12606                 cp_error ("`%D' must take either one or two arguments", decl);
12607             }
12608
12609           /* More Effective C++ rule 6.  */
12610           if (warn_ecpp
12611               && (operator_code == POSTINCREMENT_EXPR
12612                   || operator_code == POSTDECREMENT_EXPR
12613                   || operator_code == PREINCREMENT_EXPR
12614                   || operator_code == PREDECREMENT_EXPR))
12615             {
12616               tree arg = TREE_VALUE (argtypes);
12617               tree ret = TREE_TYPE (TREE_TYPE (decl));
12618               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12619                 arg = TREE_TYPE (arg);
12620               arg = TYPE_MAIN_VARIANT (arg);
12621               if (operator_code == PREINCREMENT_EXPR
12622                   || operator_code == PREDECREMENT_EXPR)
12623                 {
12624                   if (TREE_CODE (ret) != REFERENCE_TYPE
12625                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12626                                        arg))
12627                     cp_warning ("prefix `%D' should return `%T'", decl,
12628                                 build_reference_type (arg));
12629                 }
12630               else
12631                 {
12632                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12633                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12634                 }
12635             }
12636         }
12637       else if (unary_op_p (operator_code))
12638         {
12639           if (arity != 1)
12640             {
12641               if (methodp)
12642                 cp_error ("`%D' must take `void'", decl);
12643               else
12644                 cp_error ("`%D' must take exactly one argument", decl);
12645             }
12646         }
12647       else /* if (binary_op_p (operator_code)) */
12648         {
12649           if (arity != 2)
12650             {
12651               if (methodp)
12652                 cp_error ("`%D' must take exactly one argument", decl);
12653               else
12654                 cp_error ("`%D' must take exactly two arguments", decl);
12655             }
12656
12657           /* More Effective C++ rule 7.  */
12658           if (warn_ecpp
12659               && (operator_code == TRUTH_ANDIF_EXPR
12660                   || operator_code == TRUTH_ORIF_EXPR
12661                   || operator_code == COMPOUND_EXPR))
12662             cp_warning ("user-defined `%D' always evaluates both arguments",
12663                         decl);
12664         }
12665
12666       /* Effective C++ rule 23.  */
12667       if (warn_ecpp
12668           && arity == 2
12669           && (operator_code == PLUS_EXPR
12670               || operator_code == MINUS_EXPR
12671               || operator_code == TRUNC_DIV_EXPR
12672               || operator_code == MULT_EXPR)
12673           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12674         cp_warning ("`%D' should return by value", decl);
12675
12676       /* 13.4.0.8 */
12677       for (; argtypes && argtypes != void_list_node;
12678           argtypes = TREE_CHAIN (argtypes))
12679         if (TREE_PURPOSE (argtypes))
12680           {
12681             TREE_PURPOSE (argtypes) = NULL_TREE;
12682             if (operator_code == POSTINCREMENT_EXPR
12683                 || operator_code == POSTDECREMENT_EXPR)
12684               {
12685                 if (pedantic)
12686                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12687               }
12688             else
12689               cp_error ("`%D' cannot have default arguments", decl);
12690           }
12691
12692     }
12693 }
12694 \f
12695 static const char *
12696 tag_name (code)
12697      enum tag_types code;
12698 {
12699   switch (code)
12700     {
12701     case record_type:
12702       return "struct";
12703     case class_type:
12704       return "class";
12705     case union_type:
12706       return "union ";
12707     case enum_type:
12708       return "enum";
12709     default:
12710       my_friendly_abort (981122);
12711     }
12712 }
12713
12714 /* Get the struct, enum or union (CODE says which) with tag NAME.
12715    Define the tag as a forward-reference if it is not defined.
12716
12717    C++: If a class derivation is given, process it here, and report
12718    an error if multiple derivation declarations are not identical.
12719
12720    If this is a definition, come in through xref_tag and only look in
12721    the current frame for the name (since C++ allows new names in any
12722    scope.)  */
12723
12724 tree
12725 xref_tag (code_type_node, name, globalize)
12726      tree code_type_node;
12727      tree name;
12728      int globalize;
12729 {
12730   enum tag_types tag_code;
12731   enum tree_code code;
12732   register tree ref, t;
12733   struct binding_level *b = current_binding_level;
12734   int got_type = 0;
12735   tree attributes = NULL_TREE;
12736   tree context = NULL_TREE;
12737
12738   /* If we are called from the parser, code_type_node will sometimes be a
12739      TREE_LIST.  This indicates that the user wrote
12740      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12741      use them later.  */
12742   if (TREE_CODE (code_type_node) == TREE_LIST)
12743     {
12744       attributes = TREE_PURPOSE (code_type_node);
12745       code_type_node = TREE_VALUE (code_type_node);
12746     }
12747
12748   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12749   switch (tag_code)
12750     {
12751     case record_type:
12752     case class_type:
12753       code = RECORD_TYPE;
12754       break;
12755     case union_type:
12756       code = UNION_TYPE;
12757       break;
12758     case enum_type:
12759       code = ENUMERAL_TYPE;
12760       break;
12761     default:
12762       my_friendly_abort (18);
12763     }
12764
12765   /* If a cross reference is requested, look up the type
12766      already defined for this tag and return it.  */
12767   if (TYPE_P (name))
12768     {
12769       t = name;
12770       name = TYPE_IDENTIFIER (t);
12771       got_type = 1;
12772     }
12773   else
12774     t = IDENTIFIER_TYPE_VALUE (name);
12775
12776   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12777   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12778     {
12779       static int explained;
12780
12781       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12782 to refer to the inherited type, say `%s %T::%T'%s",
12783                   tag_name (tag_code), name, tag_name (tag_code),
12784                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12785                   (!explained ? "\n\
12786 (names from dependent base classes are not visible to unqualified name lookup)"
12787                    : ""));
12788
12789       explained = 1;
12790     }
12791
12792   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12793       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12794     t = NULL_TREE;
12795
12796   if (! globalize)
12797     {
12798       /* If we know we are defining this tag, only look it up in
12799          this scope and don't try to find it as a type.  */
12800       ref = lookup_tag (code, name, b, 1);
12801     }
12802   else
12803     {
12804       if (t)
12805         {
12806           /* [dcl.type.elab] If the identifier resolves to a
12807              typedef-name or a template type-parameter, the
12808              elaborated-type-specifier is ill-formed.  */
12809           if (t != TYPE_MAIN_VARIANT (t)
12810               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12811             cp_pedwarn ("using typedef-name `%D' after `%s'",
12812                         TYPE_NAME (t), tag_name (tag_code));
12813           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12814             cp_error ("using template type parameter `%T' after `%s'",
12815                       t, tag_name (tag_code));
12816
12817           ref = t;
12818         }
12819       else
12820         ref = lookup_tag (code, name, b, 0);
12821
12822       if (! ref)
12823         {
12824           /* Try finding it as a type declaration.  If that wins,
12825              use it.  */
12826           ref = lookup_name (name, 1);
12827
12828           if (ref != NULL_TREE
12829               && processing_template_decl
12830               && DECL_CLASS_TEMPLATE_P (ref)
12831               && template_class_depth (current_class_type) == 0)
12832             /* Since GLOBALIZE is true, we're declaring a global
12833                template, so we want this type.  */
12834             ref = DECL_TEMPLATE_RESULT (ref);
12835
12836           if (ref && TREE_CODE (ref) == TYPE_DECL
12837               && TREE_CODE (TREE_TYPE (ref)) == code)
12838             ref = TREE_TYPE (ref);
12839           else
12840             ref = NULL_TREE;
12841         }
12842
12843       if (ref && current_class_type
12844           && template_class_depth (current_class_type)
12845           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12846         {
12847           /* Since GLOBALIZE is non-zero, we are not looking at a
12848              definition of this tag.  Since, in addition, we are currently
12849              processing a (member) template declaration of a template
12850              class, we must be very careful; consider:
12851
12852                template <class X>
12853                struct S1
12854
12855                template <class U>
12856                struct S2
12857                { template <class V>
12858                friend struct S1; };
12859
12860              Here, the S2::S1 declaration should not be confused with the
12861              outer declaration.  In particular, the inner version should
12862              have a template parameter of level 2, not level 1.  This
12863              would be particularly important if the member declaration
12864              were instead:
12865
12866                template <class V = U> friend struct S1;
12867
12868              say, when we should tsubst into `U' when instantiating
12869              S2.  On the other hand, when presented with:
12870
12871                  template <class T>
12872                  struct S1 {
12873                    template <class U>
12874                    struct S2 {};
12875                    template <class U>
12876                    friend struct S2;
12877                  };
12878
12879               we must find the inner binding eventually.  We
12880               accomplish this by making sure that the new type we
12881               create to represent this declaration has the right
12882               TYPE_CONTEXT.  */
12883           context = TYPE_CONTEXT (ref);
12884           ref = NULL_TREE;
12885         }
12886     }
12887
12888   if (! ref)
12889     {
12890       /* If no such tag is yet defined, create a forward-reference node
12891          and record it as the "definition".
12892          When a real declaration of this type is found,
12893          the forward-reference will be altered into a real type.  */
12894       if (code == ENUMERAL_TYPE)
12895         {
12896           cp_error ("use of enum `%#D' without previous declaration", name);
12897
12898           ref = make_node (ENUMERAL_TYPE);
12899
12900           /* Give the type a default layout like unsigned int
12901              to avoid crashing if it does not get defined.  */
12902           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12903           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12904           TYPE_USER_ALIGN (ref) = 0;
12905           TREE_UNSIGNED (ref) = 1;
12906           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12907           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12908           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12909
12910           /* Enable us to recognize when a type is created in class context.
12911              To do nested classes correctly, this should probably be cleared
12912              out when we leave this classes scope.  Currently this in only
12913              done in `start_enum'.  */
12914
12915           pushtag (name, ref, globalize);
12916         }
12917       else
12918         {
12919           struct binding_level *old_b = class_binding_level;
12920
12921           ref = make_aggr_type (code);
12922           TYPE_CONTEXT (ref) = context;
12923
12924 #ifdef NONNESTED_CLASSES
12925           /* Class types don't nest the way enums do.  */
12926           class_binding_level = (struct binding_level *)0;
12927 #endif
12928           pushtag (name, ref, globalize);
12929           class_binding_level = old_b;
12930         }
12931     }
12932   else
12933     {
12934       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12935         redeclare_class_template (ref, current_template_parms);
12936     }
12937
12938   /* Until the type is defined, tentatively accept whatever
12939      structure tag the user hands us.  */
12940   if (!COMPLETE_TYPE_P (ref)
12941       && ref != current_class_type
12942       /* Have to check this, in case we have contradictory tag info.  */
12943       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12944     {
12945       if (tag_code == class_type)
12946         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12947       else if (tag_code == record_type)
12948         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12949     }
12950
12951   TREE_TYPE (ref) = attributes;
12952
12953   return ref;
12954 }
12955
12956 tree
12957 xref_tag_from_type (old, id, globalize)
12958      tree old, id;
12959      int globalize;
12960 {
12961   tree code_type_node;
12962
12963   if (TREE_CODE (old) == RECORD_TYPE)
12964     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12965                       ? class_type_node : record_type_node);
12966   else
12967     code_type_node = union_type_node;
12968
12969   if (id == NULL_TREE)
12970     id = TYPE_IDENTIFIER (old);
12971
12972   return xref_tag (code_type_node, id, globalize);
12973 }
12974
12975 /* REF is a type (named NAME), for which we have just seen some
12976    baseclasses.  BINFO is a list of those baseclasses; the
12977    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12978    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12979    struct, or union.  */
12980
12981 void
12982 xref_basetypes (code_type_node, name, ref, binfo)
12983      tree code_type_node;
12984      tree name, ref;
12985      tree binfo;
12986 {
12987   /* In the declaration `A : X, Y, ... Z' we mark all the types
12988      (A, X, Y, ..., Z) so we can check for duplicates.  */
12989   tree binfos;
12990   tree base;
12991
12992   int i, len;
12993   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12994
12995   if (tag_code == union_type)
12996     {
12997       cp_error ("derived union `%T' invalid", ref);
12998       return;
12999     }
13000
13001   len = list_length (binfo);
13002
13003   /* First, make sure that any templates in base-classes are
13004      instantiated.  This ensures that if we call ourselves recursively
13005      we do not get confused about which classes are marked and which
13006      are not.  */
13007   for (base = binfo; base; base = TREE_CHAIN (base))
13008     complete_type (TREE_VALUE (base));
13009
13010   SET_CLASSTYPE_MARKED (ref);
13011   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13012
13013   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13014     {
13015       /* The base of a derived struct is public by default.  */
13016       int via_public
13017         = (TREE_PURPOSE (binfo) == access_public_node
13018            || TREE_PURPOSE (binfo) == access_public_virtual_node
13019            || (tag_code != class_type
13020                && (TREE_PURPOSE (binfo) == access_default_node
13021                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13022       int via_protected
13023         = (TREE_PURPOSE (binfo) == access_protected_node
13024            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13025       int via_virtual
13026         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13027            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13028            || TREE_PURPOSE (binfo) == access_public_virtual_node
13029            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13030       tree basetype = TREE_VALUE (binfo);
13031       tree base_binfo;
13032
13033       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13034         basetype = TREE_TYPE (basetype);
13035       if (!basetype
13036           || (TREE_CODE (basetype) != RECORD_TYPE
13037               && TREE_CODE (basetype) != TYPENAME_TYPE
13038               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13039               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13040         {
13041           cp_error ("base type `%T' fails to be a struct or class type",
13042                     TREE_VALUE (binfo));
13043           continue;
13044         }
13045
13046       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13047
13048       /* This code replaces similar code in layout_basetypes.
13049          We put the complete_type first for implicit `typename'.  */
13050       if (!COMPLETE_TYPE_P (basetype)
13051           && ! (current_template_parms && uses_template_parms (basetype)))
13052         {
13053           cp_error ("base class `%T' has incomplete type", basetype);
13054           continue;
13055         }
13056       else
13057         {
13058           if (CLASSTYPE_MARKED (basetype))
13059             {
13060               if (basetype == ref)
13061                 cp_error ("recursive type `%T' undefined", basetype);
13062               else
13063                 cp_error ("duplicate base type `%T' invalid", basetype);
13064               continue;
13065             }
13066
13067           if (TYPE_FOR_JAVA (basetype)
13068               && (current_lang_stack
13069                   == &VARRAY_TREE (current_lang_base, 0)))
13070             TYPE_FOR_JAVA (ref) = 1;
13071
13072           /* Note that the BINFO records which describe individual
13073              inheritances are *not* shared in the lattice!  They
13074              cannot be shared because a given baseclass may be
13075              inherited with different `accessibility' by different
13076              derived classes.  (Each BINFO record describing an
13077              individual inheritance contains flags which say what
13078              the `accessibility' of that particular inheritance is.)  */
13079
13080           base_binfo
13081             = make_binfo (size_zero_node, basetype,
13082                           CLASS_TYPE_P (basetype)
13083                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13084                           CLASS_TYPE_P (basetype)
13085                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13086
13087           TREE_VEC_ELT (binfos, i) = base_binfo;
13088           TREE_VIA_PUBLIC (base_binfo) = via_public;
13089           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13090           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13091           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13092
13093           /* We need to unshare the binfos now so that lookups during class
13094              definition work.  */
13095           unshare_base_binfos (base_binfo);
13096
13097           SET_CLASSTYPE_MARKED (basetype);
13098
13099           /* We are free to modify these bits because they are meaningless
13100              at top level, and BASETYPE is a top-level type.  */
13101           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13102             {
13103               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13104               /* Converting to a virtual base class requires looking
13105                  up the offset of the virtual base.  */
13106               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13107             }
13108
13109           if (CLASS_TYPE_P (basetype))
13110             {
13111               TYPE_HAS_NEW_OPERATOR (ref)
13112                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13113               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13114                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13115               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13116               /* If the base-class uses multiple inheritance, so do we.  */
13117               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13118                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13119               /* Likewise, if converting to a base of the base may require
13120                  code, then we may need to generate code to convert to a
13121                  base as well.  */
13122               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13123                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13124             }
13125
13126           i += 1;
13127         }
13128     }
13129   if (i)
13130     TREE_VEC_LENGTH (binfos) = i;
13131   else
13132     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13133
13134   if (i > 1)
13135     {
13136       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13137       /* If there is more than one non-empty they cannot be at the same
13138          address.  */
13139       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13140     }
13141
13142   /* Unmark all the types.  */
13143   while (--i >= 0)
13144     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13145   CLEAR_CLASSTYPE_MARKED (ref);
13146
13147   /* Now that we know all the base-classes, set up the list of virtual
13148      bases.  */
13149   get_vbase_types (ref);
13150 }
13151
13152 \f
13153 /* Begin compiling the definition of an enumeration type.
13154    NAME is its name (or null if anonymous).
13155    Returns the type object, as yet incomplete.
13156    Also records info about it so that build_enumerator
13157    may be used to declare the individual values as they are read.  */
13158
13159 tree
13160 start_enum (name)
13161      tree name;
13162 {
13163   register tree enumtype = NULL_TREE;
13164   struct binding_level *b = current_binding_level;
13165
13166   /* If this is the real definition for a previous forward reference,
13167      fill in the contents in the same object that used to be the
13168      forward reference.  */
13169
13170   if (name != NULL_TREE)
13171     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13172
13173   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13174     {
13175       cp_error ("multiple definition of `%#T'", enumtype);
13176       cp_error_at ("previous definition here", enumtype);
13177       /* Clear out TYPE_VALUES, and start again.  */
13178       TYPE_VALUES (enumtype) = NULL_TREE;
13179     }
13180   else
13181     {
13182       enumtype = make_node (ENUMERAL_TYPE);
13183       pushtag (name, enumtype, 0);
13184     }
13185
13186   if (current_class_type)
13187     TREE_ADDRESSABLE (b->tags) = 1;
13188
13189   GNU_xref_decl (current_function_decl, enumtype);
13190   return enumtype;
13191 }
13192
13193 /* After processing and defining all the values of an enumeration type,
13194    install their decls in the enumeration type and finish it off.
13195    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13196    Returns ENUMTYPE.  */
13197
13198 tree
13199 finish_enum (enumtype)
13200      tree enumtype;
13201 {
13202   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13203   /* Calculate the maximum value of any enumerator in this type.  */
13204
13205   tree values = TYPE_VALUES (enumtype);
13206   if (values)
13207     {
13208       tree pair;
13209
13210       for (pair = values; pair; pair = TREE_CHAIN (pair))
13211         {
13212           tree decl;
13213           tree value;
13214
13215           /* The TREE_VALUE is a CONST_DECL for this enumeration
13216              constant.  */
13217           decl = TREE_VALUE (pair);
13218
13219           /* [dcl.enum]
13220
13221              Following the closing brace of an enum-specifier, each
13222              enumerator has the type of its enumeration.  Prior to the
13223              closing brace, the type of each enumerator is the type of
13224              its initializing value.  */
13225           TREE_TYPE (decl) = enumtype;
13226
13227           /* The DECL_INITIAL will be NULL if we are processing a
13228              template declaration and this enumeration constant had no
13229              explicit initializer.  */
13230           value = DECL_INITIAL (decl);
13231           if (value && !processing_template_decl)
13232             {
13233               /* Set the TREE_TYPE for the VALUE as well.  That's so
13234                  that when we call decl_constant_value we get an
13235                  entity of the right type (but with the constant
13236                  value).  Since we shouldn't ever call
13237                  decl_constant_value on a template type, there's no
13238                  reason to do that when processing_template_decl.
13239                  And, if the expression is something like a
13240                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13241                  wreak havoc on the intended type of the expression.
13242
13243                  Of course, there's also no point in trying to compute
13244                  minimum or maximum values if we're in a template.  */
13245               TREE_TYPE (value) = enumtype;
13246
13247               if (!minnode)
13248                 minnode = maxnode = value;
13249               else if (tree_int_cst_lt (maxnode, value))
13250                 maxnode = value;
13251               else if (tree_int_cst_lt (value, minnode))
13252                 minnode = value;
13253             }
13254
13255           if (processing_template_decl)
13256             /* If this is just a template, leave the CONST_DECL
13257                alone.  That way tsubst_copy will find CONST_DECLs for
13258                CONST_DECLs, and not INTEGER_CSTs.  */
13259             ;
13260           else
13261             /* In the list we're building up, we want the enumeration
13262                values, not the CONST_DECLs.  */
13263             TREE_VALUE (pair) = value;
13264         }
13265     }
13266   else
13267     maxnode = minnode = integer_zero_node;
13268
13269   TYPE_VALUES (enumtype) = nreverse (values);
13270
13271   if (processing_template_decl)
13272     {
13273       tree scope = current_scope ();
13274       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13275         add_stmt (build_min (TAG_DEFN, enumtype));
13276     }
13277   else
13278     {
13279       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13280       int lowprec = min_precision (minnode, unsignedp);
13281       int highprec = min_precision (maxnode, unsignedp);
13282       int precision = MAX (lowprec, highprec);
13283       tree tem;
13284
13285       TYPE_SIZE (enumtype) = NULL_TREE;
13286
13287       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13288
13289       TYPE_PRECISION (enumtype) = precision;
13290       if (unsignedp)
13291         fixup_unsigned_type (enumtype);
13292       else
13293         fixup_signed_type (enumtype);
13294
13295       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13296         /* Use the width of the narrowest normal C type which is wide
13297            enough.  */
13298         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13299                                                     (precision, 1));
13300       else
13301         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13302
13303       TYPE_SIZE (enumtype) = 0;
13304       layout_type (enumtype);
13305
13306       /* Fix up all variant types of this enum type.  */
13307       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13308            tem = TYPE_NEXT_VARIANT (tem))
13309         {
13310           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13311           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13312           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13313           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13314           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13315           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13316           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13317           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13318           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13319           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13320         }
13321
13322       /* Finish debugging output for this type.  */
13323       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13324     }
13325
13326   return enumtype;
13327 }
13328
13329 /* Build and install a CONST_DECL for an enumeration constant of the
13330    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13331    Assignment of sequential values by default is handled here.  */
13332
13333 void
13334 build_enumerator (name, value, enumtype)
13335      tree name;
13336      tree value;
13337      tree enumtype;
13338 {
13339   tree decl;
13340   tree context;
13341   tree type;
13342   tree values;
13343
13344   /* Remove no-op casts from the value.  */
13345   if (value)
13346     STRIP_TYPE_NOPS (value);
13347
13348   if (! processing_template_decl)
13349     {
13350       /* Validate and default VALUE.  */
13351       if (value != NULL_TREE)
13352         {
13353           value = decl_constant_value (value);
13354
13355           if (TREE_CODE (value) == INTEGER_CST)
13356             {
13357               value = default_conversion (value);
13358               constant_expression_warning (value);
13359             }
13360           else
13361             {
13362               cp_error ("enumerator value for `%D' not integer constant", name);
13363               value = NULL_TREE;
13364             }
13365         }
13366
13367       /* Default based on previous value.  */
13368       if (value == NULL_TREE && ! processing_template_decl)
13369         {
13370           tree prev_value;
13371
13372           if (TYPE_VALUES (enumtype))
13373             {
13374               /* The next value is the previous value ... */
13375               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13376               /* ... plus one.  */
13377               value = cp_build_binary_op (PLUS_EXPR,
13378                                           prev_value,
13379                                           integer_one_node);
13380
13381               if (tree_int_cst_lt (value, prev_value))
13382                 cp_error ("overflow in enumeration values at `%D'", name);
13383             }
13384           else
13385             value = integer_zero_node;
13386         }
13387
13388       /* Remove no-op casts from the value.  */
13389       if (value)
13390         STRIP_TYPE_NOPS (value);
13391 #if 0
13392       /* To fix MAX_VAL enum consts. (bkoz)  */
13393       TREE_TYPE (value) = integer_type_node;
13394 #endif
13395     }
13396
13397   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13398      Even in other cases, we will later (in finish_enum) be setting
13399      the type of VALUE.  But, we don't need to make a copy if this
13400      VALUE is one of the enumeration constants for this same
13401      enumeration type.  */
13402   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13403     if (TREE_VALUE (values) == value)
13404       break;
13405   /* If we didn't break out of the loop, then we do need a copy.  */
13406   if (!values && value)
13407     value = copy_node (value);
13408
13409   /* C++ associates enums with global, function, or class declarations.  */
13410   context = current_scope ();
13411
13412   /* Build the actual enumeration constant.  Note that the enumeration
13413     constants have the type of their initializers until the
13414     enumeration is complete:
13415
13416       [ dcl.enum ]
13417
13418       Following the closing brace of an enum-specifier, each enumer-
13419       ator has the type of its enumeration.  Prior to the closing
13420       brace, the type of each enumerator is the type of its
13421       initializing value.
13422
13423     In finish_enum we will reset the type.  Of course, if we're
13424     processing a template, there may be no value.   */
13425   type = value ? TREE_TYPE (value) : NULL_TREE;
13426
13427   if (context && context == current_class_type)
13428     /* This enum declaration is local to the class.  We need the full
13429        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13430     decl = build_lang_decl (CONST_DECL, name, type);
13431   else
13432     /* It's a global enum, or it's local to a function.  (Note local to
13433       a function could mean local to a class method.  */
13434     decl = build_decl (CONST_DECL, name, type);
13435
13436   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13437   DECL_INITIAL (decl) = value;
13438   TREE_READONLY (decl) = 1;
13439
13440   if (context && context == current_class_type)
13441     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13442       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13443       things like `S::i' later.)  */
13444     finish_member_declaration (decl);
13445   else
13446     {
13447       pushdecl (decl);
13448       GNU_xref_decl (current_function_decl, decl);
13449     }
13450
13451   /* Add this enumeration constant to the list for this type.  */
13452   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13453 }
13454
13455 \f
13456 /* We're defining DECL.  Make sure that it's type is OK.  */
13457
13458 static void
13459 check_function_type (decl, current_function_parms)
13460      tree decl;
13461      tree current_function_parms;
13462 {
13463   tree fntype = TREE_TYPE (decl);
13464   tree return_type = complete_type (TREE_TYPE (fntype));
13465
13466   /* In a function definition, arg types must be complete.  */
13467   require_complete_types_for_parms (current_function_parms);
13468
13469   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13470     {
13471       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13472
13473       /* Make it return void instead, but don't change the
13474          type of the DECL_RESULT, in case we have a named return value.  */
13475       if (TREE_CODE (fntype) == METHOD_TYPE)
13476         {
13477           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13478           TREE_TYPE (decl)
13479             = build_cplus_method_type (ctype,
13480                                        void_type_node,
13481                                        FUNCTION_ARG_CHAIN (decl));
13482         }
13483       else
13484         TREE_TYPE (decl)
13485           = build_function_type (void_type_node,
13486                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13487       TREE_TYPE (decl)
13488         = build_exception_variant (fntype,
13489                                    TYPE_RAISES_EXCEPTIONS (fntype));
13490     }
13491   else
13492     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13493 }
13494
13495 /* Create the FUNCTION_DECL for a function definition.
13496    DECLSPECS and DECLARATOR are the parts of the declaration;
13497    they describe the function's name and the type it returns,
13498    but twisted together in a fashion that parallels the syntax of C.
13499
13500    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13501    DECLARATOR is really the DECL for the function we are about to
13502    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13503    indicating that the function is an inline defined in-class.
13504
13505    This function creates a binding context for the function body
13506    as well as setting up the FUNCTION_DECL in current_function_decl.
13507
13508    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13509    (it defines a datum instead), we return 0, which tells
13510    yyparse to report a parse error.
13511
13512    For C++, we must first check whether that datum makes any sense.
13513    For example, "class A local_a(1,2);" means that variable local_a
13514    is an aggregate of type A, which should have a constructor
13515    applied to it with the argument list [1, 2].  */
13516
13517 int
13518 start_function (declspecs, declarator, attrs, flags)
13519      tree declspecs, declarator, attrs;
13520      int flags;
13521 {
13522   tree decl1;
13523   tree ctype = NULL_TREE;
13524   tree fntype;
13525   tree restype;
13526   extern int have_extern_spec;
13527   extern int used_extern_spec;
13528   int doing_friend = 0;
13529   struct binding_level *bl;
13530   tree current_function_parms;
13531
13532   /* Sanity check.  */
13533   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13534   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13535
13536   /* This should only be done once on the top most decl.  */
13537   if (have_extern_spec && !used_extern_spec)
13538     {
13539       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13540       used_extern_spec = 1;
13541     }
13542
13543   if (flags & SF_PRE_PARSED)
13544     {
13545       decl1 = declarator;
13546
13547       fntype = TREE_TYPE (decl1);
13548       if (TREE_CODE (fntype) == METHOD_TYPE)
13549         ctype = TYPE_METHOD_BASETYPE (fntype);
13550
13551       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13552          the (lexical) scope of the class in which it is defined.  */
13553       if (!ctype && DECL_FRIEND_P (decl1))
13554         {
13555           ctype = DECL_FRIEND_CONTEXT (decl1);
13556
13557           /* CTYPE could be null here if we're dealing with a template;
13558              for example, `inline friend float foo()' inside a template
13559              will have no CTYPE set.  */
13560           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13561             ctype = NULL_TREE;
13562           else
13563             doing_friend = 1;
13564         }
13565
13566       last_function_parms = DECL_ARGUMENTS (decl1);
13567       last_function_parm_tags = NULL_TREE;
13568     }
13569   else
13570     {
13571       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13572       /* If the declarator is not suitable for a function definition,
13573          cause a syntax error.  */
13574       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13575
13576       fntype = TREE_TYPE (decl1);
13577
13578       restype = TREE_TYPE (fntype);
13579       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13580         {
13581           cp_error ("semicolon missing after declaration of `%#T'", restype);
13582           shadow_tag (build_tree_list (NULL_TREE, restype));
13583           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13584           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13585             fntype = build_function_type (integer_type_node,
13586                                           TYPE_ARG_TYPES (fntype));
13587           else
13588             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13589                                               integer_type_node,
13590                                               TYPE_ARG_TYPES (fntype));
13591           TREE_TYPE (decl1) = fntype;
13592         }
13593
13594       if (TREE_CODE (fntype) == METHOD_TYPE)
13595         ctype = TYPE_METHOD_BASETYPE (fntype);
13596       else if (DECL_MAIN_P (decl1))
13597         {
13598           /* If this doesn't return integer_type, complain.  */
13599           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13600             {
13601               if (pedantic || warn_return_type)
13602                 pedwarn ("return type for `main' changed to `int'");
13603               TREE_TYPE (decl1) = fntype = default_function_type;
13604             }
13605         }
13606     }
13607
13608   /* Sometimes we don't notice that a function is a static member, and
13609      build a METHOD_TYPE for it.  Fix that up now.  */
13610   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13611       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13612     {
13613       revert_static_member_fn (decl1);
13614       last_function_parms = TREE_CHAIN (last_function_parms);
13615       ctype = NULL_TREE;
13616     }
13617
13618   /* Warn if function was previously implicitly declared
13619      (but not if we warned then).  */
13620   if (! warn_implicit
13621       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13622     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13623
13624   /* Set up current_class_type, and enter the scope of the class, if
13625      appropriate.  */
13626   if (ctype)
13627     push_nested_class (ctype, 1);
13628   else if (DECL_STATIC_FUNCTION_P (decl1))
13629     push_nested_class (DECL_CONTEXT (decl1), 2);
13630
13631   /* Now that we have entered the scope of the class, we must restore
13632      the bindings for any template parameters surrounding DECL1, if it
13633      is an inline member template.  (Order is important; consider the
13634      case where a template parameter has the same name as a field of
13635      the class.)  It is not until after this point that
13636      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13637   if (flags & SF_INCLASS_INLINE)
13638     maybe_begin_member_template_processing (decl1);
13639
13640   /* Effective C++ rule 15.  */
13641   if (warn_ecpp
13642       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13643       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13644     cp_warning ("`operator=' should return a reference to `*this'");
13645
13646   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13647      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13648   if (!DECL_INITIAL (decl1))
13649     DECL_INITIAL (decl1) = error_mark_node;
13650
13651 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13652   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13653 #endif
13654
13655   /* This function exists in static storage.
13656      (This does not mean `static' in the C sense!)  */
13657   TREE_STATIC (decl1) = 1;
13658
13659   /* We must call push_template_decl after current_class_type is set
13660      up.  (If we are processing inline definitions after exiting a
13661      class scope, current_class_type will be NULL_TREE until set above
13662      by push_nested_class.)  */
13663   if (processing_template_decl)
13664     decl1 = push_template_decl (decl1);
13665
13666   /* We are now in the scope of the function being defined.  */
13667   current_function_decl = decl1;
13668
13669   /* Save the parm names or decls from this function's declarator
13670      where store_parm_decls will find them.  */
13671   current_function_parms = last_function_parms;
13672   current_function_parm_tags = last_function_parm_tags;
13673
13674   /* Make sure the parameter and return types are reasonable.  When
13675      you declare a function, these types can be incomplete, but they
13676      must be complete when you define the function.  */
13677   if (! processing_template_decl)
13678     check_function_type (decl1, current_function_parms);
13679
13680   /* Build the return declaration for the function.  */
13681   restype = TREE_TYPE (fntype);
13682   if (!processing_template_decl)
13683     {
13684       if (!DECL_RESULT (decl1))
13685         {
13686           DECL_RESULT (decl1)
13687             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13688           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13689                                       DECL_RESULT (decl1));
13690         }
13691     }
13692   else
13693     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13694     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13695
13696   /* Initialize RTL machinery.  We cannot do this until
13697      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13698      even when processing a template; this is how we get
13699      CFUN set up, and our per-function variables initialized.  */
13700   bl = current_binding_level;
13701   init_function_start (decl1, input_filename, lineno);
13702   current_binding_level = bl;
13703
13704   /* Even though we're inside a function body, we still don't want to
13705      call expand_expr to calculate the size of a variable-sized array.
13706      We haven't necessarily assigned RTL to all variables yet, so it's
13707      not safe to try to expand expressions involving them.  */
13708   immediate_size_expand = 0;
13709   cfun->x_dont_save_pending_sizes_p = 1;
13710
13711   /* Start the statement-tree, start the tree now.  */
13712   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13713
13714   /* Let the user know we're compiling this function.  */
13715   announce_function (decl1);
13716
13717   /* Record the decl so that the function name is defined.
13718      If we already have a decl for this name, and it is a FUNCTION_DECL,
13719      use the old decl.  */
13720   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13721     {
13722       /* A specialization is not used to guide overload resolution.  */
13723       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13724           && ! DECL_FUNCTION_MEMBER_P (decl1))
13725         decl1 = pushdecl (decl1);
13726       else
13727         {
13728           /* We need to set the DECL_CONTEXT. */
13729           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13730             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13731           /* And make sure we have enough default args.  */
13732           check_default_args (decl1);
13733         }
13734       fntype = TREE_TYPE (decl1);
13735     }
13736
13737   /* Reset these in case the call to pushdecl changed them.  */
13738   current_function_decl = decl1;
13739   cfun->decl = decl1;
13740
13741   /* If we are (erroneously) defining a function that we have already
13742      defined before, wipe out what we knew before.  */
13743   if (!DECL_PENDING_INLINE_P (decl1)
13744       && DECL_SAVED_FUNCTION_DATA (decl1))
13745     {
13746       free (DECL_SAVED_FUNCTION_DATA (decl1));
13747       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13748     }
13749
13750   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13751     {
13752       /* We know that this was set up by `grokclassfn'.  We do not
13753          wait until `store_parm_decls', since evil parse errors may
13754          never get us to that point.  Here we keep the consistency
13755          between `current_class_type' and `current_class_ptr'.  */
13756       tree t = DECL_ARGUMENTS (decl1);
13757
13758       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13759                           162);
13760       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13761                           19990811);
13762
13763       cp_function_chain->x_current_class_ref
13764         = build_indirect_ref (t, NULL_PTR);
13765       cp_function_chain->x_current_class_ptr = t;
13766
13767       /* Constructors and destructors need to know whether they're "in
13768          charge" of initializing virtual base classes.  */
13769       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13770         current_in_charge_parm = TREE_CHAIN (t);
13771     }
13772
13773   if (DECL_INTERFACE_KNOWN (decl1))
13774     {
13775       tree ctx = decl_function_context (decl1);
13776
13777       if (DECL_NOT_REALLY_EXTERN (decl1))
13778         DECL_EXTERNAL (decl1) = 0;
13779
13780       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13781           && TREE_PUBLIC (ctx))
13782         /* This is a function in a local class in an extern inline
13783            function.  */
13784         comdat_linkage (decl1);
13785     }
13786   /* If this function belongs to an interface, it is public.
13787      If it belongs to someone else's interface, it is also external.
13788      This only affects inlines and template instantiations.  */
13789   else if (interface_unknown == 0
13790            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13791                || flag_alt_external_templates))
13792     {
13793       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13794           || processing_template_decl)
13795         {
13796           DECL_EXTERNAL (decl1)
13797             = (interface_only
13798                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13799                    && !DECL_VINDEX (decl1)));
13800
13801           /* For WIN32 we also want to put these in linkonce sections.  */
13802           maybe_make_one_only (decl1);
13803         }
13804       else
13805         DECL_EXTERNAL (decl1) = 0;
13806       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13807       DECL_INTERFACE_KNOWN (decl1) = 1;
13808     }
13809   else if (interface_unknown && interface_only
13810            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13811                || flag_alt_external_templates))
13812     {
13813       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13814          interface, we will have interface_only set but not
13815          interface_known.  In that case, we don't want to use the normal
13816          heuristics because someone will supply a #pragma implementation
13817          elsewhere, and deducing it here would produce a conflict.  */
13818       comdat_linkage (decl1);
13819       DECL_EXTERNAL (decl1) = 0;
13820       DECL_INTERFACE_KNOWN (decl1) = 1;
13821       DECL_DEFER_OUTPUT (decl1) = 1;
13822     }
13823   else
13824     {
13825       /* This is a definition, not a reference.
13826          So clear DECL_EXTERNAL.  */
13827       DECL_EXTERNAL (decl1) = 0;
13828
13829       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13830           && ! DECL_INTERFACE_KNOWN (decl1)
13831           /* Don't try to defer nested functions for now.  */
13832           && ! decl_function_context (decl1))
13833         DECL_DEFER_OUTPUT (decl1) = 1;
13834       else
13835         DECL_INTERFACE_KNOWN (decl1) = 1;
13836     }
13837
13838   pushlevel (0);
13839   current_binding_level->parm_flag = 1;
13840
13841   if (attrs)
13842     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13843
13844   /* We need to do this even if we aren't expanding yet so that
13845      assemble_external works.  */
13846   make_function_rtl (decl1);
13847
13848   /* Promote the value to int before returning it.  */
13849   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13850     restype = type_promotes_to (restype);
13851
13852   /* If this fcn was already referenced via a block-scope `extern' decl
13853      (or an implicit decl), propagate certain information about the usage.  */
13854   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13855     TREE_ADDRESSABLE (decl1) = 1;
13856
13857   if (DECL_RESULT (decl1) == NULL_TREE)
13858     {
13859       DECL_RESULT (decl1)
13860         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13861       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13862       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13863     }
13864
13865   ++function_depth;
13866
13867   if (DECL_DESTRUCTOR_P (decl1))
13868     {
13869       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13870       DECL_CONTEXT (dtor_label) = current_function_decl;
13871     }
13872   /* Under the old ABI we return `this' from constructors, so we make
13873      ordinary `return' statements in constructors jump to CTOR_LABEL;
13874      from there we return `this'.  Under the new ABI, we don't bother
13875      with any of this.  By not setting CTOR_LABEL the remainder of the
13876      machinery is automatically disabled.  */
13877   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13878     {
13879       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13880       DECL_CONTEXT (ctor_label) = current_function_decl;
13881     }
13882
13883   store_parm_decls (current_function_parms);
13884
13885   return 1;
13886 }
13887 \f
13888 /* Store the parameter declarations into the current function declaration.
13889    This is called after parsing the parameter declarations, before
13890    digesting the body of the function.
13891
13892    Also install to binding contour return value identifier, if any.  */
13893
13894 static void
13895 store_parm_decls (current_function_parms)
13896      tree current_function_parms;
13897 {
13898   register tree fndecl = current_function_decl;
13899   register tree parm;
13900   int parms_have_cleanups = 0;
13901   tree cleanups = NULL_TREE;
13902
13903   /* This is a list of types declared among parms in a prototype.  */
13904   tree parmtags = current_function_parm_tags;
13905
13906   /* This is a chain of any other decls that came in among the parm
13907      declarations.  If a parm is declared with  enum {foo, bar} x;
13908      then CONST_DECLs for foo and bar are put here.  */
13909   tree nonparms = NULL_TREE;
13910
13911   if (current_function_parms)
13912     {
13913       /* This case is when the function was defined with an ANSI prototype.
13914          The parms already have decls, so we need not do anything here
13915          except record them as in effect
13916          and complain if any redundant old-style parm decls were written.  */
13917
13918       tree specparms = current_function_parms;
13919       tree next;
13920
13921       /* Must clear this because it might contain TYPE_DECLs declared
13922              at class level.  */
13923       storedecls (NULL_TREE);
13924
13925       /* If we're doing semantic analysis, then we'll call pushdecl
13926              for each of these.  We must do them in reverse order so that
13927              they end in the correct forward order.  */
13928       specparms = nreverse (specparms);
13929
13930       for (parm = specparms; parm; parm = next)
13931         {
13932           next = TREE_CHAIN (parm);
13933           if (TREE_CODE (parm) == PARM_DECL)
13934             {
13935               tree cleanup;
13936
13937               if (DECL_NAME (parm) == NULL_TREE
13938                   || TREE_CODE (parm) != VOID_TYPE)
13939                 pushdecl (parm);
13940               else
13941                 cp_error ("parameter `%D' declared void", parm);
13942
13943               cleanup = (processing_template_decl
13944                          ? NULL_TREE
13945                          : maybe_build_cleanup (parm));
13946
13947               if (cleanup)
13948                 cleanups = tree_cons (parm, cleanup, cleanups);
13949             }
13950           else
13951             {
13952               /* If we find an enum constant or a type tag,
13953                  put it aside for the moment.  */
13954               TREE_CHAIN (parm) = NULL_TREE;
13955               nonparms = chainon (nonparms, parm);
13956             }
13957         }
13958
13959       /* Get the decls in their original chain order and record in the
13960          function.  This is all and only the PARM_DECLs that were
13961          pushed into scope by the loop above.  */
13962       DECL_ARGUMENTS (fndecl) = getdecls ();
13963       storetags (chainon (parmtags, gettags ()));
13964     }
13965   else
13966     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13967
13968   /* Now store the final chain of decls for the arguments
13969      as the decl-chain of the current lexical scope.
13970      Put the enumerators in as well, at the front so that
13971      DECL_ARGUMENTS is not modified.  */
13972   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13973
13974   /* Now that we have initialized the parms, we can start their
13975      cleanups.  We cannot do this before, since expand_decl_cleanup
13976      should not be called before the parm can be used.  */
13977   while (cleanups)
13978     {
13979       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13980                            TREE_VALUE (cleanups));
13981       cleanups = TREE_CHAIN (cleanups);
13982     }
13983
13984   /* Create a binding contour which can be used to catch
13985      cleanup-generated temporaries.  */
13986   if (parms_have_cleanups)
13987     pushlevel (0);
13988
13989   /* Do the starting of the exception specifications, if we have any.  */
13990   if (flag_exceptions && !processing_template_decl
13991       && flag_enforce_eh_specs
13992       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13993     current_eh_spec_try_block = expand_start_eh_spec ();
13994 }
13995
13996 \f
13997 /* We have finished doing semantic analysis on DECL, but have not yet
13998    generated RTL for its body.  Save away our current state, so that
13999    when we want to generate RTL later we know what to do.  */
14000
14001 static void
14002 save_function_data (decl)
14003      tree decl;
14004 {
14005   struct cp_language_function *f;
14006
14007   /* Save the language-specific per-function data so that we can
14008      get it back when we really expand this function.  */
14009   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14010                       19990908);
14011
14012   /* Make a copy.  */
14013   f = ((struct cp_language_function *)
14014        xmalloc (sizeof (struct cp_language_function)));
14015   bcopy ((char *) cp_function_chain, (char *) f,
14016          sizeof (struct cp_language_function));
14017   DECL_SAVED_FUNCTION_DATA (decl) = f;
14018
14019   /* Clear out the bits we don't need.  */
14020   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14021   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14022   f->x_named_label_uses = NULL;
14023   f->bindings = NULL;
14024
14025   /* When we get back here again, we will be expanding.  */
14026   f->x_expanding_p = 1;
14027
14028   /* If we've already decided that we cannot inline this function, we
14029      must remember that fact when we actually go to expand the
14030      function.  */
14031   f->cannot_inline = current_function_cannot_inline;
14032 }
14033
14034 /* At the end of every constructor we generate to code to return
14035    `this'.  Do that now.  */
14036
14037 static void
14038 finish_constructor_body ()
14039 {
14040   /* Any return from a constructor will end up here.  */
14041   if (ctor_label)
14042     add_stmt (build_stmt (LABEL_STMT, ctor_label));
14043
14044   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14045      generate the return, rather than a goto to CTOR_LABEL.  */
14046   ctor_label = NULL_TREE;
14047   /* In check_return_expr we translate an empty return from a
14048      constructor to a return of `this'.  */
14049   finish_return_stmt (NULL_TREE);
14050   /* Mark the end of the constructor.  */
14051   add_stmt (build_stmt (CTOR_STMT));
14052 }
14053
14054 /* At the end of every destructor we generate code to restore virtual
14055    function tables to the values desired by base classes and to call
14056    to base class destructors.  Do that now.  */
14057
14058 static void
14059 finish_destructor_body ()
14060 {
14061   tree compound_stmt;
14062   tree virtual_size;
14063   tree exprstmt;
14064   tree if_stmt;
14065
14066   /* Create a block to contain all the extra code.  */
14067   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14068
14069   /* Any return from a destructor will end up here.  */
14070   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14071
14072   /* Generate the code to call destructor on base class.  If this
14073      destructor belongs to a class with virtual functions, then set
14074      the virtual function table pointer to represent the type of our
14075      base class.  */
14076
14077   /* This side-effect makes call to `build_delete' generate the code
14078      we have to have at the end of this destructor.  `build_delete'
14079      will set the flag again.  */
14080   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14081
14082   exprstmt = build_delete (current_class_type,
14083                            current_class_ref,
14084                            sfk_base_destructor,
14085                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14086                            0);
14087
14088   if (exprstmt != error_mark_node
14089       && (TREE_CODE (exprstmt) != NOP_EXPR
14090           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14091           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14092     {
14093       if (exprstmt != void_zero_node)
14094         /* Don't call `expand_expr_stmt' if we're not going to do
14095            anything, since -Wall will give a diagnostic.  */
14096         finish_expr_stmt (exprstmt);
14097
14098       /* Run destructors for all virtual baseclasses.  */
14099       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14100         {
14101           tree vbases;
14102           tree if_stmt;
14103
14104           if_stmt = begin_if_stmt ();
14105           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14106                                       current_in_charge_parm,
14107                                       integer_two_node),
14108                                if_stmt);
14109
14110           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14111           /* The CLASSTYPE_VBASECLASSES list is in initialization
14112              order, so we have to march through it in reverse order.  */
14113           for (vbases = nreverse (copy_list (vbases));
14114                vbases;
14115                vbases = TREE_CHAIN (vbases))
14116             {
14117               tree vbase = TREE_VALUE (vbases);
14118
14119               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14120                 {
14121                   tree vb = get_vbase
14122                     (BINFO_TYPE (vbase),
14123                      TYPE_BINFO (current_class_type));
14124                   finish_expr_stmt
14125                     (build_scoped_method_call
14126                      (current_class_ref, vb, base_dtor_identifier,
14127                       NULL_TREE));
14128                 }
14129             }
14130
14131           finish_then_clause (if_stmt);
14132           finish_if_stmt ();
14133         }
14134     }
14135
14136   virtual_size = c_sizeof (current_class_type);
14137
14138   /* At the end, call delete if that's what's requested.  */
14139
14140   /* FDIS sez: At the point of definition of a virtual destructor
14141      (including an implicit definition), non-placement operator delete
14142      shall be looked up in the scope of the destructor's class and if
14143      found shall be accessible and unambiguous.
14144
14145      This is somewhat unclear, but I take it to mean that if the class
14146      only defines placement deletes we don't do anything here.  So we
14147      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14148      they ever try to delete one of these.  */
14149   exprstmt = build_op_delete_call
14150     (DELETE_EXPR, current_class_ptr, virtual_size,
14151      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14152
14153   if_stmt = begin_if_stmt ();
14154   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14155                               current_in_charge_parm,
14156                               integer_one_node),
14157                        if_stmt);
14158   finish_expr_stmt (exprstmt);
14159   finish_then_clause (if_stmt);
14160   finish_if_stmt ();
14161
14162   /* Close the block we started above.  */
14163   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14164 }
14165
14166 /* Finish up a function declaration and compile that function
14167    all the way to assembler language output.  The free the storage
14168    for the function definition.
14169
14170    FLAGS is a bitwise or of the following values:
14171      1 - CALL_POPLEVEL
14172        An extra call to poplevel (and expand_end_bindings) must be
14173        made to take care of the binding contour for the base
14174        initializers.  This is only relevant for constructors.
14175      2 - INCLASS_INLINE
14176        We just finished processing the body of an in-class inline
14177        function definition.  (This processing will have taken place
14178        after the class definition is complete.)  */
14179
14180 tree
14181 finish_function (flags)
14182      int flags;
14183 {
14184   register tree fndecl = current_function_decl;
14185   tree fntype, ctype = NULL_TREE;
14186   int call_poplevel = (flags & 1) != 0;
14187   int inclass_inline = (flags & 2) != 0;
14188   int nested;
14189
14190   /* When we get some parse errors, we can end up without a
14191      current_function_decl, so cope.  */
14192   if (fndecl == NULL_TREE)
14193     return error_mark_node;
14194
14195   nested = function_depth > 1;
14196   fntype = TREE_TYPE (fndecl);
14197
14198   /*  TREE_READONLY (fndecl) = 1;
14199       This caused &foo to be of type ptr-to-const-function
14200       which then got a warning when stored in a ptr-to-function variable.  */
14201
14202   my_friendly_assert (building_stmt_tree (), 20000911);
14203
14204   /* For a cloned function, we've already got all the code we need;
14205      there's no need to add any extra bits.  */
14206   if (!DECL_CLONED_FUNCTION_P (fndecl))
14207     {
14208       if (DECL_CONSTRUCTOR_P (fndecl))
14209         {
14210           finish_constructor_body ();
14211           if (call_poplevel)
14212             do_poplevel ();
14213         }
14214       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14215         finish_destructor_body ();
14216       else if (DECL_MAIN_P (fndecl))
14217         {
14218           /* Make it so that `main' always returns 0 by default.  */
14219 #ifdef VMS
14220           finish_return_stmt (integer_one_node);
14221 #else
14222           finish_return_stmt (integer_zero_node);
14223 #endif
14224         }
14225
14226       /* Finish dealing with exception specifiers.  */
14227       if (flag_exceptions && !processing_template_decl
14228           && flag_enforce_eh_specs
14229           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14230         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14231                             (TREE_TYPE (current_function_decl)),
14232                             current_eh_spec_try_block);
14233     }
14234
14235   /* If we're saving up tree structure, tie off the function now.  */
14236   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14237
14238   /* This must come after expand_function_end because cleanups might
14239      have declarations (from inline functions) that need to go into
14240      this function's blocks.  */
14241   if (current_binding_level->parm_flag != 1)
14242     my_friendly_abort (122);
14243   poplevel (1, 0, 1);
14244
14245   /* Remember that we were in class scope.  */
14246   if (current_class_name)
14247     ctype = current_class_type;
14248
14249   /* Must mark the RESULT_DECL as being in this function.  */
14250   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14251
14252   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14253      to the FUNCTION_DECL node itself.  */
14254   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14255
14256   /* Save away current state, if appropriate.  */
14257   if (!processing_template_decl)
14258     save_function_data (fndecl);
14259
14260   /* If this function calls `setjmp' it cannot be inlined.  When
14261      `longjmp' is called it is not guaranteed to restore the value of
14262      local variables that have been modified since the call to
14263      `setjmp'.  So, if were to inline this function into some caller
14264      `c', then when we `longjmp', we might not restore all variables
14265      in `c'.  (It might seem, at first blush, that there's no way for
14266      this function to modify local variables in `c', but their
14267      addresses may have been stored somewhere accessible to this
14268      function.)  */
14269   if (!processing_template_decl && calls_setjmp_p (fndecl))
14270     DECL_UNINLINABLE (fndecl) = 1;
14271
14272   /* Clear out memory we no longer need.  */
14273   free_after_parsing (cfun);
14274   /* Since we never call rest_of_compilation, we never clear
14275      CFUN.  Do so explicitly.  */
14276   free_after_compilation (cfun);
14277   cfun = NULL;
14278
14279   /* If this is a in-class inline definition, we may have to pop the
14280      bindings for the template parameters that we added in
14281      maybe_begin_member_template_processing when start_function was
14282      called.  */
14283   if (inclass_inline)
14284     maybe_end_member_template_processing ();
14285
14286   /* Leave the scope of the class.  */
14287   if (ctype)
14288     pop_nested_class ();
14289
14290   --function_depth;
14291
14292   /* Clean up.  */
14293   if (! nested)
14294     /* Let the error reporting routines know that we're outside a
14295        function.  For a nested function, this value is used in
14296        pop_cp_function_context and then reset via pop_function_context.  */
14297     current_function_decl = NULL_TREE;
14298
14299   return fndecl;
14300 }
14301 \f
14302 /* Create the FUNCTION_DECL for a function definition.
14303    DECLSPECS and DECLARATOR are the parts of the declaration;
14304    they describe the return type and the name of the function,
14305    but twisted together in a fashion that parallels the syntax of C.
14306
14307    This function creates a binding context for the function body
14308    as well as setting up the FUNCTION_DECL in current_function_decl.
14309
14310    Returns a FUNCTION_DECL on success.
14311
14312    If the DECLARATOR is not suitable for a function (it defines a datum
14313    instead), we return 0, which tells yyparse to report a parse error.
14314
14315    May return void_type_node indicating that this method is actually
14316    a friend.  See grokfield for more details.
14317
14318    Came here with a `.pushlevel' .
14319
14320    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14321    CHANGES TO CODE IN `grokfield'.  */
14322
14323 tree
14324 start_method (declspecs, declarator, attrlist)
14325      tree declarator, declspecs, attrlist;
14326 {
14327   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14328                                 attrlist);
14329
14330   /* Something too ugly to handle.  */
14331   if (fndecl == NULL_TREE)
14332     return NULL_TREE;
14333
14334   /* Pass friends other than inline friend functions back.  */
14335   if (fndecl == void_type_node)
14336     return fndecl;
14337
14338   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14339     /* Not a function, tell parser to report parse error.  */
14340     return NULL_TREE;
14341
14342   if (DECL_IN_AGGR_P (fndecl))
14343     {
14344       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14345         {
14346           if (DECL_CONTEXT (fndecl)
14347               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14348             cp_error ("`%D' is already defined in class `%T'", fndecl,
14349                       DECL_CONTEXT (fndecl));
14350         }
14351       return void_type_node;
14352     }
14353
14354   check_template_shadow (fndecl);
14355
14356   DECL_THIS_INLINE (fndecl) = 1;
14357
14358   if (flag_default_inline)
14359     DECL_INLINE (fndecl) = 1;
14360
14361   /* We process method specializations in finish_struct_1.  */
14362   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14363     fndecl = push_template_decl (fndecl);
14364
14365   if (! DECL_FRIEND_P (fndecl))
14366     {
14367       if (TREE_CHAIN (fndecl))
14368         {
14369           fndecl = copy_node (fndecl);
14370           TREE_CHAIN (fndecl) = NULL_TREE;
14371         }
14372
14373       if (DECL_CONSTRUCTOR_P (fndecl))
14374         {
14375           if (! grok_ctor_properties (current_class_type, fndecl))
14376             return void_type_node;
14377         }
14378       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14379         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14380     }
14381
14382   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14383
14384   /* Make a place for the parms */
14385   pushlevel (0);
14386   current_binding_level->parm_flag = 1;
14387
14388   DECL_IN_AGGR_P (fndecl) = 1;
14389   return fndecl;
14390 }
14391
14392 /* Go through the motions of finishing a function definition.
14393    We don't compile this method until after the whole class has
14394    been processed.
14395
14396    FINISH_METHOD must return something that looks as though it
14397    came from GROKFIELD (since we are defining a method, after all).
14398
14399    This is called after parsing the body of the function definition.
14400    STMTS is the chain of statements that makes up the function body.
14401
14402    DECL is the ..._DECL that `start_method' provided.  */
14403
14404 tree
14405 finish_method (decl)
14406      tree decl;
14407 {
14408   register tree fndecl = decl;
14409   tree old_initial;
14410
14411   register tree link;
14412
14413   if (decl == void_type_node)
14414     return decl;
14415
14416   old_initial = DECL_INITIAL (fndecl);
14417
14418   /* Undo the level for the parms (from start_method).
14419      This is like poplevel, but it causes nothing to be
14420      saved.  Saving information here confuses symbol-table
14421      output routines.  Besides, this information will
14422      be correctly output when this method is actually
14423      compiled.  */
14424
14425   /* Clear out the meanings of the local variables of this level;
14426      also record in each decl which block it belongs to.  */
14427
14428   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14429     {
14430       if (DECL_NAME (link) != NULL_TREE)
14431         pop_binding (DECL_NAME (link), link);
14432       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14433       DECL_CONTEXT (link) = NULL_TREE;
14434     }
14435
14436   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14437                       (HOST_WIDE_INT) current_binding_level->level_chain,
14438                       current_binding_level->parm_flag,
14439                       current_binding_level->keep);
14440
14441   poplevel (0, 0, 0);
14442
14443   DECL_INITIAL (fndecl) = old_initial;
14444
14445   /* We used to check if the context of FNDECL was different from
14446      current_class_type as another way to get inside here.  This didn't work
14447      for String.cc in libg++.  */
14448   if (DECL_FRIEND_P (fndecl))
14449     {
14450       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14451         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14452       decl = void_type_node;
14453     }
14454
14455   return decl;
14456 }
14457 \f
14458 /* Called when a new struct TYPE is defined.
14459    If this structure or union completes the type of any previous
14460    variable declaration, lay it out and output its rtl.  */
14461
14462 void
14463 hack_incomplete_structures (type)
14464      tree type;
14465 {
14466   tree *list;
14467   struct binding_level *level;
14468
14469   if (!type) /* Don't do this for class templates.  */
14470     return;
14471
14472   if (namespace_bindings_p ())
14473     {
14474       level = 0;
14475       list = &namespace_scope_incomplete;
14476     }
14477   else
14478     {
14479       level = innermost_nonclass_level ();
14480       list = &level->incomplete;
14481     }
14482
14483   while (1)
14484     {
14485       while (*list)
14486         {
14487           tree decl = TREE_VALUE (*list);
14488           if ((decl && TREE_TYPE (decl) == type)
14489               || (TREE_TYPE (decl)
14490                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14491                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14492             {
14493               int toplevel = toplevel_bindings_p ();
14494               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14495                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14496                 layout_type (TREE_TYPE (decl));
14497               layout_decl (decl, 0);
14498               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14499               if (! toplevel)
14500                 {
14501                   tree cleanup;
14502                   expand_decl (decl);
14503                   cleanup = maybe_build_cleanup (decl);
14504                   expand_decl_init (decl);
14505                   if (! expand_decl_cleanup (decl, cleanup))
14506                     cp_error ("parser lost in parsing declaration of `%D'",
14507                               decl);
14508                 }
14509               *list = TREE_CHAIN (*list);
14510             }
14511           else
14512             list = &TREE_CHAIN (*list);
14513         }
14514
14515       /* Keep looking through artificial binding levels generated
14516          for local variables.  */
14517       if (level && level->keep == 2)
14518         {
14519           level = level->level_chain;
14520           list = &level->incomplete;
14521         }
14522       else
14523         break;
14524     }
14525 }
14526
14527 /* If DECL is of a type which needs a cleanup, build that cleanup
14528    here.  */
14529
14530 tree
14531 maybe_build_cleanup (decl)
14532      tree decl;
14533 {
14534   tree type = TREE_TYPE (decl);
14535
14536   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14537     {
14538       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14539       tree rval;
14540
14541       if (TREE_CODE (type) == ARRAY_TYPE)
14542         rval = decl;
14543       else
14544         {
14545           mark_addressable (decl);
14546           rval = build_unary_op (ADDR_EXPR, decl, 0);
14547         }
14548
14549       /* Optimize for space over speed here.  */
14550       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14551           || flag_expensive_optimizations)
14552         flags |= LOOKUP_NONVIRTUAL;
14553
14554       rval = build_delete (TREE_TYPE (rval), rval,
14555                            sfk_complete_destructor, flags, 0);
14556
14557       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14558           && ! TYPE_HAS_DESTRUCTOR (type))
14559         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14560                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14561
14562       return rval;
14563     }
14564   return 0;
14565 }
14566 \f
14567 /* When a stmt has been parsed, this function is called.  */
14568
14569 void
14570 finish_stmt ()
14571 {
14572   /* Always assume this statement was not an expression statement.  If
14573      it actually was an expression statement, its our callers
14574      responsibility to fix this up.  */
14575   last_expr_type = NULL_TREE;
14576 }
14577
14578 /* DECL was originally constructed as a non-static member function,
14579    but turned out to be static.  Update it accordingly.  */
14580
14581 void
14582 revert_static_member_fn (decl)
14583      tree decl;
14584 {
14585   tree tmp;
14586   tree function = TREE_TYPE (decl);
14587   tree args = TYPE_ARG_TYPES (function);
14588
14589   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14590       != TYPE_UNQUALIFIED)
14591     cp_error ("static member function `%#D' declared with type qualifiers",
14592               *decl);
14593
14594   args = TREE_CHAIN (args);
14595   tmp = build_function_type (TREE_TYPE (function), args);
14596   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14597   tmp = build_exception_variant (tmp,
14598                                  TYPE_RAISES_EXCEPTIONS (function));
14599   TREE_TYPE (decl) = tmp;
14600   if (DECL_ARGUMENTS (decl))
14601     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14602   DECL_STATIC_FUNCTION_P (decl) = 1;
14603 }
14604
14605 /* Initialize the variables used during compilation of a C++
14606    function.  */
14607
14608 static void
14609 push_cp_function_context (f)
14610      struct function *f;
14611 {
14612   struct cp_language_function *p
14613     = ((struct cp_language_function *)
14614        xcalloc (1, sizeof (struct cp_language_function)));
14615   f->language = (struct language_function *) p;
14616
14617   /* It takes an explicit call to expand_body to generate RTL for a
14618      function.  */
14619   expanding_p = 0;
14620
14621   /* Whenever we start a new function, we destroy temporaries in the
14622      usual way.  */
14623   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14624 }
14625
14626 /* Free the language-specific parts of F, now that we've finished
14627    compiling the function.  */
14628
14629 static void
14630 pop_cp_function_context (f)
14631      struct function *f;
14632 {
14633   if (f->language)
14634     free (f->language);
14635   f->language = 0;
14636 }
14637
14638 /* Mark P for GC.  */
14639
14640 static void
14641 mark_lang_function (p)
14642      struct cp_language_function *p;
14643 {
14644   if (!p)
14645     return;
14646
14647   mark_c_language_function (&p->base);
14648
14649   ggc_mark_tree (p->x_ctor_label);
14650   ggc_mark_tree (p->x_dtor_label);
14651   ggc_mark_tree (p->x_current_class_ptr);
14652   ggc_mark_tree (p->x_current_class_ref);
14653   ggc_mark_tree (p->x_eh_spec_try_block);
14654
14655   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14656   mark_binding_level (&p->bindings);
14657 }
14658
14659 /* Mark the language-specific data in F for GC.  */
14660
14661 static void
14662 mark_cp_function_context (f)
14663      struct function *f;
14664 {
14665   mark_lang_function ((struct cp_language_function *) f->language);
14666 }
14667
14668 void
14669 lang_mark_tree (t)
14670      tree t;
14671 {
14672   enum tree_code code = TREE_CODE (t);
14673   if (code == IDENTIFIER_NODE)
14674     {
14675       struct lang_identifier *li = (struct lang_identifier *) t;
14676       struct lang_id2 *li2 = li->x;
14677       ggc_mark_tree (li->namespace_bindings);
14678       ggc_mark_tree (li->bindings);
14679       ggc_mark_tree (li->class_value);
14680       ggc_mark_tree (li->class_template_info);
14681
14682       if (li2)
14683         {
14684           ggc_mark_tree (li2->label_value);
14685           ggc_mark_tree (li2->implicit_decl);
14686           ggc_mark_tree (li2->error_locus);
14687         }
14688     }
14689   else if (code == CPLUS_BINDING)
14690     {
14691       if (BINDING_HAS_LEVEL_P (t))
14692         mark_binding_level (&BINDING_LEVEL (t));
14693       else
14694         ggc_mark_tree (BINDING_SCOPE (t));
14695       ggc_mark_tree (BINDING_VALUE (t));
14696     }
14697   else if (code == OVERLOAD)
14698     ggc_mark_tree (OVL_FUNCTION (t));
14699   else if (code == TEMPLATE_PARM_INDEX)
14700     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14701   else if (TREE_CODE_CLASS (code) == 'd')
14702     {
14703       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14704
14705       if (ld)
14706         {
14707           ggc_mark (ld);
14708           c_mark_lang_decl (&ld->decl_flags.base);
14709           if (!DECL_GLOBAL_CTOR_P (t)
14710               && !DECL_GLOBAL_DTOR_P (t)
14711               && !DECL_THUNK_P (t))
14712             ggc_mark_tree (ld->decl_flags.u2.access);
14713           else if (DECL_THUNK_P (t))
14714             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14715           if (TREE_CODE (t) != NAMESPACE_DECL)
14716             ggc_mark_tree (ld->decl_flags.u.template_info);
14717           else
14718             mark_binding_level (&NAMESPACE_LEVEL (t));
14719           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14720             {
14721               ggc_mark_tree (ld->befriending_classes);
14722               ggc_mark_tree (ld->context);
14723               ggc_mark_tree (ld->cloned_function);
14724               if (!DECL_OVERLOADED_OPERATOR_P (t))
14725                 ggc_mark_tree (ld->u2.vtt_parm);
14726               if (TREE_CODE (t) == TYPE_DECL)
14727                 ggc_mark_tree (ld->u.sorted_fields);
14728               else if (TREE_CODE (t) == FUNCTION_DECL
14729                        && !DECL_PENDING_INLINE_P (t))
14730                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14731             }
14732         }
14733     }
14734   else if (TREE_CODE_CLASS (code) == 't')
14735     {
14736       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14737
14738       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14739                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14740         {
14741           ggc_mark (lt);
14742           ggc_mark_tree (lt->primary_base);
14743           ggc_mark_tree (lt->vfields);
14744           ggc_mark_tree (lt->vbases);
14745           ggc_mark_tree (lt->tags);
14746           ggc_mark_tree (lt->size);
14747           ggc_mark_tree (lt->pure_virtuals);
14748           ggc_mark_tree (lt->friend_classes);
14749           ggc_mark_tree (lt->rtti);
14750           ggc_mark_tree (lt->methods);
14751           ggc_mark_tree (lt->template_info);
14752           ggc_mark_tree (lt->befriending_classes);
14753         }
14754       else if (lt)
14755         /* In the case of pointer-to-member function types, the
14756            TYPE_LANG_SPECIFIC is really just a tree.  */
14757         ggc_mark_tree ((tree) lt);
14758     }
14759 }