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 #include "tm_p.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree global_namespace;
  51
  52 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  53
  54 #ifndef BOOL_TYPE_SIZE
  55 #ifdef SLOW_BYTE_ACCESS
  56 /* In the new ABI, `bool' has size and alignment `1', on all
  57    platforms.  */
  58 #define BOOL_TYPE_SIZE \
  59   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  60 #else
  61 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  62 #endif
  63 #endif
  64
  65 /* We let tm.h override the types used here, to handle trivial differences
  66    such as the choice of unsigned int or long unsigned int for size_t.
  67    When machines start needing nontrivial differences in the size type,
  68    it would be best to do something here to figure out automatically
  69    from other information what type to use.  */
  70
  71 #ifndef SIZE_TYPE
  72 #define SIZE_TYPE "long unsigned int"
  73 #endif
  74
  75 #ifndef PTRDIFF_TYPE
  76 #define PTRDIFF_TYPE "long int"
  77 #endif
  78
  79 #ifndef WCHAR_TYPE
  80 #define WCHAR_TYPE "int"
  81 #endif
  82
  83 #ifndef WINT_TYPE
  84 #define WINT_TYPE "unsigned int"
  85 #endif
  86
  87 #ifndef INTMAX_TYPE
  88 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  89                      ? "int"                                    \
  90                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  91                         ? "long int"                            \
  92                         : "long long int"))
  93 #endif
  94
  95 #ifndef UINTMAX_TYPE
  96 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  97                      ? "unsigned int"                           \
  98                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  99                         ? "long unsigned int"                   \
 100                         : "long long unsigned int"))
 101 #endif
 102
 103 static tree grokparms                           PARAMS ((tree, int));
 104 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 105
 106 static void push_binding_level PARAMS ((struct binding_level *, int,
 107                                       int));
 108 static void pop_binding_level PARAMS ((void));
 109 static void suspend_binding_level PARAMS ((void));
 110 static void resume_binding_level PARAMS ((struct binding_level *));
 111 static struct binding_level *make_binding_level PARAMS ((void));
 112 static void declare_namespace_level PARAMS ((void));
 113 static int decl_jump_unsafe PARAMS ((tree));
 114 static void storedecls PARAMS ((tree));
 115 static void require_complete_types_for_parms PARAMS ((tree));
 116 static int ambi_op_p PARAMS ((enum tree_code));
 117 static int unary_op_p PARAMS ((enum tree_code));
 118 static tree store_bindings PARAMS ((tree, tree));
 119 static tree lookup_tag_reverse PARAMS ((tree, tree));
 120 static tree obscure_complex_init PARAMS ((tree, tree));
 121 static tree lookup_name_real PARAMS ((tree, int, int, int));
 122 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 123 static void grok_reference_init PARAMS ((tree, tree, tree));
 124 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 125                               enum overload_flags, tree,
 126                               tree, int, int, int, int, int, int, tree));
 127 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 128 static tree lookup_tag PARAMS ((enum tree_code, tree,
 129                               struct binding_level *, int));
 130 static void set_identifier_type_value_with_scope
 131         PARAMS ((tree, tree, struct binding_level *));
 132 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 133 static void record_unknown_type PARAMS ((tree, const char *));
 134 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 135 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 136 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 137                                   int));
 138 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 139 static void check_for_uninitialized_const_var PARAMS ((tree));
 140 static unsigned long typename_hash PARAMS ((hash_table_key));
 141 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 142 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 143 static int add_binding PARAMS ((tree, tree));
 144 static void pop_binding PARAMS ((tree, tree));
 145 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 146 static tree find_binding PARAMS ((tree, tree));
 147 static tree select_decl PARAMS ((tree, int));
 148 static int lookup_flags PARAMS ((int, int));
 149 static tree qualify_lookup PARAMS ((tree, int));
 150 static tree record_builtin_java_type PARAMS ((const char *, int));
 151 static const char *tag_name PARAMS ((enum tag_types code));
 152 static void find_class_binding_level PARAMS ((void));
 153 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 154 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 155 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 156 static int walk_globals_r PARAMS ((tree, void *));
 157 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 158 static tree make_label_decl PARAMS ((tree, int));
 159 static void use_label PARAMS ((tree));
 160 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 161                                            const char *, int));
 162 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 163 static void check_switch_goto PARAMS ((struct binding_level *));
 164 static void check_previous_gotos PARAMS ((tree));
 165 static void pop_label PARAMS ((tree, tree));
 166 static void pop_labels PARAMS ((tree));
 167 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 168 static void layout_var_decl PARAMS ((tree));
 169 static void maybe_commonize_var PARAMS ((tree));
 170 static tree check_initializer PARAMS ((tree, tree));
 171 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 172 static void push_cp_function_context PARAMS ((struct function *));
 173 static void pop_cp_function_context PARAMS ((struct function *));
 174 static void mark_binding_level PARAMS ((void *));
 175 static void mark_named_label_lists PARAMS ((void *, void *));
 176 static void mark_cp_function_context PARAMS ((struct function *));
 177 static void mark_saved_scope PARAMS ((void *));
 178 static void mark_lang_function PARAMS ((struct cp_language_function *));
 179 static void save_function_data PARAMS ((tree));
 180 static void check_function_type PARAMS ((tree, tree));
 181 static void destroy_local_var PARAMS ((tree));
 182 static void finish_constructor_body PARAMS ((void));
 183 static void finish_destructor_body PARAMS ((void));
 184 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 185 static tree get_atexit_node PARAMS ((void));
 186 static tree get_dso_handle_node PARAMS ((void));
 187 static tree start_cleanup_fn PARAMS ((void));
 188 static void end_cleanup_fn PARAMS ((void));
 189 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 190 static void initialize_predefined_identifiers PARAMS ((void));
 191 static tree check_special_function_return_type
 192   PARAMS ((special_function_kind, tree, tree, tree));
 193 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 194 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 195 static void store_parm_decls PARAMS ((tree));
 196
 197 #if defined (DEBUG_CP_BINDING_LEVELS)
 198 static void indent PARAMS ((void));
 199 #endif
 200
 201 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 202 tree error_mark_list;
 203
 204 /* The following symbols are subsumed in the cp_global_trees array, and
 205    listed here individually for documentation purposes.
 206
 207    C++ extensions
 208         tree wchar_decl_node;
 209
 210         tree vtable_entry_type;
 211         tree delta_type_node;
 212 #if 0
 213    Old rtti stuff.
 214         tree __baselist_desc_type_node;
 215         tree __i_desc_type_node, __m_desc_type_node;
 216         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 217 #endif
 218         tree __t_desc_type_node;
 219 #if 0
 220         tree __tp_desc_type_node;
 221 #endif
 222         tree ti_desc_type_node;
 223         tree bltn_desc_type_node, ptr_desc_type_node;
 224         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 225         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 226         tree ptm_desc_type_node;
 227         tree base_desc_type_node;
 228 #if 0
 229    Not needed yet?  May be needed one day?
 230         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 231         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 232         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 233 #endif
 234
 235         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 236         tree unknown_type_node;
 237
 238    Array type `vtable_entry_type[]'
 239
 240         tree vtbl_type_node;
 241         tree vtbl_ptr_type_node;
 242
 243    Namespaces,
 244
 245         tree std_node;
 246         tree abi_node;
 247
 248    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 249    one that the user will declare, but sufficient to be called
 250    by routines that want to abort the program.
 251
 252         tree abort_fndecl;
 253
 254    The FUNCTION_DECL for the default `::operator delete'.
 255
 256         tree global_delete_fndecl;
 257
 258    Used by RTTI
 259         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 260         tree tinfo_var_id;
 261
 262 */
 263
 264 tree cp_global_trees[CPTI_MAX];
 265
 266 /* Indicates that there is a type value in some namespace, although
 267    that is not necessarily in scope at the moment.  */
 268
 269 static tree global_type_node;
 270
 271 /* If non-zero, this is the number of times we have entered the `std'
 272    namespace when we are treating that namespace as an alias for the
 273    global namespace.  */
 274 static int in_fake_std;
 275
 276 /* Expect only namespace names now. */
 277 static int only_namespace_names;
 278
 279 /* Used only for jumps to as-yet undefined labels, since jumps to
 280    defined labels can have their validity checked immediately.  */
 281
 282 struct named_label_use_list
 283 {
 284   struct binding_level *binding_level;
 285   tree names_in_scope;
 286   tree label_decl;
 287   const char *filename_o_goto;
 288   int lineno_o_goto;
 289   struct named_label_use_list *next;
 290 };
 291
 292 #define named_label_uses cp_function_chain->x_named_label_uses
 293
 294 /* A list of objects which have constructors or destructors
 295    which reside in the global scope.  The decl is stored in
 296    the TREE_VALUE slot and the initializer is stored
 297    in the TREE_PURPOSE slot.  */
 298 tree static_aggregates;
 299
 300 /* -- end of C++ */
 301
 302 /* A node for the integer constants 2, and 3.  */
 303
 304 tree integer_two_node, integer_three_node;
 305
 306 /* Parsing a function declarator leaves here a chain of structure
 307    and enum types declared in the parmlist.  */
 308
 309 static tree last_function_parm_tags;
 310
 311 /* Similar, for last_function_parm_tags.  */
 312 tree last_function_parms;
 313 static tree current_function_parm_tags;
 314
 315 /* A list of all LABEL_DECLs in the function that have names.  Here so
 316    we can clear out their names' definitions at the end of the
 317    function, and so we can check the validity of jumps to these labels.  */
 318
 319 struct named_label_list
 320 {
 321   struct binding_level *binding_level;
 322   tree names_in_scope;
 323   tree old_value;
 324   tree label_decl;
 325   tree bad_decls;
 326   int eh_region;
 327   struct named_label_list *next;
 328 };
 329
 330 #define named_labels cp_function_chain->x_named_labels
 331
 332 /* Set to 0 at beginning of a function definition, and whenever
 333    a label (case or named) is defined.  Set to value of expression
 334    returned from function when that value can be transformed into
 335    a named return value.  */
 336
 337 tree current_function_return_value;
 338
 339 /* Nonzero means use the ISO C94 dialect of C.  */
 340
 341 int flag_isoc94;
 342
 343 /* Nonzero means use the ISO C99 dialect of C.  */
 344
 345 int flag_isoc99;
 346
 347 /* Nonzero means we are a hosted implementation for code shared with C.  */
 348
 349 int flag_hosted = 1;
 350
 351 /* Nonzero means add default format_arg attributes for functions not
 352    in ISO C.  */
 353
 354 int flag_noniso_default_format_attributes = 1;
 355
 356 /* Nonzero means give `double' the same size as `float'.  */
 357
 358 extern int flag_short_double;
 359
 360 /* Nonzero if we want to conserve space in the .o files.  We do this
 361    by putting uninitialized data and runtime initialized data into
 362    .common instead of .data at the expense of not flagging multiple
 363    definitions.  */
 364 extern int flag_conserve_space;
 365 \f
 366 /* C and C++ flags are in decl2.c.  */
 367
 368 /* Flag used when debugging spew.c */
 369
 370 extern int spew_debug;
 371
 372 /* A expression of value 0 with the same precision as a sizetype
 373    node, but signed.  */
 374 tree signed_size_zero_node;
 375
 376 /* The name of the anonymous namespace, throughout this translation
 377    unit.  */
 378 tree anonymous_namespace_name;
 379
 380 /* The number of function bodies which we are currently processing.
 381    (Zero if we are at namespace scope, one inside the body of a
 382    function, two inside the body of a function in a local class, etc.)  */
 383 int function_depth;
 384 \f
 385 /* For each binding contour we allocate a binding_level structure
 386    which records the names defined in that contour.
 387    Contours include:
 388     0) the global one
 389     1) one for each function definition,
 390        where internal declarations of the parameters appear.
 391     2) one for each compound statement,
 392        to record its declarations.
 393
 394    The current meaning of a name can be found by searching the levels
 395    from the current one out to the global one.
 396
 397    Off to the side, may be the class_binding_level.  This exists only
 398    to catch class-local declarations.  It is otherwise nonexistent.
 399
 400    Also there may be binding levels that catch cleanups that must be
 401    run when exceptions occur.  Thus, to see whether a name is bound in
 402    the current scope, it is not enough to look in the
 403    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 404    instead.  */
 405
 406 /* Note that the information in the `names' component of the global contour
 407    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 408
 409 struct binding_level
 410   {
 411     /* A chain of _DECL nodes for all variables, constants, functions,
 412        and typedef types.  These are in the reverse of the order
 413        supplied.  There may be OVERLOADs on this list, too, but they
 414        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 415     tree names;
 416
 417     /* A list of structure, union and enum definitions, for looking up
 418        tag names.
 419        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 420        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 421        or ENUMERAL_TYPE node.
 422
 423        C++: the TREE_VALUE nodes can be simple types for
 424        component_bindings.  */
 425     tree tags;
 426
 427     /* A list of USING_DECL nodes. */
 428     tree usings;
 429
 430     /* A list of used namespaces. PURPOSE is the namespace,
 431        VALUE the common ancestor with this binding_level's namespace. */
 432     tree using_directives;
 433
 434     /* If this binding level is the binding level for a class, then
 435        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 436        is the name of an entity bound in the class; the TREE_VALUE is
 437        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 438        when leaving class scope, we can restore the
 439        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 440        the DECL bound by this name in the class.  */
 441     tree class_shadowed;
 442
 443     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 444        is used for all binding levels.  */
 445     tree type_shadowed;
 446
 447     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 448        label in this scope.  The TREE_PURPOSE is the previous value of
 449        the IDENTIFIER_LABEL VALUE.  */
 450     tree shadowed_labels;
 451
 452     /* For each level (except not the global one),
 453        a chain of BLOCK nodes for all the levels
 454        that were entered and exited one level down.  */
 455     tree blocks;
 456
 457     /* The _TYPE node for this level, if parm_flag == 2.  */
 458     tree this_class;
 459
 460     /* The binding level which this one is contained in (inherits from).  */
 461     struct binding_level *level_chain;
 462
 463     /* List of decls in `names' that have incomplete
 464        structure or union types.  */
 465     tree incomplete;
 466
 467     /* List of VAR_DECLS saved from a previous for statement.
 468        These would be dead in ISO-conforming code, but might
 469        be referenced in ARM-era code.  These are stored in a
 470        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 471     tree dead_vars_from_for;
 472
 473     /* 1 for the level that holds the parameters of a function.
 474        2 for the level that holds a class declaration.  */
 475     unsigned parm_flag : 2;
 476
 477     /* 1 means make a BLOCK for this level regardless of all else.
 478        2 for temporary binding contours created by the compiler.  */
 479     unsigned keep : 2;
 480
 481     /* Nonzero if this level "doesn't exist" for tags.  */
 482     unsigned tag_transparent : 1;
 483
 484     /* Nonzero if this level can safely have additional
 485        cleanup-needing variables added to it.  */
 486     unsigned more_cleanups_ok : 1;
 487     unsigned have_cleanups : 1;
 488
 489     /* Nonzero if this scope is for storing the decls for template
 490        parameters and generic decls; these decls will be discarded and
 491        replaced with a TEMPLATE_DECL.  */
 492     unsigned template_parms_p : 1;
 493
 494     /* Nonzero if this scope corresponds to the `<>' in a
 495        `template <>' clause.  Whenever this flag is set,
 496        TEMPLATE_PARMS_P will be set as well.  */
 497     unsigned template_spec_p : 1;
 498
 499     /* This is set for a namespace binding level.  */
 500     unsigned namespace_p : 1;
 501
 502     /* True if this level is that of a for-statement where we need to
 503        worry about ambiguous (ARM or ISO) scope rules.  */
 504     unsigned is_for_scope : 1;
 505
 506     /* True if this level corresponds to an EH region, as for a try block.
 507        Currently this information is only available while building the
 508        tree structure.  */
 509     unsigned eh_region : 1;
 510
 511     /* Four bits left for this word.  */
 512
 513 #if defined(DEBUG_CP_BINDING_LEVELS)
 514     /* Binding depth at which this level began.  */
 515     unsigned binding_depth;
 516 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 517   };
 518
 519 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 520
 521 /* The binding level currently in effect.  */
 522
 523 #define current_binding_level                   \
 524   (cfun                                         \
 525    ? cp_function_chain->bindings                \
 526    : scope_chain->bindings)
 527
 528 /* The binding level of the current class, if any.  */
 529
 530 #define class_binding_level scope_chain->class_bindings
 531
 532 /* A chain of binding_level structures awaiting reuse.  */
 533
 534 static struct binding_level *free_binding_level;
 535
 536 /* The outermost binding level, for names of file scope.
 537    This is created when the compiler is started and exists
 538    through the entire run.  */
 539
 540 static struct binding_level *global_binding_level;
 541
 542 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 543
 544 static int keep_next_level_flag;
 545
 546 #if defined(DEBUG_CP_BINDING_LEVELS)
 547 static int binding_depth = 0;
 548 static int is_class_level = 0;
 549
 550 static void
 551 indent ()
 552 {
 553   register unsigned i;
 554
 555   for (i = 0; i < binding_depth*2; i++)
 556     putc (' ', stderr);
 557 }
 558 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 559
 560 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 561
 562 static void
 563 push_binding_level (newlevel, tag_transparent, keep)
 564      struct binding_level *newlevel;
 565      int tag_transparent, keep;
 566 {
 567   /* Add this level to the front of the chain (stack) of levels that
 568      are active.  */
 569   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 570   newlevel->level_chain = current_binding_level;
 571   current_binding_level = newlevel;
 572   newlevel->tag_transparent = tag_transparent;
 573   newlevel->more_cleanups_ok = 1;
 574
 575   newlevel->keep = keep;
 576 #if defined(DEBUG_CP_BINDING_LEVELS)
 577   newlevel->binding_depth = binding_depth;
 578   indent ();
 579   fprintf (stderr, "push %s level 0x%08x line %d\n",
 580            (is_class_level) ? "class" : "block", newlevel, lineno);
 581   is_class_level = 0;
 582   binding_depth++;
 583 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 584 }
 585
 586 /* Find the innermost enclosing class scope, and reset
 587    CLASS_BINDING_LEVEL appropriately.  */
 588
 589 static void
 590 find_class_binding_level ()
 591 {
 592   struct binding_level *level = current_binding_level;
 593
 594   while (level && level->parm_flag != 2)
 595     level = level->level_chain;
 596   if (level && level->parm_flag == 2)
 597     class_binding_level = level;
 598   else
 599     class_binding_level = 0;
 600 }
 601
 602 static void
 603 pop_binding_level ()
 604 {
 605   if (global_binding_level)
 606     {
 607       /* Cannot pop a level, if there are none left to pop.  */
 608       if (current_binding_level == global_binding_level)
 609         my_friendly_abort (123);
 610     }
 611   /* Pop the current level, and free the structure for reuse.  */
 612 #if defined(DEBUG_CP_BINDING_LEVELS)
 613   binding_depth--;
 614   indent ();
 615   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 616           (is_class_level) ? "class" : "block",
 617           current_binding_level, lineno);
 618   if (is_class_level != (current_binding_level == class_binding_level))
 619     {
 620       indent ();
 621       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 622     }
 623   is_class_level = 0;
 624 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 625   {
 626     register struct binding_level *level = current_binding_level;
 627     current_binding_level = current_binding_level->level_chain;
 628     level->level_chain = free_binding_level;
 629 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 630     if (level->binding_depth != binding_depth)
 631       abort ();
 632 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 633     free_binding_level = level;
 634     find_class_binding_level ();
 635   }
 636 }
 637
 638 static void
 639 suspend_binding_level ()
 640 {
 641   if (class_binding_level)
 642     current_binding_level = class_binding_level;
 643
 644   if (global_binding_level)
 645     {
 646       /* Cannot suspend a level, if there are none left to suspend.  */
 647       if (current_binding_level == global_binding_level)
 648         my_friendly_abort (123);
 649     }
 650   /* Suspend the current level.  */
 651 #if defined(DEBUG_CP_BINDING_LEVELS)
 652   binding_depth--;
 653   indent ();
 654   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 655           (is_class_level) ? "class" : "block",
 656           current_binding_level, lineno);
 657   if (is_class_level != (current_binding_level == class_binding_level))
 658     {
 659       indent ();
 660       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 661     }
 662   is_class_level = 0;
 663 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 664   current_binding_level = current_binding_level->level_chain;
 665   find_class_binding_level ();
 666 }
 667
 668 static void
 669 resume_binding_level (b)
 670      struct binding_level *b;
 671 {
 672   /* Resuming binding levels is meant only for namespaces,
 673      and those cannot nest into classes. */
 674   my_friendly_assert(!class_binding_level, 386);
 675   /* Also, resuming a non-directly nested namespace is a no-no.  */
 676   my_friendly_assert(b->level_chain == current_binding_level, 386);
 677   current_binding_level = b;
 678 #if defined(DEBUG_CP_BINDING_LEVELS)
 679   b->binding_depth = binding_depth;
 680   indent ();
 681   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 682            (is_class_level) ? "class" : "block", b, lineno);
 683   is_class_level = 0;
 684   binding_depth++;
 685 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 686 }
 687 \f
 688 /* Create a new `struct binding_level'.  */
 689
 690 static
 691 struct binding_level *
 692 make_binding_level ()
 693 {
 694   /* NOSTRICT */
 695   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 696 }
 697
 698 /* Nonzero if we are currently in the global binding level.  */
 699
 700 int
 701 global_bindings_p ()
 702 {
 703   return current_binding_level == global_binding_level;
 704 }
 705
 706 /* Return the innermost binding level that is not for a class scope.  */
 707
 708 static struct binding_level *
 709 innermost_nonclass_level ()
 710 {
 711   struct binding_level *b;
 712
 713   b = current_binding_level;
 714   while (b->parm_flag == 2)
 715     b = b->level_chain;
 716
 717   return b;
 718 }
 719
 720 /* Nonzero if we are currently in a toplevel binding level.  This
 721    means either the global binding level or a namespace in a toplevel
 722    binding level.  Since there are no non-toplevel namespace levels,
 723    this really means any namespace or template parameter level.  We
 724    also include a class whose context is toplevel.  */
 725
 726 int
 727 toplevel_bindings_p ()
 728 {
 729   struct binding_level *b = innermost_nonclass_level ();
 730
 731   return b->namespace_p || b->template_parms_p;
 732 }
 733
 734 /* Nonzero if this is a namespace scope, or if we are defining a class
 735    which is itself at namespace scope, or whose enclosing class is
 736    such a class, etc.  */
 737
 738 int
 739 namespace_bindings_p ()
 740 {
 741   struct binding_level *b = innermost_nonclass_level ();
 742
 743   return b->namespace_p;
 744 }
 745
 746 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 747    unconditionally.  Otherwise, use the normal logic to decide whether
 748    or not to create a BLOCK.  */
 749
 750 void
 751 keep_next_level (keep)
 752      int keep;
 753 {
 754   keep_next_level_flag = keep;
 755 }
 756
 757 /* Nonzero if the current level needs to have a BLOCK made.  */
 758
 759 int
 760 kept_level_p ()
 761 {
 762   return (current_binding_level->blocks != NULL_TREE
 763           || current_binding_level->keep
 764           || current_binding_level->names != NULL_TREE
 765           || (current_binding_level->tags != NULL_TREE
 766               && !current_binding_level->tag_transparent));
 767 }
 768
 769 static void
 770 declare_namespace_level ()
 771 {
 772   current_binding_level->namespace_p = 1;
 773 }
 774
 775 /* Returns non-zero if this scope was created to store template
 776    parameters.  */
 777
 778 int
 779 template_parm_scope_p ()
 780 {
 781   return current_binding_level->template_parms_p;
 782 }
 783
 784 /* Returns the kind of template specialization we are currently
 785    processing, given that it's declaration contained N_CLASS_SCOPES
 786    explicit scope qualifications.  */
 787
 788 tmpl_spec_kind
 789 current_tmpl_spec_kind (n_class_scopes)
 790      int n_class_scopes;
 791 {
 792   int n_template_parm_scopes = 0;
 793   int seen_specialization_p = 0;
 794   int innermost_specialization_p = 0;
 795   struct binding_level *b;
 796
 797   /* Scan through the template parameter scopes.  */
 798   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 799     {
 800       /* If we see a specialization scope inside a parameter scope,
 801          then something is wrong.  That corresponds to a declaration
 802          like:
 803
 804             template <class T> template <> ...
 805
 806          which is always illegal since [temp.expl.spec] forbids the
 807          specialization of a class member template if the enclosing
 808          class templates are not explicitly specialized as well.  */
 809       if (b->template_spec_p)
 810         {
 811           if (n_template_parm_scopes == 0)
 812             innermost_specialization_p = 1;
 813           else
 814             seen_specialization_p = 1;
 815         }
 816       else if (seen_specialization_p == 1)
 817         return tsk_invalid_member_spec;
 818
 819       ++n_template_parm_scopes;
 820     }
 821
 822   /* Handle explicit instantiations.  */
 823   if (processing_explicit_instantiation)
 824     {
 825       if (n_template_parm_scopes != 0)
 826         /* We've seen a template parameter list during an explicit
 827            instantiation.  For example:
 828
 829              template <class T> template void f(int);
 830
 831            This is erroneous.  */
 832         return tsk_invalid_expl_inst;
 833       else
 834         return tsk_expl_inst;
 835     }
 836
 837   if (n_template_parm_scopes < n_class_scopes)
 838     /* We've not seen enough template headers to match all the
 839        specialized classes present.  For example:
 840
 841          template <class T> void R<T>::S<T>::f(int);
 842
 843        This is illegal; there needs to be one set of template
 844        parameters for each class.  */
 845     return tsk_insufficient_parms;
 846   else if (n_template_parm_scopes == n_class_scopes)
 847     /* We're processing a non-template declaration (even though it may
 848        be a member of a template class.)  For example:
 849
 850          template <class T> void S<T>::f(int);
 851
 852        The `class T' maches the `S<T>', leaving no template headers
 853        corresponding to the `f'.  */
 854     return tsk_none;
 855   else if (n_template_parm_scopes > n_class_scopes + 1)
 856     /* We've got too many template headers.  For example:
 857
 858          template <> template <class T> void f (T);
 859
 860        There need to be more enclosing classes.  */
 861     return tsk_excessive_parms;
 862   else
 863     /* This must be a template.  It's of the form:
 864
 865          template <class T> template <class U> void S<T>::f(U);
 866
 867        This is a specialization if the innermost level was a
 868        specialization; otherwise it's just a definition of the
 869        template.  */
 870     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 871 }
 872
 873 void
 874 set_class_shadows (shadows)
 875      tree shadows;
 876 {
 877   class_binding_level->class_shadowed = shadows;
 878 }
 879
 880 /* Enter a new binding level.
 881    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 882    not for that of tags.  */
 883
 884 void
 885 pushlevel (tag_transparent)
 886      int tag_transparent;
 887 {
 888   struct binding_level *newlevel;
 889
 890   if (cfun && !doing_semantic_analysis_p ())
 891     return;
 892
 893   /* Reuse or create a struct for this binding level.  */
 894 #if defined(DEBUG_CP_BINDING_LEVELS)
 895   if (0)
 896 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 897   if (free_binding_level)
 898 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 899     {
 900       newlevel = free_binding_level;
 901       free_binding_level = free_binding_level->level_chain;
 902     }
 903   else
 904     newlevel = make_binding_level ();
 905
 906   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 907   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 908   keep_next_level_flag = 0;
 909 }
 910
 911 /* Enter a new scope.  The KIND indicates what kind of scope is being
 912    created.  */
 913
 914 void
 915 begin_scope (sk)
 916      scope_kind sk;
 917 {
 918   pushlevel (0);
 919
 920   switch (sk)
 921     {
 922     case sk_template_spec:
 923       current_binding_level->template_spec_p = 1;
 924       /* Fall through.  */
 925
 926     case sk_template_parms:
 927       current_binding_level->template_parms_p = 1;
 928       break;
 929
 930     default:
 931       my_friendly_abort (20000309);
 932     }
 933 }
 934
 935 /* Exit the current scope.  */
 936
 937 void
 938 finish_scope ()
 939 {
 940   poplevel (0, 0, 0);
 941 }
 942
 943 void
 944 note_level_for_for ()
 945 {
 946   current_binding_level->is_for_scope = 1;
 947 }
 948
 949 /* Record that the current binding level represents a try block.  */
 950
 951 void
 952 note_level_for_eh ()
 953 {
 954   current_binding_level->eh_region = 1;
 955 }
 956
 957 /* For a binding between a name and an entity at a block scope,
 958    this is the `struct binding_level' for the block.  */
 959 #define BINDING_LEVEL(NODE) \
 960    (((struct tree_binding*)NODE)->scope.level)
 961
 962 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 963    level at which this declaration is being bound.  */
 964
 965 static void
 966 push_binding (id, decl, level)
 967      tree id;
 968      tree decl;
 969      struct binding_level* level;
 970 {
 971   tree binding;
 972
 973   binding = make_node (CPLUS_BINDING);
 974
 975   /* Now, fill in the binding information.  */
 976   BINDING_VALUE (binding) = decl;
 977   BINDING_TYPE (binding) = NULL_TREE;
 978   BINDING_LEVEL (binding) = level;
 979   INHERITED_VALUE_BINDING_P (binding) = 0;
 980   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 981   BINDING_HAS_LEVEL_P (binding) = 1;
 982
 983   /* And put it on the front of the list of bindings for ID.  */
 984   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 985   IDENTIFIER_BINDING (id) = binding;
 986 }
 987
 988 /* ID is already bound in the current scope.  But, DECL is an
 989    additional binding for ID in the same scope.  This is the `struct
 990    stat' hack whereby a non-typedef class-name or enum-name can be
 991    bound at the same level as some other kind of entity.  It's the
 992    responsibility of the caller to check that inserting this name is
 993    legal here.  Returns nonzero if the new binding was successful.  */
 994 static int
 995 add_binding (id, decl)
 996      tree id;
 997      tree decl;
 998 {
 999   tree binding = IDENTIFIER_BINDING (id);
1000   int ok = 1;
1001
1002   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1003     /* The new name is the type name.  */
1004     BINDING_TYPE (binding) = decl;
1005   else if (!BINDING_VALUE (binding))
1006     /* This situation arises when push_class_level_binding moves an
1007        inherited type-binding out of the way to make room for a new
1008        value binding.  */
1009     BINDING_VALUE (binding) = decl;
1010   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1011            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1012     {
1013       /* The old binding was a type name.  It was placed in
1014          BINDING_VALUE because it was thought, at the point it was
1015          declared, to be the only entity with such a name.  Move the
1016          type name into the type slot; it is now hidden by the new
1017          binding.  */
1018       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1019       BINDING_VALUE (binding) = decl;
1020       INHERITED_VALUE_BINDING_P (binding) = 0;
1021     }
1022   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1023            && TREE_CODE (decl) == TYPE_DECL
1024            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1025            && same_type_p (TREE_TYPE (decl),
1026                            TREE_TYPE (BINDING_VALUE (binding))))
1027     /* We have two typedef-names, both naming the same type to have
1028        the same name.  This is OK because of:
1029
1030          [dcl.typedef]
1031
1032          In a given scope, a typedef specifier can be used to redefine
1033          the name of any type declared in that scope to refer to the
1034          type to which it already refers.  */
1035     ok = 0;
1036   /* There can be two block-scope declarations of the same variable,
1037      so long as they are `extern' declarations.  */
1038   else if (TREE_CODE (decl) == VAR_DECL
1039            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1040            && DECL_EXTERNAL (decl)
1041            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1042     {
1043       duplicate_decls (decl, BINDING_VALUE (binding));
1044       ok = 0;
1045     }
1046   else
1047     {
1048       cp_error ("declaration of `%#D'", decl);
1049       cp_error_at ("conflicts with previous declaration `%#D'",
1050                    BINDING_VALUE (binding));
1051       ok = 0;
1052     }
1053
1054   return ok;
1055 }
1056
1057 /* Add DECL to the list of things declared in B.  */
1058
1059 static void
1060 add_decl_to_level (decl, b)
1061      tree decl;
1062      struct binding_level *b;
1063 {
1064   /* We build up the list in reverse order, and reverse it later if
1065      necessary.  */
1066   TREE_CHAIN (decl) = b->names;
1067   b->names = decl;
1068 }
1069
1070 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1071    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1072    doesn't really belong to this binding level, that it got here
1073    through a using-declaration.  */
1074
1075 void
1076 push_local_binding (id, decl, flags)
1077      tree id;
1078      tree decl;
1079      int flags;
1080 {
1081   struct binding_level *b;
1082
1083   /* Skip over any local classes.  This makes sense if we call
1084      push_local_binding with a friend decl of a local class.  */
1085   b = current_binding_level;
1086   while (b->parm_flag == 2)
1087     b = b->level_chain;
1088
1089   if (lookup_name_current_level (id))
1090     {
1091       /* Supplement the existing binding.  */
1092       if (!add_binding (id, decl))
1093         /* It didn't work.  Something else must be bound at this
1094            level.  Do not add DECL to the list of things to pop
1095            later.  */
1096         return;
1097     }
1098   else
1099     /* Create a new binding.  */
1100     push_binding (id, decl, b);
1101
1102   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1103     /* We must put the OVERLOAD into a TREE_LIST since the
1104        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1105        decls that got here through a using-declaration.  */
1106     decl = build_tree_list (NULL_TREE, decl);
1107
1108   /* And put DECL on the list of things declared by the current
1109      binding level.  */
1110   add_decl_to_level (decl, b);
1111 }
1112
1113 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1114    binding was successful.  */
1115
1116 int
1117 push_class_binding (id, decl)
1118      tree id;
1119      tree decl;
1120 {
1121   int result = 1;
1122   tree binding = IDENTIFIER_BINDING (id);
1123   tree context;
1124
1125   /* Note that we declared this value so that we can issue an error if
1126      this an illegal redeclaration of a name already used for some
1127      other purpose.  */
1128   note_name_declared_in_class (id, decl);
1129
1130   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1131     /* Supplement the existing binding.  */
1132     result = add_binding (id, decl);
1133   else
1134     /* Create a new binding.  */
1135     push_binding (id, decl, class_binding_level);
1136
1137   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1138      class-level declaration.  Note that we do not use DECL here
1139      because of the possibility of the `struct stat' hack; if DECL is
1140      a class-name or enum-name we might prefer a field-name, or some
1141      such.  */
1142   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1143
1144   /* If this is a binding from a base class, mark it as such.  */
1145   binding = IDENTIFIER_BINDING (id);
1146   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1147     {
1148       /* Any implicit typename must be from a base-class.  The
1149          context for an implicit typename declaration is always
1150          the derived class in which the lookup was done, so the checks
1151          based on the context of DECL below will not trigger.  */
1152       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1153         INHERITED_VALUE_BINDING_P (binding) = 1;
1154       else
1155         {
1156           if (TREE_CODE (decl) == OVERLOAD)
1157             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1158           else
1159             {
1160               my_friendly_assert (DECL_P (decl), 0);
1161               context = CP_DECL_CONTEXT (decl);
1162             }
1163
1164           if (is_properly_derived_from (current_class_type, context))
1165             INHERITED_VALUE_BINDING_P (binding) = 1;
1166           else
1167             INHERITED_VALUE_BINDING_P (binding) = 0;
1168         }
1169     }
1170   else if (BINDING_VALUE (binding) == decl)
1171     /* We only encounter a TREE_LIST when push_class_decls detects an
1172        ambiguity.  Such an ambiguity can be overridden by a definition
1173        in this class.  */
1174     INHERITED_VALUE_BINDING_P (binding) = 1;
1175
1176   return result;
1177 }
1178
1179 /* Remove the binding for DECL which should be the innermost binding
1180    for ID.  */
1181
1182 static void
1183 pop_binding (id, decl)
1184      tree id;
1185      tree decl;
1186 {
1187   tree binding;
1188
1189   if (id == NULL_TREE)
1190     /* It's easiest to write the loops that call this function without
1191        checking whether or not the entities involved have names.  We
1192        get here for such an entity.  */
1193     return;
1194
1195   /* Get the innermost binding for ID.  */
1196   binding = IDENTIFIER_BINDING (id);
1197
1198   /* The name should be bound.  */
1199   my_friendly_assert (binding != NULL_TREE, 0);
1200
1201   /* The DECL will be either the ordinary binding or the type
1202      binding for this identifier.  Remove that binding.  */
1203   if (BINDING_VALUE (binding) == decl)
1204     BINDING_VALUE (binding) = NULL_TREE;
1205   else if (BINDING_TYPE (binding) == decl)
1206     BINDING_TYPE (binding) = NULL_TREE;
1207   else
1208     my_friendly_abort (0);
1209
1210   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1211     /* We're completely done with the innermost binding for this
1212        identifier.  Unhook it from the list of bindings.  */
1213     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1214 }
1215
1216 /* When a label goes out of scope, check to see if that label was used
1217    in a valid manner, and issue any appropriate warnings or errors.  */
1218
1219 static void
1220 pop_label (label, old_value)
1221      tree label;
1222      tree old_value;
1223 {
1224   if (!processing_template_decl && doing_semantic_analysis_p ())
1225     {
1226       if (DECL_INITIAL (label) == NULL_TREE)
1227         {
1228           cp_error_at ("label `%D' used but not defined", label);
1229           /* Avoid crashing later.  */
1230           define_label (input_filename, 1, DECL_NAME (label));
1231         }
1232       else if (warn_unused_label && !TREE_USED (label))
1233         cp_warning_at ("label `%D' defined but not used", label);
1234     }
1235
1236   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1237 }
1238
1239 /* At the end of a function, all labels declared within the function
1240    go out of scope.  BLOCK is the top-level block for the
1241    function.  */
1242
1243 static void
1244 pop_labels (block)
1245      tree block;
1246 {
1247   struct named_label_list *link;
1248
1249   /* Clear out the definitions of all label names, since their scopes
1250      end here.  */
1251   for (link = named_labels; link; link = link->next)
1252     {
1253       pop_label (link->label_decl, link->old_value);
1254       /* Put the labels into the "variables" of the top-level block,
1255          so debugger can see them.  */
1256       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1257       BLOCK_VARS (block) = link->label_decl;
1258     }
1259
1260   named_labels = NULL;
1261 }
1262
1263 /* Exit a binding level.
1264    Pop the level off, and restore the state of the identifier-decl mappings
1265    that were in effect when this level was entered.
1266
1267    If KEEP == 1, this level had explicit declarations, so
1268    and create a "block" (a BLOCK node) for the level
1269    to record its declarations and subblocks for symbol table output.
1270
1271    If FUNCTIONBODY is nonzero, this level is the body of a function,
1272    so create a block as if KEEP were set and also clear out all
1273    label names.
1274
1275    If REVERSE is nonzero, reverse the order of decls before putting
1276    them into the BLOCK.  */
1277
1278 tree
1279 poplevel (keep, reverse, functionbody)
1280      int keep;
1281      int reverse;
1282      int functionbody;
1283 {
1284   register tree link;
1285   /* The chain of decls was accumulated in reverse order.
1286      Put it into forward order, just for cleanliness.  */
1287   tree decls;
1288   int tmp = functionbody;
1289   int real_functionbody;
1290   tree tags;
1291   tree subblocks;
1292   tree block = NULL_TREE;
1293   tree decl;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->eh_region)
1338                   labels->eh_region = 1;
1339                 for (decl = labels->names_in_scope; decl;
1340                      decl = TREE_CHAIN (decl))
1341                   if (decl_jump_unsafe (decl))
1342                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1343                                                    labels->bad_decls);
1344                 labels->binding_level = level_chain;
1345                 labels->names_in_scope = level_chain->names;
1346               }
1347
1348           for (uses = named_label_uses; uses; uses = uses->next)
1349             if (uses->binding_level == current_binding_level)
1350               {
1351                 uses->binding_level = level_chain;
1352                 uses->names_in_scope = level_chain->names;
1353               }
1354         }
1355     }
1356
1357   /* Get the decls in the order they were written.
1358      Usually current_binding_level->names is in reverse order.
1359      But parameter decls were previously put in forward order.  */
1360
1361   if (reverse)
1362     current_binding_level->names
1363       = decls = nreverse (current_binding_level->names);
1364   else
1365     decls = current_binding_level->names;
1366
1367   /* Output any nested inline functions within this block
1368      if they weren't already output.  */
1369   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1370     if (TREE_CODE (decl) == FUNCTION_DECL
1371         && ! TREE_ASM_WRITTEN (decl)
1372         && DECL_INITIAL (decl) != NULL_TREE
1373         && TREE_ADDRESSABLE (decl)
1374         && decl_function_context (decl) == current_function_decl)
1375       {
1376         /* If this decl was copied from a file-scope decl
1377            on account of a block-scope extern decl,
1378            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1379         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1380           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1381         else
1382           {
1383             push_function_context ();
1384             output_inline_function (decl);
1385             pop_function_context ();
1386           }
1387       }
1388
1389   /* When not in function-at-a-time mode, expand_end_bindings will
1390      warn about unused variables.  But, in function-at-a-time mode
1391      expand_end_bindings is not passed the list of variables in the
1392      current scope, and therefore no warning is emitted.  So, we
1393      explicitly warn here.  */
1394   if (!processing_template_decl)
1395     warn_about_unused_variables (getdecls ());
1396
1397   /* If there were any declarations or structure tags in that level,
1398      or if this level is a function body,
1399      create a BLOCK to record them for the life of this function.  */
1400   block = NULL_TREE;
1401   if (keep == 1 || functionbody)
1402     block = make_node (BLOCK);
1403   if (block != NULL_TREE)
1404     {
1405       BLOCK_VARS (block) = decls;
1406       BLOCK_SUBBLOCKS (block) = subblocks;
1407     }
1408
1409   /* In each subblock, record that this is its superior.  */
1410   if (keep >= 0)
1411     for (link = subblocks; link; link = TREE_CHAIN (link))
1412       BLOCK_SUPERCONTEXT (link) = block;
1413
1414   /* We still support the old for-scope rules, whereby the variables
1415      in a for-init statement were in scope after the for-statement
1416      ended.  We only use the new rules in flag_new_for_scope is
1417      nonzero.  */
1418   leaving_for_scope
1419     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1420
1421   /* Remove declarations for all the DECLs in this level.  */
1422   for (link = decls; link; link = TREE_CHAIN (link))
1423     {
1424       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1425           && DECL_NAME (link))
1426         {
1427           tree outer_binding
1428             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1429           tree ns_binding;
1430
1431           if (!outer_binding)
1432             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1433           else
1434             ns_binding = NULL_TREE;
1435
1436           if (outer_binding
1437               && (BINDING_LEVEL (outer_binding)
1438                   == current_binding_level->level_chain))
1439             /* We have something like:
1440
1441                  int i;
1442                  for (int i; ;);
1443
1444                and we are leaving the `for' scope.  There's no reason to
1445                keep the binding of the inner `i' in this case.  */
1446             pop_binding (DECL_NAME (link), link);
1447           else if ((outer_binding
1448                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1449                         == TYPE_DECL))
1450                    || (ns_binding
1451                        && TREE_CODE (ns_binding) == TYPE_DECL))
1452             /* Here, we have something like:
1453
1454                  typedef int I;
1455
1456                  void f () {
1457                    for (int I; ;);
1458                  }
1459
1460                We must pop the for-scope binding so we know what's a
1461                type and what isn't.  */
1462             pop_binding (DECL_NAME (link), link);
1463           else
1464             {
1465               /* Mark this VAR_DECL as dead so that we can tell we left it
1466                  there only for backward compatibility.  */
1467               DECL_DEAD_FOR_LOCAL (link) = 1;
1468
1469               /* Keep track of what should of have happenned when we
1470                  popped the binding.  */
1471               if (outer_binding && BINDING_VALUE (outer_binding))
1472                 DECL_SHADOWED_FOR_VAR (link)
1473                   = BINDING_VALUE (outer_binding);
1474
1475               /* Add it to the list of dead variables in the next
1476                  outermost binding to that we can remove these when we
1477                  leave that binding.  */
1478               current_binding_level->level_chain->dead_vars_from_for
1479                 = tree_cons (NULL_TREE, link,
1480                              current_binding_level->level_chain->
1481                              dead_vars_from_for);
1482
1483               /* Although we don't pop the CPLUS_BINDING, we do clear
1484                  its BINDING_LEVEL since the level is going away now.  */
1485               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1486                 = 0;
1487             }
1488         }
1489       else
1490         {
1491           /* Remove the binding.  */
1492           decl = link;
1493           if (TREE_CODE (decl) == TREE_LIST)
1494             decl = TREE_VALUE (decl);
1495           if (DECL_P (decl))
1496             pop_binding (DECL_NAME (decl), decl);
1497           else if (TREE_CODE (decl) == OVERLOAD)
1498             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1499           else
1500             my_friendly_abort (0);
1501         }
1502     }
1503
1504   /* Remove declarations for any `for' variables from inner scopes
1505      that we kept around.  */
1506   for (link = current_binding_level->dead_vars_from_for;
1507        link; link = TREE_CHAIN (link))
1508     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1509
1510   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1511   for (link = current_binding_level->type_shadowed;
1512        link; link = TREE_CHAIN (link))
1513     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1514
1515   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1516   for (link = current_binding_level->shadowed_labels;
1517        link;
1518        link = TREE_CHAIN (link))
1519     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1520
1521   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1522      list if a `using' declaration put them there.  The debugging
1523      back-ends won't understand OVERLOAD, so we remove them here.
1524      Because the BLOCK_VARS are (temporarily) shared with
1525      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1526      popped all the bindings.  */
1527   if (block)
1528     {
1529       tree* d;
1530
1531       for (d = &BLOCK_VARS (block); *d; )
1532         {
1533           if (TREE_CODE (*d) == TREE_LIST)
1534             *d = TREE_CHAIN (*d);
1535           else
1536             d = &TREE_CHAIN (*d);
1537         }
1538     }
1539
1540   /* If the level being exited is the top level of a function,
1541      check over all the labels.  */
1542   if (functionbody)
1543     {
1544       /* Since this is the top level block of a function, the vars are
1545          the function's parameters.  Don't leave them in the BLOCK
1546          because they are found in the FUNCTION_DECL instead.  */
1547       BLOCK_VARS (block) = 0;
1548       pop_labels (block);
1549     }
1550
1551   tmp = current_binding_level->keep;
1552
1553   pop_binding_level ();
1554   if (functionbody)
1555     DECL_INITIAL (current_function_decl) = block;
1556   else if (block)
1557     current_binding_level->blocks
1558       = chainon (current_binding_level->blocks, block);
1559
1560   /* If we did not make a block for the level just exited,
1561      any blocks made for inner levels
1562      (since they cannot be recorded as subblocks in that level)
1563      must be carried forward so they will later become subblocks
1564      of something else.  */
1565   else if (subblocks)
1566     current_binding_level->blocks
1567       = chainon (current_binding_level->blocks, subblocks);
1568
1569   /* Each and every BLOCK node created here in `poplevel' is important
1570      (e.g. for proper debugging information) so if we created one
1571      earlier, mark it as "used".  */
1572   if (block)
1573     TREE_USED (block) = 1;
1574
1575   /* Take care of compiler's internal binding structures.  */
1576   if (tmp == 2)
1577     {
1578       tree scope_stmts;
1579
1580       scope_stmts
1581         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1582       if (block)
1583         {
1584           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1585           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1586         }
1587
1588       block = poplevel (keep, reverse, functionbody);
1589     }
1590
1591   return block;
1592 }
1593
1594 /* Delete the node BLOCK from the current binding level.
1595    This is used for the block inside a stmt expr ({...})
1596    so that the block can be reinserted where appropriate.  */
1597
1598 void
1599 delete_block (block)
1600      tree block;
1601 {
1602   tree t;
1603   if (current_binding_level->blocks == block)
1604     current_binding_level->blocks = TREE_CHAIN (block);
1605   for (t = current_binding_level->blocks; t;)
1606     {
1607       if (TREE_CHAIN (t) == block)
1608         TREE_CHAIN (t) = TREE_CHAIN (block);
1609       else
1610         t = TREE_CHAIN (t);
1611     }
1612   TREE_CHAIN (block) = NULL_TREE;
1613   /* Clear TREE_USED which is always set by poplevel.
1614      The flag is set again if insert_block is called.  */
1615   TREE_USED (block) = 0;
1616 }
1617
1618 /* Insert BLOCK at the end of the list of subblocks of the
1619    current binding level.  This is used when a BIND_EXPR is expanded,
1620    to handle the BLOCK node inside the BIND_EXPR.  */
1621
1622 void
1623 insert_block (block)
1624      tree block;
1625 {
1626   TREE_USED (block) = 1;
1627   current_binding_level->blocks
1628     = chainon (current_binding_level->blocks, block);
1629 }
1630
1631 /* Set the BLOCK node for the innermost scope
1632    (the one we are currently in).  */
1633
1634 void
1635 set_block (block)
1636     tree block ATTRIBUTE_UNUSED;
1637 {
1638   /* The RTL expansion machinery requires us to provide this callback,
1639      but it is not applicable in function-at-a-time mode.  */
1640   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1641 }
1642
1643 /* Do a pushlevel for class declarations.  */
1644
1645 void
1646 pushlevel_class ()
1647 {
1648   register struct binding_level *newlevel;
1649
1650   /* Reuse or create a struct for this binding level.  */
1651 #if defined(DEBUG_CP_BINDING_LEVELS)
1652   if (0)
1653 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1654   if (free_binding_level)
1655 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1656     {
1657       newlevel = free_binding_level;
1658       free_binding_level = free_binding_level->level_chain;
1659     }
1660   else
1661     newlevel = make_binding_level ();
1662
1663 #if defined(DEBUG_CP_BINDING_LEVELS)
1664   is_class_level = 1;
1665 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1666
1667   push_binding_level (newlevel, 0, 0);
1668
1669   class_binding_level = current_binding_level;
1670   class_binding_level->parm_flag = 2;
1671   class_binding_level->this_class = current_class_type;
1672 }
1673
1674 /* ...and a poplevel for class declarations.  */
1675
1676 void
1677 poplevel_class ()
1678 {
1679   register struct binding_level *level = class_binding_level;
1680   tree shadowed;
1681
1682   my_friendly_assert (level != 0, 354);
1683
1684   /* If we're leaving a toplevel class, don't bother to do the setting
1685      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1686      shouldn't even be used when current_class_type isn't set, and second,
1687      if we don't touch it here, we're able to use the cache effect if the
1688      next time we're entering a class scope, it is the same class.  */
1689   if (current_class_depth != 1)
1690     {
1691       struct binding_level* b;
1692
1693       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1694       for (shadowed = level->class_shadowed;
1695            shadowed;
1696            shadowed = TREE_CHAIN (shadowed))
1697         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1698
1699       /* Find the next enclosing class, and recreate
1700          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1701       b = level->level_chain;
1702       while (b && b->parm_flag != 2)
1703         b = b->level_chain;
1704
1705       if (b)
1706         for (shadowed = b->class_shadowed;
1707              shadowed;
1708              shadowed = TREE_CHAIN (shadowed))
1709           {
1710             tree t;
1711
1712             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1713             while (t && BINDING_LEVEL (t) != b)
1714               t = TREE_CHAIN (t);
1715
1716             if (t)
1717               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1718                 = BINDING_VALUE (t);
1719           }
1720     }
1721   else
1722     /* Remember to save what IDENTIFIER's were bound in this scope so we
1723        can recover from cache misses.  */
1724     {
1725       previous_class_type = current_class_type;
1726       previous_class_values = class_binding_level->class_shadowed;
1727     }
1728   for (shadowed = level->type_shadowed;
1729        shadowed;
1730        shadowed = TREE_CHAIN (shadowed))
1731     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1732
1733   /* Remove the bindings for all of the class-level declarations.  */
1734   for (shadowed = level->class_shadowed;
1735        shadowed;
1736        shadowed = TREE_CHAIN (shadowed))
1737     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1738
1739   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1740                       (HOST_WIDE_INT) class_binding_level->level_chain,
1741                       class_binding_level->parm_flag,
1742                       class_binding_level->keep);
1743
1744   /* Now, pop out of the binding level which we created up in the
1745      `pushlevel_class' routine.  */
1746 #if defined(DEBUG_CP_BINDING_LEVELS)
1747   is_class_level = 1;
1748 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1749
1750   pop_binding_level ();
1751 }
1752
1753 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1754    for any names in enclosing classes.  */
1755
1756 void
1757 clear_identifier_class_values ()
1758 {
1759   tree t;
1760
1761   if (!class_binding_level)
1762     return;
1763
1764   for (t = class_binding_level->class_shadowed;
1765        t;
1766        t = TREE_CHAIN (t))
1767     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1768 }
1769
1770 /* Returns non-zero if T is a virtual function table.  */
1771
1772 int
1773 vtable_decl_p (t, data)
1774      tree t;
1775      void *data ATTRIBUTE_UNUSED;
1776 {
1777   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1778 }
1779
1780 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1781    functions.  */
1782
1783 int
1784 vtype_decl_p (t, data)
1785      tree t;
1786      void *data ATTRIBUTE_UNUSED;
1787 {
1788   return (TREE_CODE (t) == TYPE_DECL
1789           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1790           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1791 }
1792
1793 /* Return the declarations that are members of the namespace NS.  */
1794
1795 tree
1796 cp_namespace_decls (ns)
1797      tree ns;
1798 {
1799   return NAMESPACE_LEVEL (ns)->names;
1800 }
1801
1802 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1803    itself, calling F for each.  The DATA is passed to F as well.  */
1804
1805 static int
1806 walk_namespaces_r (namespace, f, data)
1807      tree namespace;
1808      walk_namespaces_fn f;
1809      void *data;
1810 {
1811   tree current;
1812   int result = 0;
1813
1814   result |= (*f) (namespace, data);
1815
1816   for (current = cp_namespace_decls (namespace);
1817        current;
1818        current = TREE_CHAIN (current))
1819     {
1820       if (TREE_CODE (current) != NAMESPACE_DECL
1821           || DECL_NAMESPACE_ALIAS (current))
1822         continue;
1823       if (!DECL_LANG_SPECIFIC (current))
1824         {
1825           /* Hmm. std. */
1826           my_friendly_assert (current == fake_std_node, 393);
1827           continue;
1828         }
1829
1830       /* We found a namespace.  */
1831       result |= walk_namespaces_r (current, f, data);
1832     }
1833
1834   return result;
1835 }
1836
1837 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1838    F as well.  */
1839
1840 int
1841 walk_namespaces (f, data)
1842      walk_namespaces_fn f;
1843      void *data;
1844 {
1845   return walk_namespaces_r (global_namespace, f, data);
1846 }
1847
1848 struct walk_globals_data {
1849   walk_globals_pred p;
1850   walk_globals_fn f;
1851   void *data;
1852 };
1853
1854 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1855    for which P returns non-zero, call F with its address.  If any call
1856    to F returns a non-zero value, return a non-zero value.  */
1857
1858 static int
1859 walk_globals_r (namespace, data)
1860      tree namespace;
1861      void *data;
1862 {
1863   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1864   walk_globals_pred p = wgd->p;
1865   walk_globals_fn f = wgd->f;
1866   void *d = wgd->data;
1867   tree *t;
1868   int result = 0;
1869
1870   t = &NAMESPACE_LEVEL (namespace)->names;
1871
1872   while (*t)
1873     {
1874       tree glbl = *t;
1875
1876       if ((*p) (glbl, d))
1877         result |= (*f) (t, d);
1878
1879       /* If F changed *T, then *T still points at the next item to
1880          examine.  */
1881       if (*t == glbl)
1882         t = &TREE_CHAIN (*t);
1883     }
1884
1885   return result;
1886 }
1887
1888 /* Walk the global declarations.  Whenever one is found for which P
1889    returns non-zero, call F with its address.  If any call to F
1890    returns a non-zero value, return a non-zero value.  */
1891
1892 int
1893 walk_globals (p, f, data)
1894      walk_globals_pred p;
1895      walk_globals_fn f;
1896      void *data;
1897 {
1898   struct walk_globals_data wgd;
1899   wgd.p = p;
1900   wgd.f = f;
1901   wgd.data = data;
1902
1903   return walk_namespaces (walk_globals_r, &wgd);
1904 }
1905
1906 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1907    DATA is non-NULL, this is the last time we will call
1908    wrapup_global_declarations for this NAMESPACE.  */
1909
1910 int
1911 wrapup_globals_for_namespace (namespace, data)
1912      tree namespace;
1913      void *data;
1914 {
1915   tree globals = cp_namespace_decls (namespace);
1916   int len = list_length (globals);
1917   tree *vec = (tree *) alloca (sizeof (tree) * len);
1918   int i;
1919   int result;
1920   tree decl;
1921   int last_time = (data != 0);
1922
1923   if (last_time && namespace == global_namespace)
1924     /* Let compile_file handle the global namespace.  */
1925     return 0;
1926
1927   /* Process the decls in reverse order--earliest first.
1928      Put them into VEC from back to front, then take out from front.  */
1929
1930   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1931     {
1932       /* Pretend we've output an unused static variable.  This ensures
1933          that the toplevel __FUNCTION__ etc won't be emitted, unless
1934          needed. */
1935       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1936           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1937         {
1938           TREE_ASM_WRITTEN (decl) = 1;
1939           DECL_IGNORED_P (decl) = 1;
1940         }
1941       vec[len - i - 1] = decl;
1942     }
1943
1944   if (last_time)
1945     {
1946       check_global_declarations (vec, len);
1947       return 0;
1948     }
1949
1950   /* Temporarily mark vtables as external.  That prevents
1951      wrapup_global_declarations from writing them out; we must process
1952      them ourselves in finish_vtable_vardecl.  */
1953   for (i = 0; i < len; ++i)
1954     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1955       {
1956         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1957         DECL_EXTERNAL (vec[i]) = 1;
1958       }
1959
1960   /* Write out any globals that need to be output.  */
1961   result = wrapup_global_declarations (vec, len);
1962
1963   /* Undo the hack to DECL_EXTERNAL above.  */
1964   for (i = 0; i < len; ++i)
1965     if (vtable_decl_p (vec[i], /*data=*/0)
1966         && DECL_NOT_REALLY_EXTERN (vec[i]))
1967       {
1968         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1969         DECL_EXTERNAL (vec[i]) = 0;
1970       }
1971
1972   return result;
1973 }
1974
1975 \f
1976 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1977
1978 static void
1979 mark_binding_level (arg)
1980      void *arg;
1981 {
1982   struct binding_level *lvl = *(struct binding_level **)arg;
1983
1984   for (; lvl; lvl = lvl->level_chain)
1985     {
1986       ggc_mark_tree (lvl->names);
1987       ggc_mark_tree (lvl->tags);
1988       ggc_mark_tree (lvl->usings);
1989       ggc_mark_tree (lvl->using_directives);
1990       ggc_mark_tree (lvl->class_shadowed);
1991       ggc_mark_tree (lvl->type_shadowed);
1992       ggc_mark_tree (lvl->shadowed_labels);
1993       ggc_mark_tree (lvl->blocks);
1994       ggc_mark_tree (lvl->this_class);
1995       ggc_mark_tree (lvl->incomplete);
1996       ggc_mark_tree (lvl->dead_vars_from_for);
1997     }
1998 }
1999
2000 static void
2001 mark_named_label_lists (labs, uses)
2002      void *labs;
2003      void *uses;
2004 {
2005   struct named_label_list *l = *(struct named_label_list **)labs;
2006   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2007
2008   for (; l; l = l->next)
2009     {
2010       ggc_mark (l);
2011       mark_binding_level (l->binding_level);
2012       ggc_mark_tree (l->old_value);
2013       ggc_mark_tree (l->label_decl);
2014       ggc_mark_tree (l->bad_decls);
2015     }
2016
2017   for (; u; u = u->next)
2018     ggc_mark (u);
2019 }
2020 \f
2021 /* For debugging.  */
2022 static int no_print_functions = 0;
2023 static int no_print_builtins = 0;
2024
2025 void
2026 print_binding_level (lvl)
2027      struct binding_level *lvl;
2028 {
2029   tree t;
2030   int i = 0, len;
2031   fprintf (stderr, " blocks=");
2032   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2033   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2034            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2035   if (lvl->tag_transparent)
2036     fprintf (stderr, " tag-transparent");
2037   if (lvl->more_cleanups_ok)
2038     fprintf (stderr, " more-cleanups-ok");
2039   if (lvl->have_cleanups)
2040     fprintf (stderr, " have-cleanups");
2041   fprintf (stderr, "\n");
2042   if (lvl->names)
2043     {
2044       fprintf (stderr, " names:\t");
2045       /* We can probably fit 3 names to a line?  */
2046       for (t = lvl->names; t; t = TREE_CHAIN (t))
2047         {
2048           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2049             continue;
2050           if (no_print_builtins
2051               && (TREE_CODE (t) == TYPE_DECL)
2052               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2053             continue;
2054
2055           /* Function decls tend to have longer names.  */
2056           if (TREE_CODE (t) == FUNCTION_DECL)
2057             len = 3;
2058           else
2059             len = 2;
2060           i += len;
2061           if (i > 6)
2062             {
2063               fprintf (stderr, "\n\t");
2064               i = len;
2065             }
2066           print_node_brief (stderr, "", t, 0);
2067           if (t == error_mark_node)
2068             break;
2069         }
2070       if (i)
2071         fprintf (stderr, "\n");
2072     }
2073   if (lvl->tags)
2074     {
2075       fprintf (stderr, " tags:\t");
2076       i = 0;
2077       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2078         {
2079           if (TREE_PURPOSE (t) == NULL_TREE)
2080             len = 3;
2081           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2082             len = 2;
2083           else
2084             len = 4;
2085           i += len;
2086           if (i > 5)
2087             {
2088               fprintf (stderr, "\n\t");
2089               i = len;
2090             }
2091           if (TREE_PURPOSE (t) == NULL_TREE)
2092             {
2093               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2094               fprintf (stderr, ">");
2095             }
2096           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2097             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2098           else
2099             {
2100               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2101               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2102               fprintf (stderr, ">");
2103             }
2104         }
2105       if (i)
2106         fprintf (stderr, "\n");
2107     }
2108   if (lvl->class_shadowed)
2109     {
2110       fprintf (stderr, " class-shadowed:");
2111       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2112         {
2113           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2114         }
2115       fprintf (stderr, "\n");
2116     }
2117   if (lvl->type_shadowed)
2118     {
2119       fprintf (stderr, " type-shadowed:");
2120       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2121         {
2122           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2123         }
2124       fprintf (stderr, "\n");
2125     }
2126 }
2127
2128 void
2129 print_other_binding_stack (stack)
2130      struct binding_level *stack;
2131 {
2132   struct binding_level *level;
2133   for (level = stack; level != global_binding_level; level = level->level_chain)
2134     {
2135       fprintf (stderr, "binding level ");
2136       fprintf (stderr, HOST_PTR_PRINTF, level);
2137       fprintf (stderr, "\n");
2138       print_binding_level (level);
2139     }
2140 }
2141
2142 void
2143 print_binding_stack ()
2144 {
2145   struct binding_level *b;
2146   fprintf (stderr, "current_binding_level=");
2147   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2148   fprintf (stderr, "\nclass_binding_level=");
2149   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2150   fprintf (stderr, "\nglobal_binding_level=");
2151   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2152   fprintf (stderr, "\n");
2153   if (class_binding_level)
2154     {
2155       for (b = class_binding_level; b; b = b->level_chain)
2156         if (b == current_binding_level)
2157           break;
2158       if (b)
2159         b = class_binding_level;
2160       else
2161         b = current_binding_level;
2162     }
2163   else
2164     b = current_binding_level;
2165   print_other_binding_stack (b);
2166   fprintf (stderr, "global:\n");
2167   print_binding_level (global_binding_level);
2168 }
2169
2170 /* Namespace binding access routines: The namespace_bindings field of
2171    the identifier is polymorphic, with three possible values:
2172    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2173    indicating the BINDING_VALUE of global_namespace. */
2174
2175 /* Check whether the a binding for the name to scope is known.
2176    Assumes that the bindings of the name are already a list
2177    of bindings. Returns the binding found, or NULL_TREE. */
2178
2179 static tree
2180 find_binding (name, scope)
2181      tree name;
2182      tree scope;
2183 {
2184   tree iter, prev = NULL_TREE;
2185
2186   scope = ORIGINAL_NAMESPACE (scope);
2187
2188   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2189        iter = TREE_CHAIN (iter))
2190     {
2191       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2192       if (BINDING_SCOPE (iter) == scope)
2193         {
2194           /* Move binding found to the front of the list, so
2195              subsequent lookups will find it faster. */
2196           if (prev)
2197             {
2198               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2199               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2200               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2201             }
2202           return iter;
2203         }
2204       prev = iter;
2205     }
2206   return NULL_TREE;
2207 }
2208
2209 /* Always returns a binding for name in scope. If the
2210    namespace_bindings is not a list, convert it to one first.
2211    If no binding is found, make a new one. */
2212
2213 tree
2214 binding_for_name (name, scope)
2215      tree name;
2216      tree scope;
2217 {
2218   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2219   tree result;
2220
2221   scope = ORIGINAL_NAMESPACE (scope);
2222
2223   if (b && TREE_CODE (b) != CPLUS_BINDING)
2224     {
2225       /* Get rid of optimization for global scope. */
2226       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2227       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2228       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2229     }
2230   if (b && (result = find_binding (name, scope)))
2231     return result;
2232   /* Not found, make a new one. */
2233   result = make_node (CPLUS_BINDING);
2234   TREE_CHAIN (result) = b;
2235   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2236   BINDING_SCOPE (result) = scope;
2237   BINDING_TYPE (result) = NULL_TREE;
2238   BINDING_VALUE (result) = NULL_TREE;
2239   return result;
2240 }
2241
2242 /* Return the binding value for name in scope, considering that
2243    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2244
2245 tree
2246 namespace_binding (name, scope)
2247      tree name;
2248      tree scope;
2249 {
2250   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2251   if (b == NULL_TREE)
2252     return NULL_TREE;
2253   if (scope == NULL_TREE)
2254     scope = global_namespace;
2255   if (TREE_CODE (b) != CPLUS_BINDING)
2256     return (scope == global_namespace) ? b : NULL_TREE;
2257   name = find_binding (name,scope);
2258   if (name == NULL_TREE)
2259     return name;
2260   return BINDING_VALUE (name);
2261 }
2262
2263 /* Set the binding value for name in scope. If modifying the binding
2264    of global_namespace is attempted, try to optimize it. */
2265
2266 void
2267 set_namespace_binding (name, scope, val)
2268      tree name;
2269      tree scope;
2270      tree val;
2271 {
2272   tree b;
2273
2274   if (scope == NULL_TREE)
2275     scope = global_namespace;
2276
2277   if (scope == global_namespace)
2278     {
2279       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2280       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2281         {
2282           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2283           return;
2284         }
2285     }
2286   b = binding_for_name (name, scope);
2287   BINDING_VALUE (b) = val;
2288 }
2289
2290 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2291    select a name that is unique to this compilation unit.  */
2292
2293 void
2294 push_namespace (name)
2295      tree name;
2296 {
2297   tree d = NULL_TREE;
2298   int need_new = 1;
2299   int implicit_use = 0;
2300   int global = 0;
2301   if (!global_namespace)
2302     {
2303       /* This must be ::. */
2304       my_friendly_assert (name == get_identifier ("::"), 377);
2305       global = 1;
2306     }
2307   else if (!name)
2308     {
2309       /* The name of anonymous namespace is unique for the translation
2310          unit.  */
2311       if (!anonymous_namespace_name)
2312         anonymous_namespace_name = get_file_function_name ('N');
2313       name = anonymous_namespace_name;
2314       d = IDENTIFIER_NAMESPACE_VALUE (name);
2315       if (d)
2316         /* Reopening anonymous namespace.  */
2317         need_new = 0;
2318       implicit_use = 1;
2319     }
2320   else if (current_namespace == global_namespace
2321            && !flag_honor_std
2322            && name == std_identifier)
2323     {
2324       in_fake_std++;
2325       return;
2326     }
2327   else
2328     {
2329       /* Check whether this is an extended namespace definition. */
2330       d = IDENTIFIER_NAMESPACE_VALUE (name);
2331       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2332         {
2333           need_new = 0;
2334           if (DECL_NAMESPACE_ALIAS (d))
2335             {
2336               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2337                         d, DECL_NAMESPACE_ALIAS (d));
2338               d = DECL_NAMESPACE_ALIAS (d);
2339             }
2340         }
2341     }
2342
2343   if (need_new)
2344     {
2345       /* Make a new namespace, binding the name to it. */
2346       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2347       /* The global namespace is not pushed, and the global binding
2348          level is set elsewhere.  */
2349       if (!global)
2350         {
2351           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2352           d = pushdecl (d);
2353           pushlevel (0);
2354           declare_namespace_level ();
2355           NAMESPACE_LEVEL (d) = current_binding_level;
2356         }
2357     }
2358   else
2359     resume_binding_level (NAMESPACE_LEVEL (d));
2360
2361   if (implicit_use)
2362     do_using_directive (d);
2363   /* Enter the name space. */
2364   current_namespace = d;
2365 }
2366
2367 /* Pop from the scope of the current namespace.  */
2368
2369 void
2370 pop_namespace ()
2371 {
2372   if (current_namespace == global_namespace)
2373     {
2374       my_friendly_assert (in_fake_std > 0, 980421);
2375       in_fake_std--;
2376       return;
2377     }
2378   current_namespace = CP_DECL_CONTEXT (current_namespace);
2379   /* The binding level is not popped, as it might be re-opened later.  */
2380   suspend_binding_level ();
2381 }
2382
2383 /* Push into the scope of the namespace NS, even if it is deeply
2384    nested within another namespace.  */
2385
2386 void
2387 push_nested_namespace (ns)
2388      tree ns;
2389 {
2390   if (ns == global_namespace)
2391     push_to_top_level ();
2392   else
2393     {
2394       push_nested_namespace (CP_DECL_CONTEXT (ns));
2395       push_namespace (DECL_NAME (ns));
2396     }
2397 }
2398
2399 /* Pop back from the scope of the namespace NS, which was previously
2400    entered with push_nested_namespace.  */
2401
2402 void
2403 pop_nested_namespace (ns)
2404      tree ns;
2405 {
2406   while (ns != global_namespace)
2407     {
2408       pop_namespace ();
2409       ns = CP_DECL_CONTEXT (ns);
2410     }
2411
2412   pop_from_top_level ();
2413 }
2414
2415 \f
2416 /* Subroutines for reverting temporarily to top-level for instantiation
2417    of templates and such.  We actually need to clear out the class- and
2418    local-value slots of all identifiers, so that only the global values
2419    are at all visible.  Simply setting current_binding_level to the global
2420    scope isn't enough, because more binding levels may be pushed.  */
2421 struct saved_scope *scope_chain;
2422
2423 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2424
2425 static void
2426 mark_saved_scope (arg)
2427      void *arg;
2428 {
2429   struct saved_scope *t = *(struct saved_scope **)arg;
2430   while (t)
2431     {
2432       mark_binding_level (&t->class_bindings);
2433       ggc_mark_tree (t->old_bindings);
2434       ggc_mark_tree (t->old_namespace);
2435       ggc_mark_tree (t->class_name);
2436       ggc_mark_tree (t->class_type);
2437       ggc_mark_tree (t->access_specifier);
2438       ggc_mark_tree (t->function_decl);
2439       if (t->lang_base)
2440         ggc_mark_tree_varray (t->lang_base);
2441       ggc_mark_tree (t->lang_name);
2442       ggc_mark_tree (t->template_parms);
2443       ggc_mark_tree (t->x_previous_class_type);
2444       ggc_mark_tree (t->x_previous_class_values);
2445       ggc_mark_tree (t->x_saved_tree);
2446       ggc_mark_tree (t->incomplete);
2447       ggc_mark_tree (t->lookups);
2448
2449       mark_stmt_tree (&t->x_stmt_tree);
2450       mark_binding_level (&t->bindings);
2451       t = t->prev;
2452     }
2453 }
2454
2455 static tree
2456 store_bindings (names, old_bindings)
2457      tree names, old_bindings;
2458 {
2459   tree t;
2460   for (t = names; t; t = TREE_CHAIN (t))
2461     {
2462       tree binding, t1, id;
2463
2464       if (TREE_CODE (t) == TREE_LIST)
2465         id = TREE_PURPOSE (t);
2466       else
2467         id = DECL_NAME (t);
2468
2469       if (!id
2470           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2471              we have no IDENTIFIER_BINDING if we have left the class
2472              scope, but cached the class-level declarations.  */
2473           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2474         continue;
2475
2476       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2477         if (TREE_VEC_ELT (t1, 0) == id)
2478           goto skip_it;
2479
2480       binding = make_tree_vec (4);
2481
2482       if (id)
2483         {
2484           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2485           TREE_VEC_ELT (binding, 0) = id;
2486           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2487           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2488           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2489           IDENTIFIER_BINDING (id) = NULL_TREE;
2490           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2491         }
2492       TREE_CHAIN (binding) = old_bindings;
2493       old_bindings = binding;
2494     skip_it:
2495       ;
2496     }
2497   return old_bindings;
2498 }
2499
2500 void
2501 maybe_push_to_top_level (pseudo)
2502      int pseudo;
2503 {
2504   struct saved_scope *s;
2505   struct binding_level *b;
2506   tree old_bindings;
2507   int need_pop;
2508
2509   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2510
2511   b = scope_chain ? current_binding_level : 0;
2512
2513   /* If we're in the middle of some function, save our state.  */
2514   if (cfun)
2515     {
2516       need_pop = 1;
2517       push_function_context_to (NULL_TREE);
2518     }
2519   else
2520     need_pop = 0;
2521
2522   old_bindings = NULL_TREE;
2523   if (scope_chain && previous_class_type)
2524     old_bindings = store_bindings (previous_class_values, old_bindings);
2525
2526   /* Have to include global_binding_level, because class-level decls
2527      aren't listed anywhere useful.  */
2528   for (; b; b = b->level_chain)
2529     {
2530       tree t;
2531
2532       /* Template IDs are inserted into the global level. If they were
2533          inserted into namespace level, finish_file wouldn't find them
2534          when doing pending instantiations. Therefore, don't stop at
2535          namespace level, but continue until :: .  */
2536       if (b == global_binding_level || (pseudo && b->template_parms_p))
2537         break;
2538
2539       old_bindings = store_bindings (b->names, old_bindings);
2540       /* We also need to check class_shadowed to save class-level type
2541          bindings, since pushclass doesn't fill in b->names.  */
2542       if (b->parm_flag == 2)
2543         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2544
2545       /* Unwind type-value slots back to top level.  */
2546       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2547         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2548     }
2549   s->prev = scope_chain;
2550   s->old_bindings = old_bindings;
2551   s->bindings = b;
2552   s->need_pop_function_context = need_pop;
2553   s->function_decl = current_function_decl;
2554
2555   scope_chain = s;
2556   current_function_decl = NULL_TREE;
2557   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2558   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2559   current_lang_name = lang_name_cplusplus;
2560   current_namespace = global_namespace;
2561 }
2562
2563 void
2564 push_to_top_level ()
2565 {
2566   maybe_push_to_top_level (0);
2567 }
2568
2569 void
2570 pop_from_top_level ()
2571 {
2572   struct saved_scope *s = scope_chain;
2573   tree t;
2574
2575   /* Clear out class-level bindings cache.  */
2576   if (previous_class_type)
2577     invalidate_class_lookup_cache ();
2578
2579   VARRAY_FREE (current_lang_base);
2580
2581   scope_chain = s->prev;
2582   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2583     {
2584       tree id = TREE_VEC_ELT (t, 0);
2585       if (id)
2586         {
2587           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2588           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2589           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2590         }
2591     }
2592
2593   /* If we were in the middle of compiling a function, restore our
2594      state.  */
2595   if (s->need_pop_function_context)
2596     pop_function_context_from (NULL_TREE);
2597   current_function_decl = s->function_decl;
2598
2599   free (s);
2600 }
2601 \f
2602 /* Push a definition of struct, union or enum tag "name".
2603    into binding_level "b".   "type" should be the type node,
2604    We assume that the tag "name" is not already defined.
2605
2606    Note that the definition may really be just a forward reference.
2607    In that case, the TYPE_SIZE will be a NULL_TREE.
2608
2609    C++ gratuitously puts all these tags in the name space.  */
2610
2611 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2612    record the shadowed value for this binding contour.  TYPE is
2613    the type that ID maps to.  */
2614
2615 static void
2616 set_identifier_type_value_with_scope (id, type, b)
2617      tree id;
2618      tree type;
2619      struct binding_level *b;
2620 {
2621   if (!b->namespace_p)
2622     {
2623       /* Shadow the marker, not the real thing, so that the marker
2624          gets restored later. */
2625       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2626       b->type_shadowed
2627         = tree_cons (id, old_type_value, b->type_shadowed);
2628     }
2629   else
2630     {
2631       tree binding = binding_for_name (id, current_namespace);
2632       BINDING_TYPE (binding) = type;
2633       /* Store marker instead of real type. */
2634       type = global_type_node;
2635     }
2636   SET_IDENTIFIER_TYPE_VALUE (id, type);
2637 }
2638
2639 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2640
2641 void
2642 set_identifier_type_value (id, type)
2643      tree id;
2644      tree type;
2645 {
2646   set_identifier_type_value_with_scope (id, type, current_binding_level);
2647 }
2648
2649 /* Return the type associated with id. */
2650
2651 tree
2652 identifier_type_value (id)
2653      tree id;
2654 {
2655   /* There is no type with that name, anywhere. */
2656   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2657     return NULL_TREE;
2658   /* This is not the type marker, but the real thing. */
2659   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2660     return REAL_IDENTIFIER_TYPE_VALUE (id);
2661   /* Have to search for it. It must be on the global level, now.
2662      Ask lookup_name not to return non-types. */
2663   id = lookup_name_real (id, 2, 1, 0);
2664   if (id)
2665     return TREE_TYPE (id);
2666   return NULL_TREE;
2667 }
2668
2669 /* Pop off extraneous binding levels left over due to syntax errors.
2670
2671    We don't pop past namespaces, as they might be valid.  */
2672
2673 void
2674 pop_everything ()
2675 {
2676 #ifdef DEBUG_CP_BINDING_LEVELS
2677   fprintf (stderr, "XXX entering pop_everything ()\n");
2678 #endif
2679   while (!toplevel_bindings_p ())
2680     {
2681       if (current_binding_level->parm_flag == 2)
2682         pop_nested_class ();
2683       else
2684         poplevel (0, 0, 0);
2685     }
2686 #ifdef DEBUG_CP_BINDING_LEVELS
2687   fprintf (stderr, "XXX leaving pop_everything ()\n");
2688 #endif
2689 }
2690
2691 /* The type TYPE is being declared.  If it is a class template, or a
2692    specialization of a class template, do any processing required and
2693    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2694    being declared a friend.  B is the binding level at which this TYPE
2695    should be bound.
2696
2697    Returns the TYPE_DECL for TYPE, which may have been altered by this
2698    processing.  */
2699
2700 static tree
2701 maybe_process_template_type_declaration (type, globalize, b)
2702      tree type;
2703      int globalize;
2704      struct binding_level* b;
2705 {
2706   tree decl = TYPE_NAME (type);
2707
2708   if (processing_template_parmlist)
2709     /* You can't declare a new template type in a template parameter
2710        list.  But, you can declare a non-template type:
2711
2712          template <class A*> struct S;
2713
2714        is a forward-declaration of `A'.  */
2715     ;
2716   else
2717     {
2718       maybe_check_template_type (type);
2719
2720       my_friendly_assert (IS_AGGR_TYPE (type)
2721                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2722
2723
2724       if (processing_template_decl)
2725         {
2726           /* This may change after the call to
2727              push_template_decl_real, but we want the original value.  */
2728           tree name = DECL_NAME (decl);
2729
2730           decl = push_template_decl_real (decl, globalize);
2731           /* If the current binding level is the binding level for the
2732              template parameters (see the comment in
2733              begin_template_parm_list) and the enclosing level is a class
2734              scope, and we're not looking at a friend, push the
2735              declaration of the member class into the class scope.  In the
2736              friend case, push_template_decl will already have put the
2737              friend into global scope, if appropriate.  */
2738           if (TREE_CODE (type) != ENUMERAL_TYPE
2739               && !globalize && b->template_parms_p
2740               && b->level_chain->parm_flag == 2)
2741             {
2742               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2743               /* Put this tag on the list of tags for the class, since
2744                  that won't happen below because B is not the class
2745                  binding level, but is instead the pseudo-global level.  */
2746               b->level_chain->tags =
2747                 tree_cons (name, type, b->level_chain->tags);
2748               if (!COMPLETE_TYPE_P (current_class_type))
2749                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2750             }
2751         }
2752     }
2753
2754   return decl;
2755 }
2756
2757 /* In C++, you don't have to write `struct S' to refer to `S'; you
2758    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2759    if the user had written `typedef struct S S'.  Create and return
2760    the TYPE_DECL for TYPE.  */
2761
2762 tree
2763 create_implicit_typedef (name, type)
2764      tree name;
2765      tree type;
2766 {
2767   tree decl;
2768
2769   decl = build_decl (TYPE_DECL, name, type);
2770   DECL_ARTIFICIAL (decl) = 1;
2771   /* There are other implicit type declarations, like the one *within*
2772      a class that allows you to write `S::S'.  We must distinguish
2773      amongst these.  */
2774   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2775   TYPE_NAME (type) = decl;
2776
2777   return decl;
2778 }
2779
2780 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2781    Normally put it into the inner-most non-tag-transparent scope,
2782    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2783    The latter is needed for implicit declarations.  */
2784
2785 void
2786 pushtag (name, type, globalize)
2787      tree name, type;
2788      int globalize;
2789 {
2790   register struct binding_level *b;
2791
2792   b = current_binding_level;
2793   while (b->tag_transparent
2794          || (globalize && b->parm_flag == 2))
2795     b = b->level_chain;
2796
2797   b->tags = tree_cons (name, type, b->tags);
2798
2799   if (name)
2800     {
2801       /* Do C++ gratuitous typedefing.  */
2802       if (IDENTIFIER_TYPE_VALUE (name) != type)
2803         {
2804           register tree d = NULL_TREE;
2805           int in_class = 0;
2806           tree context = TYPE_CONTEXT (type);
2807
2808           if (! context)
2809             {
2810               tree cs = current_scope ();
2811
2812               if (! globalize)
2813                 context = cs;
2814               else if (cs != NULL_TREE && TYPE_P (cs))
2815                 /* When declaring a friend class of a local class, we want
2816                    to inject the newly named class into the scope
2817                    containing the local class, not the namespace scope.  */
2818                 context = decl_function_context (get_type_decl (cs));
2819             }
2820           if (!context)
2821             context = current_namespace;
2822
2823           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2824               || b->parm_flag == 2)
2825             in_class = 1;
2826
2827           if (current_lang_name == lang_name_java)
2828             TYPE_FOR_JAVA (type) = 1;
2829
2830           d = create_implicit_typedef (name, type);
2831           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2832           if (! in_class)
2833             set_identifier_type_value_with_scope (name, type, b);
2834
2835           d = maybe_process_template_type_declaration (type,
2836                                                        globalize, b);
2837
2838           if (b->parm_flag == 2)
2839             {
2840               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2841                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2842                    class.  But if it's a member template class, we
2843                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2844                    is done later.  */
2845                 finish_member_declaration (d);
2846               else
2847                 pushdecl_class_level (d);
2848             }
2849           else
2850             d = pushdecl_with_scope (d, b);
2851
2852           if (ANON_AGGRNAME_P (name))
2853             DECL_IGNORED_P (d) = 1;
2854
2855           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2856           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2857
2858           /* If this is a local class, keep track of it.  We need this
2859              information for name-mangling, and so that it is possible to find
2860              all function definitions in a translation unit in a convenient
2861              way.  (It's otherwise tricky to find a member function definition
2862              it's only pointed to from within a local class.)  */
2863           if (TYPE_CONTEXT (type)
2864               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2865               && !processing_template_decl)
2866             VARRAY_PUSH_TREE (local_classes, type);
2867
2868           if (!uses_template_parms (type))
2869             {
2870               if (flag_new_abi)
2871                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2872               else
2873                 DECL_ASSEMBLER_NAME (d)
2874                   = get_identifier (build_overload_name (type, 1, 1));
2875             }
2876         }
2877       if (b->parm_flag == 2)
2878         {
2879           if (!COMPLETE_TYPE_P (current_class_type))
2880             CLASSTYPE_TAGS (current_class_type) = b->tags;
2881         }
2882     }
2883
2884   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2885     /* Use the canonical TYPE_DECL for this node.  */
2886     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2887   else
2888     {
2889       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2890          will be the tagged type we just added to the current
2891          binding level.  This fake NULL-named TYPE_DECL node helps
2892          dwarfout.c to know when it needs to output a
2893          representation of a tagged type, and it also gives us a
2894          convenient place to record the "scope start" address for
2895          the tagged type.  */
2896
2897       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2898       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2899     }
2900 }
2901
2902 /* Counter used to create anonymous type names.  */
2903
2904 static int anon_cnt = 0;
2905
2906 /* Return an IDENTIFIER which can be used as a name for
2907    anonymous structs and unions.  */
2908
2909 tree
2910 make_anon_name ()
2911 {
2912   char buf[32];
2913
2914   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2915   return get_identifier (buf);
2916 }
2917
2918 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2919    This keeps dbxout from getting confused.  */
2920
2921 void
2922 clear_anon_tags ()
2923 {
2924   register struct binding_level *b;
2925   register tree tags;
2926   static int last_cnt = 0;
2927
2928   /* Fast out if no new anon names were declared.  */
2929   if (last_cnt == anon_cnt)
2930     return;
2931
2932   b = current_binding_level;
2933   while (b->tag_transparent)
2934     b = b->level_chain;
2935   tags = b->tags;
2936   while (tags)
2937     {
2938       /* A NULL purpose means we have already processed all tags
2939          from here to the end of the list.  */
2940       if (TREE_PURPOSE (tags) == NULL_TREE)
2941         break;
2942       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2943         TREE_PURPOSE (tags) = NULL_TREE;
2944       tags = TREE_CHAIN (tags);
2945     }
2946   last_cnt = anon_cnt;
2947 }
2948 \f
2949 /* Subroutine of duplicate_decls: return truthvalue of whether
2950    or not types of these decls match.
2951
2952    For C++, we must compare the parameter list so that `int' can match
2953    `int&' in a parameter position, but `int&' is not confused with
2954    `const int&'.  */
2955
2956 int
2957 decls_match (newdecl, olddecl)
2958      tree newdecl, olddecl;
2959 {
2960   int types_match;
2961
2962   if (newdecl == olddecl)
2963     return 1;
2964
2965   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2966     /* If the two DECLs are not even the same kind of thing, we're not
2967        interested in their types.  */
2968     return 0;
2969
2970   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2971     {
2972       tree f1 = TREE_TYPE (newdecl);
2973       tree f2 = TREE_TYPE (olddecl);
2974       tree p1 = TYPE_ARG_TYPES (f1);
2975       tree p2 = TYPE_ARG_TYPES (f2);
2976
2977       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2978           && ! (DECL_EXTERN_C_P (newdecl)
2979                 && DECL_EXTERN_C_P (olddecl)))
2980         return 0;
2981
2982       if (TREE_CODE (f1) != TREE_CODE (f2))
2983         return 0;
2984
2985       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2986         {
2987           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2988               && (DECL_BUILT_IN (olddecl)
2989 #ifndef NO_IMPLICIT_EXTERN_C
2990                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2991                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2992 #endif
2993               ))
2994             {
2995               types_match = self_promoting_args_p (p1);
2996               if (p1 == void_list_node)
2997                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2998             }
2999 #ifndef NO_IMPLICIT_EXTERN_C
3000           else if (p1 == NULL_TREE
3001                    && (DECL_EXTERN_C_P (olddecl)
3002                        && DECL_IN_SYSTEM_HEADER (olddecl)
3003                        && !DECL_CLASS_SCOPE_P (olddecl))
3004                    && (DECL_EXTERN_C_P (newdecl)
3005                        && DECL_IN_SYSTEM_HEADER (newdecl)
3006                        && !DECL_CLASS_SCOPE_P (newdecl)))
3007             {
3008               types_match = self_promoting_args_p (p2);
3009               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3010             }
3011 #endif
3012           else
3013             types_match = compparms (p1, p2);
3014         }
3015       else
3016         types_match = 0;
3017     }
3018   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3019     {
3020       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3021                                 DECL_TEMPLATE_PARMS (olddecl)))
3022         return 0;
3023
3024       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3025           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3026         return 0;
3027
3028       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3029         types_match = 1;
3030       else
3031         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3032                                    DECL_TEMPLATE_RESULT (newdecl));
3033     }
3034   else
3035     {
3036       if (TREE_TYPE (newdecl) == error_mark_node)
3037         types_match = TREE_TYPE (olddecl) == error_mark_node;
3038       else if (TREE_TYPE (olddecl) == NULL_TREE)
3039         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3040       else if (TREE_TYPE (newdecl) == NULL_TREE)
3041         types_match = 0;
3042       else
3043         types_match = comptypes (TREE_TYPE (newdecl),
3044                                  TREE_TYPE (olddecl),
3045                                  COMPARE_REDECLARATION);
3046     }
3047
3048   return types_match;
3049 }
3050
3051 /* If NEWDECL is `static' and an `extern' was seen previously,
3052    warn about it.  OLDDECL is the previous declaration.
3053
3054    Note that this does not apply to the C++ case of declaring
3055    a variable `extern const' and then later `const'.
3056
3057    Don't complain about built-in functions, since they are beyond
3058    the user's control.  */
3059
3060 static void
3061 warn_extern_redeclared_static (newdecl, olddecl)
3062      tree newdecl, olddecl;
3063 {
3064   static const char *explicit_extern_static_warning
3065     = "`%D' was declared `extern' and later `static'";
3066   static const char *implicit_extern_static_warning
3067     = "`%D' was declared implicitly `extern' and later `static'";
3068
3069   tree name;
3070
3071   if (TREE_CODE (newdecl) == TYPE_DECL
3072       || TREE_CODE (newdecl) == TEMPLATE_DECL
3073       || TREE_CODE (newdecl) == CONST_DECL)
3074     return;
3075
3076   /* Don't get confused by static member functions; that's a different
3077      use of `static'.  */
3078   if (TREE_CODE (newdecl) == FUNCTION_DECL
3079       && DECL_STATIC_FUNCTION_P (newdecl))
3080     return;
3081
3082   /* If the old declaration was `static', or the new one isn't, then
3083      then everything is OK.  */
3084   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3085     return;
3086
3087   /* It's OK to declare a builtin function as `static'.  */
3088   if (TREE_CODE (olddecl) == FUNCTION_DECL
3089       && DECL_ARTIFICIAL (olddecl))
3090     return;
3091
3092   name = DECL_ASSEMBLER_NAME (newdecl);
3093   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3094               ? implicit_extern_static_warning
3095               : explicit_extern_static_warning, newdecl);
3096   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3097 }
3098
3099 /* Handle when a new declaration NEWDECL has the same name as an old
3100    one OLDDECL in the same binding contour.  Prints an error message
3101    if appropriate.
3102
3103    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3104    Otherwise, return 0.  */
3105
3106 int
3107 duplicate_decls (newdecl, olddecl)
3108      tree newdecl, olddecl;
3109 {
3110   unsigned olddecl_uid = DECL_UID (olddecl);
3111   int olddecl_friend = 0, types_match = 0;
3112   int new_defines_function = 0;
3113
3114   if (newdecl == olddecl)
3115     return 1;
3116
3117   types_match = decls_match (newdecl, olddecl);
3118
3119   /* If either the type of the new decl or the type of the old decl is an
3120      error_mark_node, then that implies that we have already issued an
3121      error (earlier) for some bogus type specification, and in that case,
3122      it is rather pointless to harass the user with yet more error message
3123      about the same declaration, so just pretend the types match here.  */
3124   if (TREE_TYPE (newdecl) == error_mark_node
3125       || TREE_TYPE (olddecl) == error_mark_node)
3126     types_match = 1;
3127
3128   /* Check for redeclaration and other discrepancies. */
3129   if (TREE_CODE (olddecl) == FUNCTION_DECL
3130       && DECL_ARTIFICIAL (olddecl))
3131     {
3132       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3133         {
3134           /* If you declare a built-in or predefined function name as static,
3135              the old definition is overridden, but optionally warn this was a
3136              bad choice of name.  */
3137           if (! TREE_PUBLIC (newdecl))
3138             {
3139               if (warn_shadow)
3140                 cp_warning ("shadowing %s function `%#D'",
3141                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3142                             olddecl);
3143               /* Discard the old built-in function.  */
3144               return 0;
3145             }
3146           /* If the built-in is not ansi, then programs can override
3147              it even globally without an error.  */
3148           else if (! DECL_BUILT_IN (olddecl))
3149             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3150                         olddecl, newdecl);
3151           else
3152             {
3153               cp_error ("declaration of `%#D'", newdecl);
3154               cp_error ("conflicts with built-in declaration `%#D'",
3155                         olddecl);
3156             }
3157           return 0;
3158         }
3159       else if (!types_match)
3160         {
3161           if ((DECL_EXTERN_C_P (newdecl)
3162                && DECL_EXTERN_C_P (olddecl))
3163               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3164                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3165             {
3166               /* A near match; override the builtin.  */
3167
3168               if (TREE_PUBLIC (newdecl))
3169                 {
3170                   cp_warning ("new declaration `%#D'", newdecl);
3171                   cp_warning ("ambiguates built-in declaration `%#D'",
3172                               olddecl);
3173                 }
3174               else if (warn_shadow)
3175                 cp_warning ("shadowing %s function `%#D'",
3176                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3177                             olddecl);
3178             }
3179           else
3180             /* Discard the old built-in function.  */
3181             return 0;
3182         }
3183
3184       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3185         {
3186           /* If a builtin function is redeclared as `static', merge
3187              the declarations, but make the original one static.  */
3188           DECL_THIS_STATIC (olddecl) = 1;
3189           TREE_PUBLIC (olddecl) = 0;
3190
3191           /* Make the old declaration consistent with the new one so
3192              that all remnants of the builtin-ness of this function
3193              will be banished.  */
3194           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3195           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3196           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3197           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3198                                        newdecl);
3199         }
3200     }
3201   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3202     {
3203       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3204            && TREE_CODE (newdecl) != TYPE_DECL
3205            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3206                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3207           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3208               && TREE_CODE (olddecl) != TYPE_DECL
3209               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3210                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3211                         == TYPE_DECL))))
3212         {
3213           /* We do nothing special here, because C++ does such nasty
3214              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3215              get shadowed, and know that if we need to find a TYPE_DECL
3216              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3217              slot of the identifier.  */
3218           return 0;
3219         }
3220
3221       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3222            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3223           || (TREE_CODE (olddecl) == FUNCTION_DECL
3224               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3225         return 0;
3226
3227       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3228       if (TREE_CODE (olddecl) == TREE_LIST)
3229         olddecl = TREE_VALUE (olddecl);
3230       cp_error_at ("previous declaration of `%#D'", olddecl);
3231
3232       /* New decl is completely inconsistent with the old one =>
3233          tell caller to replace the old one.  */
3234
3235       return 0;
3236     }
3237   else if (!types_match)
3238     {
3239       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3240         /* These are certainly not duplicate declarations; they're
3241            from different scopes.  */
3242         return 0;
3243
3244       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3245         {
3246           /* The name of a class template may not be declared to refer to
3247              any other template, class, function, object, namespace, value,
3248              or type in the same scope.  */
3249           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3250               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3251             {
3252               cp_error ("declaration of template `%#D'", newdecl);
3253               cp_error_at ("conflicts with previous declaration `%#D'",
3254                            olddecl);
3255             }
3256           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3257                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3258                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3259                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3260                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3261                                            DECL_TEMPLATE_PARMS (olddecl)))
3262             {
3263               cp_error ("new declaration `%#D'", newdecl);
3264               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3265             }
3266           return 0;
3267         }
3268       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3269         {
3270           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3271             {
3272               cp_error ("declaration of C function `%#D' conflicts with",
3273                         newdecl);
3274               cp_error_at ("previous declaration `%#D' here", olddecl);
3275             }
3276           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3277                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3278             {
3279               cp_error ("new declaration `%#D'", newdecl);
3280               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3281             }
3282           else
3283             return 0;
3284         }
3285
3286       /* Already complained about this, so don't do so again.  */
3287       else if (current_class_type == NULL_TREE
3288           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3289         {
3290           cp_error ("conflicting types for `%#D'", newdecl);
3291           cp_error_at ("previous declaration as `%#D'", olddecl);
3292         }
3293     }
3294   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3295             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3296                  && (!DECL_TEMPLATE_INFO (newdecl)
3297                      || (DECL_TI_TEMPLATE (newdecl)
3298                          != DECL_TI_TEMPLATE (olddecl))))
3299                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3300                     && (!DECL_TEMPLATE_INFO (olddecl)
3301                         || (DECL_TI_TEMPLATE (olddecl)
3302                             != DECL_TI_TEMPLATE (newdecl))))))
3303     /* It's OK to have a template specialization and a non-template
3304        with the same type, or to have specializations of two
3305        different templates with the same type.  Note that if one is a
3306        specialization, and the other is an instantiation of the same
3307        template, that we do not exit at this point.  That situation
3308        can occur if we instantiate a template class, and then
3309        specialize one of its methods.  This situation is legal, but
3310        the declarations must be merged in the usual way.  */
3311     return 0;
3312   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3313            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3314                 && !DECL_USE_TEMPLATE (newdecl))
3315                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3316                    && !DECL_USE_TEMPLATE (olddecl))))
3317     /* One of the declarations is a template instantiation, and the
3318        other is not a template at all.  That's OK.  */
3319     return 0;
3320   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3321            && DECL_NAMESPACE_ALIAS (newdecl)
3322            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3323     /* Redeclaration of namespace alias, ignore it. */
3324     return 1;
3325   else
3326     {
3327       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3328       if (errmsg)
3329         {
3330           cp_error (errmsg, newdecl);
3331           if (DECL_NAME (olddecl) != NULL_TREE)
3332             cp_error_at ((DECL_INITIAL (olddecl)
3333                           && namespace_bindings_p ())
3334                          ? "`%#D' previously defined here"
3335                          : "`%#D' previously declared here", olddecl);
3336         }
3337       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3338                && DECL_INITIAL (olddecl) != NULL_TREE
3339                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3340                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3341         {
3342           /* Prototype decl follows defn w/o prototype.  */
3343           cp_warning_at ("prototype for `%#D'", newdecl);
3344           cp_warning_at ("follows non-prototype definition here", olddecl);
3345         }
3346       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3347                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3348         {
3349           /* extern "C" int foo ();
3350              int foo () { bar (); }
3351              is OK.  */
3352           if (current_lang_stack
3353               == &VARRAY_TREE (current_lang_base, 0))
3354             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3355           else
3356             {
3357               cp_error_at ("previous declaration of `%#D' with %L linkage",
3358                            olddecl, DECL_LANGUAGE (olddecl));
3359               cp_error ("conflicts with new declaration with %L linkage",
3360                         DECL_LANGUAGE (newdecl));
3361             }
3362         }
3363
3364       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3365         ;
3366       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3367         {
3368           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3369           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3370           int i = 1;
3371
3372           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3373             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3374
3375           for (; t1 && t1 != void_list_node;
3376                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3377             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3378               {
3379                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3380                                            TREE_PURPOSE (t2)))
3381                   {
3382                     if (pedantic)
3383                       {
3384                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3385                                     i, newdecl);
3386                         cp_pedwarn_at ("after previous specification in `%#D'",
3387                                        olddecl);
3388                       }
3389                   }
3390                 else
3391                   {
3392                     cp_error ("default argument given for parameter %d of `%#D'",
3393                               i, newdecl);
3394                     cp_error_at ("after previous specification in `%#D'",
3395                                  olddecl);
3396                   }
3397               }
3398
3399           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3400               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3401             {
3402               cp_warning ("`%#D' was used before it was declared inline",
3403                           newdecl);
3404               cp_warning_at ("previous non-inline declaration here",
3405                              olddecl);
3406             }
3407         }
3408     }
3409
3410   /* If new decl is `static' and an `extern' was seen previously,
3411      warn about it.  */
3412   warn_extern_redeclared_static (newdecl, olddecl);
3413
3414   /* We have committed to returning 1 at this point.  */
3415   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3416     {
3417       /* Now that functions must hold information normally held
3418          by field decls, there is extra work to do so that
3419          declaration information does not get destroyed during
3420          definition.  */
3421       if (DECL_VINDEX (olddecl))
3422         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3423       if (DECL_VIRTUAL_CONTEXT (olddecl))
3424         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3425       if (DECL_CONTEXT (olddecl))
3426         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3427       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3428         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3429       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3430       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3431       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3432       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3433       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3434       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3435       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3436       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3437
3438       /* Optionally warn about more than one declaration for the same
3439          name, but don't warn about a function declaration followed by a
3440          definition.  */
3441       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3442           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3443           /* Don't warn about extern decl followed by definition. */
3444           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3445           /* Don't warn about friends, let add_friend take care of it. */
3446           && ! DECL_FRIEND_P (newdecl))
3447         {
3448           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3449           cp_warning_at ("previous declaration of `%D'", olddecl);
3450         }
3451     }
3452
3453   /* Deal with C++: must preserve virtual function table size.  */
3454   if (TREE_CODE (olddecl) == TYPE_DECL)
3455     {
3456       register tree newtype = TREE_TYPE (newdecl);
3457       register tree oldtype = TREE_TYPE (olddecl);
3458
3459       if (newtype != error_mark_node && oldtype != error_mark_node
3460           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3461         {
3462           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3463           CLASSTYPE_FRIEND_CLASSES (newtype)
3464             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3465         }
3466
3467       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3468     }
3469
3470   /* Copy all the DECL_... slots specified in the new decl
3471      except for any that we copy here from the old type.  */
3472   DECL_MACHINE_ATTRIBUTES (newdecl)
3473     = merge_machine_decl_attributes (olddecl, newdecl);
3474
3475   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3476     {
3477       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3478       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3479         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3480                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3481
3482       return 1;
3483     }
3484
3485   if (types_match)
3486     {
3487       /* Automatically handles default parameters.  */
3488       tree oldtype = TREE_TYPE (olddecl);
3489       tree newtype;
3490
3491       /* Merge the data types specified in the two decls.  */
3492       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3493
3494       /* If common_type produces a non-typedef type, just use the old type.  */
3495       if (TREE_CODE (newdecl) == TYPE_DECL
3496           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3497         newtype = oldtype;
3498
3499       if (TREE_CODE (newdecl) == VAR_DECL)
3500         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3501       /* Do this after calling `common_type' so that default
3502          parameters don't confuse us.  */
3503       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3504           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3505               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3506         {
3507           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3508                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3509           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3510                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3511
3512           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3513               && DECL_SOURCE_LINE (olddecl) != 0
3514               && flag_exceptions
3515               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3516                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3517             {
3518               cp_error ("declaration of `%F' throws different exceptions",
3519                         newdecl);
3520               cp_error_at ("than previous declaration `%F'", olddecl);
3521             }
3522         }
3523       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3524
3525       /* Lay the type out, unless already done.  */
3526       if (! same_type_p (newtype, oldtype)
3527           && TREE_TYPE (newdecl) != error_mark_node
3528           && !(processing_template_decl && uses_template_parms (newdecl)))
3529         layout_type (TREE_TYPE (newdecl));
3530
3531       if ((TREE_CODE (newdecl) == VAR_DECL
3532            || TREE_CODE (newdecl) == PARM_DECL
3533            || TREE_CODE (newdecl) == RESULT_DECL
3534            || TREE_CODE (newdecl) == FIELD_DECL
3535            || TREE_CODE (newdecl) == TYPE_DECL)
3536           && !(processing_template_decl && uses_template_parms (newdecl)))
3537         layout_decl (newdecl, 0);
3538
3539       /* Merge the type qualifiers.  */
3540       if (TREE_READONLY (newdecl))
3541         TREE_READONLY (olddecl) = 1;
3542       if (TREE_THIS_VOLATILE (newdecl))
3543         TREE_THIS_VOLATILE (olddecl) = 1;
3544
3545       /* Merge the initialization information.  */
3546       if (DECL_INITIAL (newdecl) == NULL_TREE
3547           && DECL_INITIAL (olddecl) != NULL_TREE)
3548         {
3549           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3550           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3551           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3552           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3553               && DECL_LANG_SPECIFIC (newdecl)
3554               && DECL_LANG_SPECIFIC (olddecl))
3555             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3556         }
3557
3558       /* Merge the section attribute.
3559          We want to issue an error if the sections conflict but that must be
3560          done later in decl_attributes since we are called before attributes
3561          are assigned.  */
3562       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3563         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3564
3565       /* Keep the old rtl since we can safely use it.  */
3566       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3567
3568       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3569         {
3570           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3571             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3572           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3573             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3574           DECL_NO_LIMIT_STACK (newdecl)
3575             |= DECL_NO_LIMIT_STACK (olddecl);
3576         }
3577     }
3578   /* If cannot merge, then use the new type and qualifiers,
3579      and don't preserve the old rtl.  */
3580   else
3581     {
3582       /* Clean out any memory we had of the old declaration.  */
3583       tree oldstatic = value_member (olddecl, static_aggregates);
3584       if (oldstatic)
3585         TREE_VALUE (oldstatic) = error_mark_node;
3586
3587       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3588       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3589       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3590       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3591     }
3592
3593   /* Merge the storage class information.  */
3594   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3595   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3596   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3597   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3598   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3599   if (! DECL_EXTERNAL (olddecl))
3600     DECL_EXTERNAL (newdecl) = 0;
3601
3602   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3603     {
3604       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3605       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3606       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3607       DECL_TEMPLATE_INSTANTIATED (newdecl)
3608         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3609       /* Don't really know how much of the language-specific
3610          values we should copy from old to new.  */
3611       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3612       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3613       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3614       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3615       olddecl_friend = DECL_FRIEND_P (olddecl);
3616
3617       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3618       if (TREE_CODE (newdecl) == FUNCTION_DECL
3619           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3620         DECL_BEFRIENDING_CLASSES (newdecl)
3621           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3622                      DECL_BEFRIENDING_CLASSES (olddecl));
3623     }
3624
3625   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3626     {
3627       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3628           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3629         {
3630           /* If newdecl is not a specialization, then it is not a
3631              template-related function at all.  And that means that we
3632              shoud have exited above, returning 0.  */
3633           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3634                               0);
3635
3636           if (TREE_USED (olddecl))
3637             /* From [temp.expl.spec]:
3638
3639                If a template, a member template or the member of a class
3640                template is explicitly specialized then that
3641                specialization shall be declared before the first use of
3642                that specialization that would cause an implicit
3643                instantiation to take place, in every translation unit in
3644                which such a use occurs.  */
3645             cp_error ("explicit specialization of %D after first use",
3646                       olddecl);
3647
3648           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3649         }
3650       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3651
3652       /* If either decl says `inline', this fn is inline, unless its
3653          definition was passed already.  */
3654       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3655         DECL_INLINE (olddecl) = 1;
3656       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3657
3658       if (! types_match)
3659         {
3660           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3661           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3662           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3663         }
3664       if (! types_match || new_defines_function)
3665         {
3666           /* These need to be copied so that the names are available.
3667              Note that if the types do match, we'll preserve inline
3668              info and other bits, but if not, we won't.  */
3669           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3670           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3671         }
3672       if (new_defines_function)
3673         /* If defining a function declared with other language
3674            linkage, use the previously declared language linkage.  */
3675         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3676       else if (types_match)
3677         {
3678           /* If redeclaring a builtin function, and not a definition,
3679              it stays built in.  */
3680           if (DECL_BUILT_IN (olddecl))
3681             {
3682               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3683               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3684               /* If we're keeping the built-in definition, keep the rtl,
3685                  regardless of declaration matches.  */
3686               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3687             }
3688           else
3689             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3690
3691           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3692           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3693             /* Previously saved insns go together with
3694                the function's previous definition.  */
3695             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3696           /* Don't clear out the arguments if we're redefining a function.  */
3697           if (DECL_ARGUMENTS (olddecl))
3698             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3699         }
3700     }
3701
3702   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3703     {
3704       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3705     }
3706
3707   /* Now preserve various other info from the definition.  */
3708   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3709   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3710   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3711   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3712
3713   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3714     {
3715       int function_size;
3716
3717       function_size = sizeof (struct tree_decl);
3718
3719       bcopy ((char *) newdecl + sizeof (struct tree_common),
3720              (char *) olddecl + sizeof (struct tree_common),
3721              function_size - sizeof (struct tree_common));
3722
3723       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3724         {
3725           /* If newdecl is a template instantiation, it is possible that
3726              the following sequence of events has occurred:
3727
3728              o A friend function was declared in a class template.  The
3729              class template was instantiated.
3730
3731              o The instantiation of the friend declaration was
3732              recorded on the instantiation list, and is newdecl.
3733
3734              o Later, however, instantiate_class_template called pushdecl
3735              on the newdecl to perform name injection.  But, pushdecl in
3736              turn called duplicate_decls when it discovered that another
3737              declaration of a global function with the same name already
3738              existed.
3739
3740              o Here, in duplicate_decls, we decided to clobber newdecl.
3741
3742              If we're going to do that, we'd better make sure that
3743              olddecl, and not newdecl, is on the list of
3744              instantiations so that if we try to do the instantiation
3745              again we won't get the clobbered declaration.  */
3746
3747           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3748           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3749
3750           for (; decls; decls = TREE_CHAIN (decls))
3751             if (TREE_VALUE (decls) == newdecl)
3752               TREE_VALUE (decls) = olddecl;
3753         }
3754     }
3755   else
3756     {
3757       bcopy ((char *) newdecl + sizeof (struct tree_common),
3758              (char *) olddecl + sizeof (struct tree_common),
3759              sizeof (struct tree_decl) - sizeof (struct tree_common)
3760              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3761     }
3762
3763   DECL_UID (olddecl) = olddecl_uid;
3764   if (olddecl_friend)
3765     DECL_FRIEND_P (olddecl) = 1;
3766
3767   /* NEWDECL contains the merged attribute lists.
3768      Update OLDDECL to be the same.  */
3769   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3770
3771   return 1;
3772 }
3773
3774 /* Record a decl-node X as belonging to the current lexical scope.
3775    Check for errors (such as an incompatible declaration for the same
3776    name already seen in the same scope).
3777
3778    Returns either X or an old decl for the same name.
3779    If an old decl is returned, it may have been smashed
3780    to agree with what X says.  */
3781
3782 tree
3783 pushdecl (x)
3784      tree x;
3785 {
3786   register tree t;
3787   register tree name;
3788   int need_new_binding;
3789
3790   /* We shouldn't be calling pushdecl when we're generating RTL for a
3791      function that we already did semantic analysis on previously.  */
3792   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3793                       19990913);
3794
3795   need_new_binding = 1;
3796
3797   if (DECL_TEMPLATE_PARM_P (x))
3798     /* Template parameters have no context; they are not X::T even
3799        when declared within a class or namespace.  */
3800     ;
3801   else
3802     {
3803       if (current_function_decl && x != current_function_decl
3804           /* A local declaration for a function doesn't constitute
3805              nesting.  */
3806           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3807           /* A local declaration for an `extern' variable is in the
3808              scope of the current namespace, not the current
3809              function.  */
3810           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3811           && !DECL_CONTEXT (x))
3812         DECL_CONTEXT (x) = current_function_decl;
3813
3814       /* If this is the declaration for a namespace-scope function,
3815          but the declaration itself is in a local scope, mark the
3816          declaration.  */
3817       if (TREE_CODE (x) == FUNCTION_DECL
3818           && DECL_NAMESPACE_SCOPE_P (x)
3819           && current_function_decl
3820           && x != current_function_decl)
3821         DECL_LOCAL_FUNCTION_P (x) = 1;
3822     }
3823
3824   name = DECL_NAME (x);
3825   if (name)
3826     {
3827       int different_binding_level = 0;
3828
3829       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3830         name = TREE_OPERAND (name, 0);
3831
3832       /* In case this decl was explicitly namespace-qualified, look it
3833          up in its namespace context.  */
3834       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3835           && namespace_bindings_p ())
3836         t = namespace_binding (name, DECL_CONTEXT (x));
3837       else
3838         t = lookup_name_current_level (name);
3839
3840       /* [basic.link] If there is a visible declaration of an entity
3841          with linkage having the same name and type, ignoring entities
3842          declared outside the innermost enclosing namespace scope, the
3843          block scope declaration declares that same entity and
3844          receives the linkage of the previous declaration.  */
3845       if (! t && current_function_decl && x != current_function_decl
3846           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3847           && DECL_EXTERNAL (x))
3848         {
3849           /* Look in block scope.  */
3850           t = IDENTIFIER_VALUE (name);
3851           /* Or in the innermost namespace.  */
3852           if (! t)
3853             t = namespace_binding (name, DECL_CONTEXT (x));
3854           /* Does it have linkage?  */
3855           if (t && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3856             t = NULL_TREE;
3857           if (t)
3858             different_binding_level = 1;
3859         }
3860
3861       /* If we are declaring a function, and the result of name-lookup
3862          was an OVERLOAD, look for an overloaded instance that is
3863          actually the same as the function we are declaring.  (If
3864          there is one, we have to merge our declaration with the
3865          previous declaration.)  */
3866       if (t && TREE_CODE (t) == OVERLOAD)
3867         {
3868           tree match;
3869
3870           if (TREE_CODE (x) == FUNCTION_DECL)
3871             for (match = t; match; match = OVL_NEXT (match))
3872               {
3873                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3874                     == DECL_ASSEMBLER_NAME (x))
3875                   break;
3876               }
3877           else
3878             /* Just choose one.  */
3879             match = t;
3880
3881           if (match)
3882             t = OVL_CURRENT (match);
3883           else
3884             t = NULL_TREE;
3885         }
3886
3887       if (t == error_mark_node)
3888         {
3889           /* error_mark_node is 0 for a while during initialization!  */
3890           t = NULL_TREE;
3891           cp_error_at ("`%#D' used prior to declaration", x);
3892         }
3893       else if (t != NULL_TREE)
3894         {
3895           if (different_binding_level)
3896             {
3897               if (decls_match (x, t))
3898                 /* The standard only says that the local extern
3899                    inherits linkage from the previous decl; in
3900                    particular, default args are not shared.  It would
3901                    be nice to propagate inlining info, though.  FIXME.  */
3902                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3903             }
3904           else if (TREE_CODE (t) == PARM_DECL)
3905             {
3906               if (DECL_CONTEXT (t) == NULL_TREE)
3907                 fatal ("parse errors have confused me too much");
3908
3909               /* Check for duplicate params.  */
3910               if (duplicate_decls (x, t))
3911                 return t;
3912             }
3913           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3914                     || DECL_FUNCTION_TEMPLATE_P (x))
3915                    && is_overloaded_fn (t))
3916             /* Don't do anything just yet. */;
3917           else if (t == wchar_decl_node)
3918             {
3919               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3920                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3921
3922               /* Throw away the redeclaration.  */
3923               return t;
3924             }
3925           else if (TREE_CODE (t) != TREE_CODE (x))
3926             {
3927               if (duplicate_decls (x, t))
3928                 return t;
3929             }
3930           else if (duplicate_decls (x, t))
3931             {
3932               if (TREE_CODE (t) == TYPE_DECL)
3933                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3934               else if (TREE_CODE (t) == FUNCTION_DECL)
3935                 check_default_args (t);
3936
3937               return t;
3938             }
3939           else if (DECL_MAIN_P (x))
3940             {
3941               /* A redeclaration of main, but not a duplicate of the
3942                  previous one.
3943
3944                  [basic.start.main]
3945
3946                  This function shall not be overloaded.  */
3947               cp_error_at ("invalid redeclaration of `%D'", t);
3948               cp_error ("as `%D'", x);
3949               /* We don't try to push this declaration since that
3950                  causes a crash.  */
3951               return x;
3952             }
3953         }
3954
3955       check_template_shadow (x);
3956
3957       /* If this is a function conjured up by the backend, massage it
3958          so it looks friendly.  */
3959       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3960         {
3961           retrofit_lang_decl (x);
3962           DECL_LANGUAGE (x) = lang_c;
3963         }
3964
3965       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3966         {
3967           t = push_overloaded_decl (x, PUSH_LOCAL);
3968           if (t != x)
3969             return t;
3970           if (!namespace_bindings_p ())
3971             /* We do not need to create a binding for this name;
3972                push_overloaded_decl will have already done so if
3973                necessary.  */
3974             need_new_binding = 0;
3975         }
3976       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3977         {
3978           t = push_overloaded_decl (x, PUSH_GLOBAL);
3979           if (t == x)
3980             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3981           return t;
3982         }
3983
3984       /* If declaring a type as a typedef, copy the type (unless we're
3985          at line 0), and install this TYPE_DECL as the new type's typedef
3986          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3987       if (TREE_CODE (x) == TYPE_DECL)
3988         {
3989           tree type = TREE_TYPE (x);
3990           if (DECL_SOURCE_LINE (x) == 0)
3991             {
3992               if (TYPE_NAME (type) == 0)
3993                 TYPE_NAME (type) = x;
3994             }
3995           else if (type != error_mark_node && TYPE_NAME (type) != x
3996                    /* We don't want to copy the type when all we're
3997                       doing is making a TYPE_DECL for the purposes of
3998                       inlining.  */
3999                    && (!TYPE_NAME (type)
4000                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4001             {
4002               DECL_ORIGINAL_TYPE (x) = type;
4003               type = build_type_copy (type);
4004               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4005               TYPE_NAME (type) = x;
4006               TREE_TYPE (x) = type;
4007             }
4008
4009           if (type != error_mark_node
4010               && TYPE_NAME (type)
4011               && TYPE_IDENTIFIER (type))
4012             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4013                                                   current_binding_level);
4014
4015         }
4016
4017       /* Multiple external decls of the same identifier ought to match.
4018
4019          We get warnings about inline functions where they are defined.
4020          We get warnings about other functions from push_overloaded_decl.
4021
4022          Avoid duplicate warnings where they are used.  */
4023       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4024         {
4025           tree decl;
4026
4027           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4028           if (decl && TREE_CODE (decl) == OVERLOAD)
4029             decl = OVL_FUNCTION (decl);
4030
4031           if (decl && decl != error_mark_node
4032               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4033               /* If different sort of thing, we already gave an error.  */
4034               && TREE_CODE (decl) == TREE_CODE (x)
4035               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4036             {
4037               cp_pedwarn ("type mismatch with previous external decl", x);
4038               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4039             }
4040         }
4041
4042       /* This name is new in its binding level.
4043          Install the new declaration and return it.  */
4044       if (namespace_bindings_p ())
4045         {
4046           /* Install a global value.  */
4047
4048           /* If the first global decl has external linkage,
4049              warn if we later see static one.  */
4050           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4051             TREE_PUBLIC (name) = 1;
4052
4053           /* Bind the mangled name for the entity.  In the future, we
4054              should not need to do this; mangled names are an
4055              implementation detail of which the front-end should not
4056              need to be aware.  */
4057           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4058                 && t != NULL_TREE)
4059               /* For an ordinary function, we create a binding from
4060                  the mangled name (i.e., NAME) to the DECL.  But, for
4061                  an `extern "C"' function, the mangled name and the
4062                  ordinary name are the same so we need not do this.  */
4063               && !DECL_EXTERN_C_FUNCTION_P (x))
4064             {
4065               tree mangled_name;
4066
4067               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4068                   || TREE_CODE (x) == NAMESPACE_DECL)
4069                 mangled_name = name;
4070               else
4071                 mangled_name = DECL_ASSEMBLER_NAME (x);
4072
4073               if (TREE_CODE (x) == FUNCTION_DECL)
4074                 my_friendly_assert
4075                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4076                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4077               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4078             }
4079
4080           /* Don't forget if the function was used via an implicit decl.  */
4081           if (IDENTIFIER_IMPLICIT_DECL (name)
4082               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4083             TREE_USED (x) = 1;
4084
4085           /* Don't forget if its address was taken in that way.  */
4086           if (IDENTIFIER_IMPLICIT_DECL (name)
4087               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4088             TREE_ADDRESSABLE (x) = 1;
4089
4090           /* Warn about mismatches against previous implicit decl.  */
4091           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4092               /* If this real decl matches the implicit, don't complain.  */
4093               && ! (TREE_CODE (x) == FUNCTION_DECL
4094                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4095             cp_warning
4096               ("`%D' was previously implicitly declared to return `int'", x);
4097
4098           /* If new decl is `static' and an `extern' was seen previously,
4099              warn about it.  */
4100           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4101             warn_extern_redeclared_static (x, t);
4102         }
4103       else
4104         {
4105           /* Here to install a non-global value.  */
4106           tree oldlocal = IDENTIFIER_VALUE (name);
4107           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4108
4109           if (need_new_binding)
4110             {
4111               push_local_binding (name, x, 0);
4112               /* Because push_local_binding will hook X on to the
4113                  current_binding_level's name list, we don't want to
4114                  do that again below.  */
4115               need_new_binding = 0;
4116             }
4117
4118           /* If this is a TYPE_DECL, push it into the type value slot.  */
4119           if (TREE_CODE (x) == TYPE_DECL)
4120             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4121                                                   current_binding_level);
4122
4123           /* Clear out any TYPE_DECL shadowed by a namespace so that
4124              we won't think this is a type.  The C struct hack doesn't
4125              go through namespaces.  */
4126           if (TREE_CODE (x) == NAMESPACE_DECL)
4127             set_identifier_type_value_with_scope (name, NULL_TREE,
4128                                                   current_binding_level);
4129
4130           if (oldlocal)
4131             {
4132               tree d = oldlocal;
4133
4134               while (oldlocal
4135                      && TREE_CODE (oldlocal) == VAR_DECL
4136                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4137                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4138
4139               if (oldlocal == NULL_TREE)
4140                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4141             }
4142
4143           /* If this is an extern function declaration, see if we
4144              have a global definition or declaration for the function.  */
4145           if (oldlocal == NULL_TREE
4146               && DECL_EXTERNAL (x)
4147               && oldglobal != NULL_TREE
4148               && TREE_CODE (x) == FUNCTION_DECL
4149               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4150             {
4151               /* We have one.  Their types must agree.  */
4152               if (decls_match (x, oldglobal))
4153                 /* OK */;
4154               else
4155                 {
4156                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4157                   cp_warning_at ("global declaration `%#D'", oldglobal);
4158                 }
4159             }
4160           /* If we have a local external declaration,
4161              and no file-scope declaration has yet been seen,
4162              then if we later have a file-scope decl it must not be static.  */
4163           if (oldlocal == NULL_TREE
4164               && oldglobal == NULL_TREE
4165               && DECL_EXTERNAL (x)
4166               && TREE_PUBLIC (x))
4167             TREE_PUBLIC (name) = 1;
4168
4169           /* Warn if shadowing an argument at the top level of the body.  */
4170           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4171               /* Inline decls shadow nothing.  */
4172               && !DECL_FROM_INLINE (x)
4173               && TREE_CODE (oldlocal) == PARM_DECL
4174               /* Don't complain if it's from an enclosing function.  */
4175               && DECL_CONTEXT (oldlocal) == current_function_decl
4176               && TREE_CODE (x) != PARM_DECL)
4177             {
4178               /* Go to where the parms should be and see if we
4179                  find them there.  */
4180               struct binding_level *b = current_binding_level->level_chain;
4181
4182               if (cleanup_label)
4183                 b = b->level_chain;
4184
4185               /* ARM $8.3 */
4186               if (b->parm_flag == 1)
4187                 cp_error ("declaration of `%#D' shadows a parameter", name);
4188             }
4189
4190           /* Maybe warn if shadowing something else.  */
4191           if (warn_shadow && !DECL_EXTERNAL (x)
4192               /* Inline decls shadow nothing.  */
4193               && !DECL_FROM_INLINE (x)
4194               /* No shadow warnings for internally generated vars.  */
4195               && ! DECL_ARTIFICIAL (x)
4196               /* No shadow warnings for vars made for inlining.  */
4197               && ! DECL_FROM_INLINE (x))
4198             {
4199               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4200                 warning ("declaration of `%s' shadows a parameter",
4201                         IDENTIFIER_POINTER (name));
4202               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4203                        && current_class_ptr
4204                        && !TREE_STATIC (name))
4205                 warning ("declaration of `%s' shadows a member of `this'",
4206                         IDENTIFIER_POINTER (name));
4207               else if (oldlocal != NULL_TREE)
4208                 warning ("declaration of `%s' shadows previous local",
4209                         IDENTIFIER_POINTER (name));
4210               else if (oldglobal != NULL_TREE)
4211                 /* XXX shadow warnings in outer-more namespaces */
4212                 warning ("declaration of `%s' shadows global declaration",
4213                         IDENTIFIER_POINTER (name));
4214             }
4215         }
4216
4217       if (TREE_CODE (x) == FUNCTION_DECL)
4218         check_default_args (x);
4219
4220       /* Keep count of variables in this level with incomplete type.  */
4221       if (TREE_CODE (x) == VAR_DECL
4222           && TREE_TYPE (x) != error_mark_node
4223           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4224                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4225               /* RTTI TD entries are created while defining the type_info.  */
4226               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4227                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4228         {
4229           if (namespace_bindings_p ())
4230             namespace_scope_incomplete
4231               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4232           else
4233             current_binding_level->incomplete
4234               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4235         }
4236     }
4237
4238   if (need_new_binding)
4239     add_decl_to_level (x,
4240                        DECL_NAMESPACE_SCOPE_P (x)
4241                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4242                        : current_binding_level);
4243
4244   return x;
4245 }
4246
4247 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4248    caller to set DECL_CONTEXT properly.  */
4249
4250 static tree
4251 pushdecl_with_scope (x, level)
4252      tree x;
4253      struct binding_level *level;
4254 {
4255   register struct binding_level *b;
4256   tree function_decl = current_function_decl;
4257
4258   current_function_decl = NULL_TREE;
4259   if (level->parm_flag == 2)
4260     {
4261       b = class_binding_level;
4262       class_binding_level = level;
4263       pushdecl_class_level (x);
4264       class_binding_level = b;
4265     }
4266   else
4267     {
4268       b = current_binding_level;
4269       current_binding_level = level;
4270       x = pushdecl (x);
4271       current_binding_level = b;
4272     }
4273   current_function_decl = function_decl;
4274   return x;
4275 }
4276
4277 /* Like pushdecl, only it places X in the current namespace,
4278    if appropriate.  */
4279
4280 tree
4281 pushdecl_namespace_level (x)
4282      tree x;
4283 {
4284   register struct binding_level *b = current_binding_level;
4285   register tree t;
4286
4287   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4288
4289   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4290      what we want.  */
4291   if (TREE_CODE (x) == TYPE_DECL)
4292     {
4293       tree name = DECL_NAME (x);
4294       tree newval;
4295       tree *ptr = (tree *)0;
4296       for (; b != global_binding_level; b = b->level_chain)
4297         {
4298           tree shadowed = b->type_shadowed;
4299           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4300             if (TREE_PURPOSE (shadowed) == name)
4301               {
4302                 ptr = &TREE_VALUE (shadowed);
4303                 /* Can't break out of the loop here because sometimes
4304                    a binding level will have duplicate bindings for
4305                    PT names.  It's gross, but I haven't time to fix it.  */
4306               }
4307         }
4308       newval = TREE_TYPE (x);
4309       if (ptr == (tree *)0)
4310         {
4311           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4312              up here if this is changed to an assertion.  --KR  */
4313           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4314         }
4315       else
4316         {
4317           *ptr = newval;
4318         }
4319     }
4320   return t;
4321 }
4322
4323 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4324    if appropriate.  */
4325
4326 tree
4327 pushdecl_top_level (x)
4328      tree x;
4329 {
4330   push_to_top_level ();
4331   x = pushdecl_namespace_level (x);
4332   pop_from_top_level ();
4333   return x;
4334 }
4335
4336 /* Make the declaration of X appear in CLASS scope.  */
4337
4338 void
4339 pushdecl_class_level (x)
4340      tree x;
4341 {
4342   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4343      scope looks for the pre-mangled name.  */
4344   register tree name;
4345
4346   if (TREE_CODE (x) == OVERLOAD)
4347     x = OVL_CURRENT (x);
4348   name = DECL_NAME (x);
4349
4350   if (name)
4351     {
4352       push_class_level_binding (name, x);
4353       if (TREE_CODE (x) == TYPE_DECL)
4354         set_identifier_type_value (name, TREE_TYPE (x));
4355     }
4356   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4357     {
4358       tree f;
4359
4360       for (f = TYPE_FIELDS (TREE_TYPE (x));
4361            f;
4362            f = TREE_CHAIN (f))
4363         pushdecl_class_level (f);
4364     }
4365 }
4366
4367 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4368    DECL, or a modified version thereof.  */
4369
4370 tree
4371 maybe_push_decl (decl)
4372      tree decl;
4373 {
4374   tree type = TREE_TYPE (decl);
4375
4376   /* Add this decl to the current binding level, but not if it comes
4377      from another scope, e.g. a static member variable.  TEM may equal
4378      DECL or it may be a previous decl of the same name.  */
4379   if (decl == error_mark_node
4380       || (TREE_CODE (decl) != PARM_DECL
4381           && DECL_CONTEXT (decl) != NULL_TREE
4382           /* Definitions of namespace members outside their namespace are
4383              possible. */
4384           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4385       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4386       || TREE_CODE (type) == UNKNOWN_TYPE
4387       /* The declaration of a template specialization does not affect
4388          the functions available for overload resolution, so we do not
4389          call pushdecl.  */
4390       || (TREE_CODE (decl) == FUNCTION_DECL
4391           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4392     return decl;
4393   else
4394     return pushdecl (decl);
4395 }
4396
4397 /* Make the declaration(s) of X appear in CLASS scope
4398    under the name NAME.  */
4399
4400 void
4401 push_class_level_binding (name, x)
4402      tree name;
4403      tree x;
4404 {
4405   tree binding;
4406   /* The class_binding_level will be NULL if x is a template
4407      parameter name in a member template.  */
4408   if (!class_binding_level)
4409     return;
4410
4411   /* Make sure that this new member does not have the same name
4412      as a template parameter.  */
4413   if (TYPE_BEING_DEFINED (current_class_type))
4414     check_template_shadow (x);
4415
4416   /* If this declaration shadows a declaration from an enclosing
4417      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4418      we leave this class.  Record the shadowed declaration here.  */
4419   binding = IDENTIFIER_BINDING (name);
4420   if (binding
4421       && ((TREE_CODE (x) == OVERLOAD
4422            && BINDING_VALUE (binding)
4423            && is_overloaded_fn (BINDING_VALUE (binding)))
4424           || INHERITED_VALUE_BINDING_P (binding)))
4425     {
4426       tree shadow;
4427       tree old_decl;
4428
4429       /* If the old binding was from a base class, and was for a tag
4430          name, slide it over to make room for the new binding.  The
4431          old binding is still visible if explicitly qualified with a
4432          class-key.  */
4433       if (INHERITED_VALUE_BINDING_P (binding)
4434           && BINDING_VALUE (binding)
4435           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4436           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4437           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4438         {
4439           old_decl = BINDING_TYPE (binding);
4440           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4441           BINDING_VALUE (binding) = NULL_TREE;
4442           INHERITED_VALUE_BINDING_P (binding) = 0;
4443         }
4444       else
4445         old_decl = BINDING_VALUE (binding);
4446
4447       /* There was already a binding for X containing fewer
4448          functions than are named in X.  Find the previous
4449          declaration of X on the class-shadowed list, and update it.  */
4450       for (shadow = class_binding_level->class_shadowed;
4451            shadow;
4452            shadow = TREE_CHAIN (shadow))
4453         if (TREE_PURPOSE (shadow) == name
4454             && TREE_TYPE (shadow) == old_decl)
4455           {
4456             BINDING_VALUE (binding) = x;
4457             INHERITED_VALUE_BINDING_P (binding) = 0;
4458             TREE_TYPE (shadow) = x;
4459             return;
4460           }
4461     }
4462
4463   /* If we didn't replace an existing binding, put the binding on the
4464      stack of bindings for the identifier, and update
4465      IDENTIFIER_CLASS_VALUE.  */
4466   if (push_class_binding (name, x))
4467     {
4468       class_binding_level->class_shadowed
4469         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4470                      class_binding_level->class_shadowed);
4471       /* Record the value we are binding NAME to so that we can know
4472          what to pop later.  */
4473       TREE_TYPE (class_binding_level->class_shadowed) = x;
4474     }
4475 }
4476
4477 /* Insert another USING_DECL into the current binding level, returning
4478    this declaration. If this is a redeclaration, do nothing, and
4479    return NULL_TREE if this not in namespace scope (in namespace
4480    scope, a using decl might extend any previous bindings).  */
4481
4482 tree
4483 push_using_decl (scope, name)
4484      tree scope;
4485      tree name;
4486 {
4487   tree decl;
4488
4489   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4490   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4491   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4492     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4493       break;
4494   if (decl)
4495     return namespace_bindings_p () ? decl : NULL_TREE;
4496   decl = build_lang_decl (USING_DECL, name, void_type_node);
4497   DECL_INITIAL (decl) = scope;
4498   TREE_CHAIN (decl) = current_binding_level->usings;
4499   current_binding_level->usings = decl;
4500   return decl;
4501 }
4502
4503 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4504    changed (i.e. there was already a directive), or the fresh
4505    TREE_LIST otherwise.  */
4506
4507 tree
4508 push_using_directive (used)
4509      tree used;
4510 {
4511   tree ud = current_binding_level->using_directives;
4512   tree iter, ancestor;
4513
4514   /* Check if we already have this. */
4515   if (purpose_member (used, ud) != NULL_TREE)
4516     return NULL_TREE;
4517
4518   /* Recursively add all namespaces used. */
4519   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4520     push_using_directive (TREE_PURPOSE (iter));
4521
4522   ancestor = namespace_ancestor (current_decl_namespace (), used);
4523   ud = current_binding_level->using_directives;
4524   ud = tree_cons (used, ancestor, ud);
4525   current_binding_level->using_directives = ud;
4526   return ud;
4527 }
4528
4529 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4530    other definitions already in place.  We get around this by making
4531    the value of the identifier point to a list of all the things that
4532    want to be referenced by that name.  It is then up to the users of
4533    that name to decide what to do with that list.
4534
4535    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4536    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4537
4538    FLAGS is a bitwise-or of the following values:
4539      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4540                  namespace scope.
4541      PUSH_USING: DECL is being pushed as the result of a using
4542                  declaration.
4543
4544    The value returned may be a previous declaration if we guessed wrong
4545    about what language DECL should belong to (C or C++).  Otherwise,
4546    it's always DECL (and never something that's not a _DECL).  */
4547
4548 tree
4549 push_overloaded_decl (decl, flags)
4550      tree decl;
4551      int flags;
4552 {
4553   tree name = DECL_NAME (decl);
4554   tree old;
4555   tree new_binding;
4556   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4557
4558   if (doing_global)
4559     old = namespace_binding (name, DECL_CONTEXT (decl));
4560   else
4561     old = lookup_name_current_level (name);
4562
4563   if (old)
4564     {
4565       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4566         {
4567           tree t = TREE_TYPE (old);
4568           if (IS_AGGR_TYPE (t) && warn_shadow
4569               && (! DECL_IN_SYSTEM_HEADER (decl)
4570                   || ! DECL_IN_SYSTEM_HEADER (old)))
4571             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4572           old = NULL_TREE;
4573         }
4574       else if (is_overloaded_fn (old))
4575         {
4576           tree tmp;
4577
4578           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4579             {
4580               tree fn = OVL_CURRENT (tmp);
4581
4582               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4583                   && !(flags & PUSH_USING)
4584                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4585                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4586                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4587                           decl, fn);
4588
4589               if (duplicate_decls (decl, fn))
4590                 return fn;
4591             }
4592         }
4593       else if (old == error_mark_node)
4594         /* Ignore the undefined symbol marker.  */
4595         old = NULL_TREE;
4596       else
4597         {
4598           cp_error_at ("previous non-function declaration `%#D'", old);
4599           cp_error ("conflicts with function declaration `%#D'", decl);
4600           return decl;
4601         }
4602     }
4603
4604   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4605     {
4606       if (old && TREE_CODE (old) != OVERLOAD)
4607         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4608       else
4609         new_binding = ovl_cons (decl, old);
4610       if (flags & PUSH_USING)
4611         OVL_USED (new_binding) = 1;
4612     }
4613   else
4614     /* NAME is not ambiguous.  */
4615     new_binding = decl;
4616
4617   if (doing_global)
4618     set_namespace_binding (name, current_namespace, new_binding);
4619   else
4620     {
4621       /* We only create an OVERLOAD if there was a previous binding at
4622          this level, or if decl is a template. In the former case, we
4623          need to remove the old binding and replace it with the new
4624          binding.  We must also run through the NAMES on the binding
4625          level where the name was bound to update the chain.  */
4626
4627       if (TREE_CODE (new_binding) == OVERLOAD && old)
4628         {
4629           tree *d;
4630
4631           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4632                *d;
4633                d = &TREE_CHAIN (*d))
4634             if (*d == old
4635                 || (TREE_CODE (*d) == TREE_LIST
4636                     && TREE_VALUE (*d) == old))
4637               {
4638                 if (TREE_CODE (*d) == TREE_LIST)
4639                   /* Just replace the old binding with the new.  */
4640                   TREE_VALUE (*d) = new_binding;
4641                 else
4642                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4643                   *d = tree_cons (NULL_TREE, new_binding,
4644                                   TREE_CHAIN (*d));
4645
4646                 /* And update the CPLUS_BINDING node.  */
4647                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4648                   = new_binding;
4649                 return decl;
4650               }
4651
4652           /* We should always find a previous binding in this case.  */
4653           my_friendly_abort (0);
4654         }
4655
4656       /* Install the new binding.  */
4657       push_local_binding (name, new_binding, flags);
4658     }
4659
4660   return decl;
4661 }
4662 \f
4663 /* Generate an implicit declaration for identifier FUNCTIONID
4664    as a function of type int ().  Print a warning if appropriate.  */
4665
4666 tree
4667 implicitly_declare (functionid)
4668      tree functionid;
4669 {
4670   register tree decl;
4671
4672   /* We used to reuse an old implicit decl here,
4673      but this loses with inline functions because it can clobber
4674      the saved decl chains.  */
4675   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4676
4677   DECL_EXTERNAL (decl) = 1;
4678   TREE_PUBLIC (decl) = 1;
4679
4680   /* ISO standard says implicit declarations are in the innermost block.
4681      So we record the decl in the standard fashion.  */
4682   pushdecl (decl);
4683   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4684
4685   if (warn_implicit
4686       /* Only one warning per identifier.  */
4687       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4688     {
4689       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4690     }
4691
4692   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4693
4694   return decl;
4695 }
4696
4697 /* Return zero if the declaration NEWDECL is valid
4698    when the declaration OLDDECL (assumed to be for the same name)
4699    has already been seen.
4700    Otherwise return an error message format string with a %s
4701    where the identifier should go.  */
4702
4703 static const char *
4704 redeclaration_error_message (newdecl, olddecl)
4705      tree newdecl, olddecl;
4706 {
4707   if (TREE_CODE (newdecl) == TYPE_DECL)
4708     {
4709       /* Because C++ can put things into name space for free,
4710          constructs like "typedef struct foo { ... } foo"
4711          would look like an erroneous redeclaration.  */
4712       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4713         return 0;
4714       else
4715         return "redefinition of `%#D'";
4716     }
4717   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4718     {
4719       /* If this is a pure function, its olddecl will actually be
4720          the original initialization to `0' (which we force to call
4721          abort()).  Don't complain about redefinition in this case.  */
4722       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4723         return 0;
4724
4725       /* If both functions come from different namespaces, this is not
4726          a redeclaration - this is a conflict with a used function. */
4727       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4728           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4729         return "`%D' conflicts with used function";
4730
4731       /* We'll complain about linkage mismatches in
4732          warn_extern_redeclared_static.  */
4733
4734       /* Defining the same name twice is no good.  */
4735       if (DECL_INITIAL (olddecl) != NULL_TREE
4736           && DECL_INITIAL (newdecl) != NULL_TREE)
4737         {
4738           if (DECL_NAME (olddecl) == NULL_TREE)
4739             return "`%#D' not declared in class";
4740           else
4741             return "redefinition of `%#D'";
4742         }
4743       return 0;
4744     }
4745   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4746     {
4747       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4748            && (DECL_TEMPLATE_RESULT (newdecl)
4749                != DECL_TEMPLATE_RESULT (olddecl))
4750            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4751            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4752           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4753               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4754               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4755         return "redefinition of `%#D'";
4756       return 0;
4757     }
4758   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4759     {
4760       /* Objects declared at top level:  */
4761       /* If at least one is a reference, it's ok.  */
4762       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4763         return 0;
4764       /* Reject two definitions.  */
4765       return "redefinition of `%#D'";
4766     }
4767   else
4768     {
4769       /* Objects declared with block scope:  */
4770       /* Reject two definitions, and reject a definition
4771          together with an external reference.  */
4772       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4773         return "redeclaration of `%#D'";
4774       return 0;
4775     }
4776 }
4777 \f
4778 /* Create a new label, named ID.  */
4779
4780 static tree
4781 make_label_decl (id, local_p)
4782      tree id;
4783      int local_p;
4784 {
4785   tree decl;
4786
4787   decl = build_decl (LABEL_DECL, id, void_type_node);
4788   if (expanding_p)
4789     /* Make sure every label has an rtx.  */
4790     label_rtx (decl);
4791
4792   DECL_CONTEXT (decl) = current_function_decl;
4793   DECL_MODE (decl) = VOIDmode;
4794   C_DECLARED_LABEL_FLAG (decl) = local_p;
4795
4796   /* Say where one reference is to the label, for the sake of the
4797      error if it is not defined.  */
4798   DECL_SOURCE_LINE (decl) = lineno;
4799   DECL_SOURCE_FILE (decl) = input_filename;
4800
4801   /* Record the fact that this identifier is bound to this label.  */
4802   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4803
4804   return decl;
4805 }
4806
4807 /* Record this label on the list of used labels so that we can check
4808    at the end of the function to see whether or not the label was
4809    actually defined, and so we can check when the label is defined whether
4810    this use is valid.  */
4811
4812 static void
4813 use_label (decl)
4814      tree decl;
4815 {
4816   if (named_label_uses == NULL
4817       || named_label_uses->names_in_scope != current_binding_level->names
4818       || named_label_uses->label_decl != decl)
4819     {
4820       struct named_label_use_list *new_ent;
4821       new_ent = ((struct named_label_use_list *)
4822                  ggc_alloc (sizeof (struct named_label_use_list)));
4823       new_ent->label_decl = decl;
4824       new_ent->names_in_scope = current_binding_level->names;
4825       new_ent->binding_level = current_binding_level;
4826       new_ent->lineno_o_goto = lineno;
4827       new_ent->filename_o_goto = input_filename;
4828       new_ent->next = named_label_uses;
4829       named_label_uses = new_ent;
4830     }
4831 }
4832
4833 /* Look for a label named ID in the current function.  If one cannot
4834    be found, create one.  (We keep track of used, but undefined,
4835    labels, and complain about them at the end of a function.)  */
4836
4837 tree
4838 lookup_label (id)
4839      tree id;
4840 {
4841   tree decl;
4842   struct named_label_list *ent;
4843
4844   /* You can't use labels at global scope.  */
4845   if (current_function_decl == NULL_TREE)
4846     {
4847       error ("label `%s' referenced outside of any function",
4848              IDENTIFIER_POINTER (id));
4849       return NULL_TREE;
4850     }
4851
4852   /* See if we've already got this label.  */
4853   decl = IDENTIFIER_LABEL_VALUE (id);
4854   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4855     return decl;
4856
4857   /* Record this label on the list of labels used in this function.
4858      We do this before calling make_label_decl so that we get the
4859      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4860   ent = ((struct named_label_list *)
4861          ggc_alloc_cleared (sizeof (struct named_label_list)));
4862   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4863   ent->next = named_labels;
4864   named_labels = ent;
4865
4866   /* We need a new label.  */
4867   decl = make_label_decl (id, /*local_p=*/0);
4868
4869   /* Now fill in the information we didn't have before.  */
4870   ent->label_decl = decl;
4871
4872   return decl;
4873 }
4874
4875 /* Declare a local label named ID.  */
4876
4877 tree
4878 declare_local_label (id)
4879      tree id;
4880 {
4881   tree decl;
4882
4883   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4884      this scope we can restore the old value of
4885      IDENTIFIER_TYPE_VALUE.  */
4886   current_binding_level->shadowed_labels
4887     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4888                  current_binding_level->shadowed_labels);
4889   /* Look for the label.  */
4890   decl = make_label_decl (id, /*local_p=*/1);
4891   /* Now fill in the information we didn't have before.  */
4892   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4893
4894   return decl;
4895 }
4896
4897 /* Returns nonzero if it is ill-formed to jump past the declaration of
4898    DECL.  Returns 2 if it's also a real problem.  */
4899
4900 static int
4901 decl_jump_unsafe (decl)
4902      tree decl;
4903 {
4904   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4905     return 0;
4906
4907   if (DECL_INITIAL (decl) == NULL_TREE
4908       && pod_type_p (TREE_TYPE (decl)))
4909     return 0;
4910
4911   /* This is really only important if we're crossing an initialization.
4912      The POD stuff is just pedantry; why should it matter if the class
4913      contains a field of pointer to member type?  */
4914   if (DECL_INITIAL (decl)
4915       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4916     return 2;
4917   return 1;
4918 }
4919
4920 /* Check that a single previously seen jump to a newly defined label
4921    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4922    the jump context; NAMES are the names in scope in LEVEL at the jump
4923    context; FILE and LINE are the source position of the jump or 0.  */
4924
4925 static void
4926 check_previous_goto_1 (decl, level, names, file, line)
4927      tree decl;
4928      struct binding_level *level;
4929      tree names;
4930      const char *file;
4931      int line;
4932 {
4933   int identified = 0;
4934   int saw_eh = 0;
4935   struct binding_level *b = current_binding_level;
4936   for (; b; b = b->level_chain)
4937     {
4938       tree new_decls = b->names;
4939       tree old_decls = (b == level ? names : NULL_TREE);
4940       for (; new_decls != old_decls;
4941            new_decls = TREE_CHAIN (new_decls))
4942         {
4943           int problem = decl_jump_unsafe (new_decls);
4944           if (! problem)
4945             continue;
4946
4947           if (! identified)
4948             {
4949               if (decl)
4950                 cp_pedwarn ("jump to label `%D'", decl);
4951               else
4952                 pedwarn ("jump to case label");
4953
4954               if (file)
4955                 pedwarn_with_file_and_line (file, line, "  from here");
4956               identified = 1;
4957             }
4958
4959           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4960             /* Can't skip init of __exception_info.  */
4961             cp_error_at ("  enters catch block", new_decls);
4962           else if (problem > 1)
4963             cp_error_at ("  crosses initialization of `%#D'",
4964                          new_decls);
4965           else
4966             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4967                            new_decls);
4968         }
4969
4970       if (b == level)
4971         break;
4972       if (b->eh_region && ! saw_eh)
4973         {
4974           if (! identified)
4975             {
4976               if (decl)
4977                 cp_pedwarn ("jump to label `%D'", decl);
4978               else
4979                 pedwarn ("jump to case label");
4980
4981               if (file)
4982                 pedwarn_with_file_and_line (file, line, "  from here");
4983               identified = 1;
4984             }
4985           error ("  enters try block");
4986           saw_eh = 1;
4987         }
4988     }
4989 }
4990
4991 static void
4992 check_previous_goto (use)
4993      struct named_label_use_list *use;
4994 {
4995   check_previous_goto_1 (use->label_decl, use->binding_level,
4996                          use->names_in_scope, use->filename_o_goto,
4997                          use->lineno_o_goto);
4998 }
4999
5000 static void
5001 check_switch_goto (level)
5002      struct binding_level *level;
5003 {
5004   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5005 }
5006
5007 /* Check that any previously seen jumps to a newly defined label DECL
5008    are OK.  Called by define_label.  */
5009
5010 static void
5011 check_previous_gotos (decl)
5012      tree decl;
5013 {
5014   struct named_label_use_list **usep;
5015
5016   if (! TREE_USED (decl))
5017     return;
5018
5019   for (usep = &named_label_uses; *usep; )
5020     {
5021       struct named_label_use_list *use = *usep;
5022       if (use->label_decl == decl)
5023         {
5024           check_previous_goto (use);
5025           *usep = use->next;
5026         }
5027       else
5028         usep = &(use->next);
5029     }
5030 }
5031
5032 /* Check that a new jump to a label DECL is OK.  Called by
5033    finish_goto_stmt.  */
5034
5035 void
5036 check_goto (decl)
5037      tree decl;
5038 {
5039   int identified = 0;
5040   tree bad;
5041   struct named_label_list *lab;
5042
5043   /* We can't know where a computed goto is jumping.  So we assume
5044      that it's OK.  */
5045   if (! DECL_P (decl))
5046     return;
5047
5048   /* If the label hasn't been defined yet, defer checking.  */
5049   if (! DECL_INITIAL (decl))
5050     {
5051       use_label (decl);
5052       return;
5053     }
5054
5055   for (lab = named_labels; lab; lab = lab->next)
5056     if (decl == lab->label_decl)
5057       break;
5058
5059   /* If the label is not on named_labels it's a gcc local label, so
5060      it must be in an outer scope, so jumping to it is always OK.  */
5061   if (lab == 0)
5062     return;
5063
5064   if ((lab->eh_region || lab->bad_decls) && !identified)
5065     {
5066       cp_pedwarn_at ("jump to label `%D'", decl);
5067       pedwarn ("  from here");
5068       identified = 1;
5069     }
5070
5071   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5072     {
5073       tree b = TREE_VALUE (bad);
5074       int u = decl_jump_unsafe (b);
5075
5076       if (u > 1 && DECL_ARTIFICIAL (b))
5077         /* Can't skip init of __exception_info.  */
5078         cp_error_at ("  enters catch block", b);
5079       else if (u > 1)
5080         cp_error_at ("  skips initialization of `%#D'", b);
5081       else
5082         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5083     }
5084
5085   if (lab->eh_region)
5086     error ("  enters try block");
5087 }
5088
5089 /* Define a label, specifying the location in the source file.
5090    Return the LABEL_DECL node for the label, if the definition is valid.
5091    Otherwise return 0.  */
5092
5093 tree
5094 define_label (filename, line, name)
5095      const char *filename;
5096      int line;
5097      tree name;
5098 {
5099   tree decl = lookup_label (name);
5100   struct named_label_list *ent;
5101
5102   for (ent = named_labels; ent; ent = ent->next)
5103     if (ent->label_decl == decl)
5104       break;
5105
5106   /* After labels, make any new cleanups go into their
5107      own new (temporary) binding contour.  */
5108   current_binding_level->more_cleanups_ok = 0;
5109
5110   if (name == get_identifier ("wchar_t"))
5111     cp_pedwarn ("label named wchar_t");
5112
5113   if (DECL_INITIAL (decl) != NULL_TREE)
5114     {
5115       cp_error ("duplicate label `%D'", decl);
5116       return 0;
5117     }
5118   else
5119     {
5120       /* Mark label as having been defined.  */
5121       DECL_INITIAL (decl) = error_mark_node;
5122       /* Say where in the source.  */
5123       DECL_SOURCE_FILE (decl) = filename;
5124       DECL_SOURCE_LINE (decl) = line;
5125       if (ent)
5126         {
5127           ent->names_in_scope = current_binding_level->names;
5128           ent->binding_level = current_binding_level;
5129         }
5130       check_previous_gotos (decl);
5131       current_function_return_value = NULL_TREE;
5132       return decl;
5133     }
5134 }
5135
5136 struct cp_switch
5137 {
5138   struct binding_level *level;
5139   struct cp_switch *next;
5140   /* The SWITCH_STMT being built.  */
5141   tree switch_stmt;
5142   /* A splay-tree mapping the low element of a case range to the high
5143      element, or NULL_TREE if there is no high element.  Used to
5144      determine whether or not a new case label duplicates an old case
5145      label.  We need a tree, rather than simply a hash table, because
5146      of the GNU case range extension.  */
5147   splay_tree cases;
5148 };
5149
5150 /* A stack of the currently active switch statements.  The innermost
5151    switch statement is on the top of the stack.  There is no need to
5152    mark the stack for garbage collection because it is only active
5153    during the processing of the body of a function, and we never
5154    collect at that point.  */
5155
5156 static struct cp_switch *switch_stack;
5157
5158 /* Called right after a switch-statement condition is parsed.
5159    SWITCH_STMT is the switch statement being parsed.  */
5160
5161 void
5162 push_switch (switch_stmt)
5163      tree switch_stmt;
5164 {
5165   struct cp_switch *p
5166     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5167   p->level = current_binding_level;
5168   p->next = switch_stack;
5169   p->switch_stmt = switch_stmt;
5170   p->cases = splay_tree_new (case_compare, NULL, NULL);
5171   switch_stack = p;
5172 }
5173
5174 void
5175 pop_switch ()
5176 {
5177   struct cp_switch *cs;
5178
5179   cs = switch_stack;
5180   splay_tree_delete (cs->cases);
5181   switch_stack = switch_stack->next;
5182   free (cs);
5183 }
5184
5185 /* Note that we've seen a definition of a case label, and complain if this
5186    is a bad place for one.  */
5187
5188 void
5189 finish_case_label (low_value, high_value)
5190      tree low_value;
5191      tree high_value;
5192 {
5193   tree cond;
5194
5195   if (! switch_stack)
5196     {
5197       if (high_value)
5198         error ("case label not within a switch statement");
5199       else if (low_value)
5200         cp_error ("case label `%E' not within a switch statement",
5201                   low_value);
5202       else
5203         error ("`default' label not within a switch statement");
5204       return;
5205     }
5206
5207   if (processing_template_decl)
5208     {
5209       tree label;
5210
5211       /* For templates, just add the case label; we'll do semantic
5212          analysis at instantiation-time.  */
5213       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5214       add_stmt (build_case_label (low_value, high_value, label));
5215       return;
5216     }
5217
5218   /* Find the condition on which this switch statement depends.  */
5219   cond = SWITCH_COND (switch_stack->switch_stmt);
5220   if (cond && TREE_CODE (cond) == TREE_LIST)
5221     cond = TREE_VALUE (cond);
5222
5223   c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5224
5225   check_switch_goto (switch_stack->level);
5226
5227   /* After labels, make any new cleanups go into their
5228      own new (temporary) binding contour.  */
5229   current_binding_level->more_cleanups_ok = 0;
5230   current_function_return_value = NULL_TREE;
5231 }
5232 \f
5233 /* Return the list of declarations of the current level.
5234    Note that this list is in reverse order unless/until
5235    you nreverse it; and when you do nreverse it, you must
5236    store the result back using `storedecls' or you will lose.  */
5237
5238 tree
5239 getdecls ()
5240 {
5241   return current_binding_level->names;
5242 }
5243
5244 /* Return the list of type-tags (for structs, etc) of the current level.  */
5245
5246 tree
5247 gettags ()
5248 {
5249   return current_binding_level->tags;
5250 }
5251
5252 /* Store the list of declarations of the current level.
5253    This is done for the parameter declarations of a function being defined,
5254    after they are modified in the light of any missing parameters.  */
5255
5256 static void
5257 storedecls (decls)
5258      tree decls;
5259 {
5260   current_binding_level->names = decls;
5261 }
5262
5263 /* Similarly, store the list of tags of the current level.  */
5264
5265 void
5266 storetags (tags)
5267      tree tags;
5268 {
5269   current_binding_level->tags = tags;
5270 }
5271 \f
5272 /* Given NAME, an IDENTIFIER_NODE,
5273    return the structure (or union or enum) definition for that name.
5274    Searches binding levels from BINDING_LEVEL up to the global level.
5275    If THISLEVEL_ONLY is nonzero, searches only the specified context
5276    (but skips any tag-transparent contexts to find one that is
5277    meaningful for tags).
5278    FORM says which kind of type the caller wants;
5279    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5280    If the wrong kind of type is found, and it's not a template, an error is
5281    reported.  */
5282
5283 static tree
5284 lookup_tag (form, name, binding_level, thislevel_only)
5285      enum tree_code form;
5286      tree name;
5287      struct binding_level *binding_level;
5288      int thislevel_only;
5289 {
5290   register struct binding_level *level;
5291   /* Non-zero if, we should look past a template parameter level, even
5292      if THISLEVEL_ONLY.  */
5293   int allow_template_parms_p = 1;
5294
5295   for (level = binding_level; level; level = level->level_chain)
5296     {
5297       register tree tail;
5298       if (ANON_AGGRNAME_P (name))
5299         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5300           {
5301             /* There's no need for error checking here, because
5302                anon names are unique throughout the compilation.  */
5303             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5304               return TREE_VALUE (tail);
5305           }
5306       else if (level->namespace_p)
5307         /* Do namespace lookup. */
5308         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5309           {
5310             tree old = binding_for_name (name, tail);
5311
5312             /* If we just skipped past a template parameter level,
5313                even though THISLEVEL_ONLY, and we find a template
5314                class declaration, then we use the _TYPE node for the
5315                template.  See the example below.  */
5316             if (thislevel_only && !allow_template_parms_p
5317                 && old && BINDING_VALUE (old)
5318                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5319               old = TREE_TYPE (BINDING_VALUE (old));
5320             else
5321               old = BINDING_TYPE (old);
5322
5323             /* If it has an original type, it is a typedef, and we
5324                should not return it.  */
5325             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5326               old = NULL_TREE;
5327             if (old && TREE_CODE (old) != form
5328                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5329               {
5330                 cp_error ("`%#D' redeclared as %C", old, form);
5331                 return NULL_TREE;
5332               }
5333             if (old)
5334               return old;
5335             if (thislevel_only || tail == global_namespace)
5336               return NULL_TREE;
5337           }
5338       else
5339         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5340           {
5341             if (TREE_PURPOSE (tail) == name)
5342               {
5343                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5344                 /* Should tighten this up; it'll probably permit
5345                    UNION_TYPE and a struct template, for example.  */
5346                 if (code != form
5347                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5348                   {
5349                     /* Definition isn't the kind we were looking for.  */
5350                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5351                               form);
5352                     return NULL_TREE;
5353                   }
5354                 return TREE_VALUE (tail);
5355               }
5356           }
5357       if (thislevel_only && ! level->tag_transparent)
5358         {
5359           if (level->template_parms_p && allow_template_parms_p)
5360             {
5361               /* We must deal with cases like this:
5362
5363                    template <class T> struct S;
5364                    template <class T> struct S {};
5365
5366                  When looking up `S', for the second declaration, we
5367                  would like to find the first declaration.  But, we
5368                  are in the pseudo-global level created for the
5369                  template parameters, rather than the (surrounding)
5370                  namespace level.  Thus, we keep going one more level,
5371                  even though THISLEVEL_ONLY is non-zero.  */
5372               allow_template_parms_p = 0;
5373               continue;
5374             }
5375           else
5376             return NULL_TREE;
5377         }
5378     }
5379   return NULL_TREE;
5380 }
5381
5382 #if 0
5383 void
5384 set_current_level_tags_transparency (tags_transparent)
5385      int tags_transparent;
5386 {
5387   current_binding_level->tag_transparent = tags_transparent;
5388 }
5389 #endif
5390
5391 /* Given a type, find the tag that was defined for it and return the tag name.
5392    Otherwise return 0.  However, the value can never be 0
5393    in the cases in which this is used.
5394
5395    C++: If NAME is non-zero, this is the new name to install.  This is
5396    done when replacing anonymous tags with real tag names.  */
5397
5398 static tree
5399 lookup_tag_reverse (type, name)
5400      tree type;
5401      tree name;
5402 {
5403   register struct binding_level *level;
5404
5405   for (level = current_binding_level; level; level = level->level_chain)
5406     {
5407       register tree tail;
5408       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5409         {
5410           if (TREE_VALUE (tail) == type)
5411             {
5412               if (name)
5413                 TREE_PURPOSE (tail) = name;
5414               return TREE_PURPOSE (tail);
5415             }
5416         }
5417     }
5418   return NULL_TREE;
5419 }
5420 \f
5421 /* Look up NAME in the NAMESPACE.  */
5422
5423 tree
5424 lookup_namespace_name (namespace, name)
5425      tree namespace, name;
5426 {
5427   tree val;
5428   tree template_id = NULL_TREE;
5429
5430   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5431
5432   if (TREE_CODE (name) == NAMESPACE_DECL)
5433     /* This happens for A::B<int> when B is a namespace. */
5434     return name;
5435   else if (TREE_CODE (name) == TEMPLATE_DECL)
5436     {
5437       /* This happens for A::B where B is a template, and there are no
5438          template arguments.  */
5439       cp_error ("invalid use of `%D'", name);
5440       return error_mark_node;
5441     }
5442
5443   namespace = ORIGINAL_NAMESPACE (namespace);
5444
5445   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5446     {
5447       template_id = name;
5448       name = TREE_OPERAND (name, 0);
5449       if (TREE_CODE (name) == OVERLOAD)
5450         name = DECL_NAME (OVL_CURRENT (name));
5451       else if (DECL_P (name))
5452         name = DECL_NAME (name);
5453     }
5454
5455   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5456
5457   val = make_node (CPLUS_BINDING);
5458   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5459     return error_mark_node;
5460
5461   if (BINDING_VALUE (val))
5462     {
5463       val = BINDING_VALUE (val);
5464
5465       if (template_id)
5466         {
5467           if (DECL_CLASS_TEMPLATE_P (val))
5468             val = lookup_template_class (val,
5469                                          TREE_OPERAND (template_id, 1),
5470                                          /*in_decl=*/NULL_TREE,
5471                                          /*context=*/NULL_TREE,
5472                                          /*entering_scope=*/0);
5473           else if (DECL_FUNCTION_TEMPLATE_P (val)
5474                    || TREE_CODE (val) == OVERLOAD)
5475             val = lookup_template_function (val,
5476                                             TREE_OPERAND (template_id, 1));
5477           else
5478             {
5479               cp_error ("`%D::%D' is not a template",
5480                         namespace, name);
5481               return error_mark_node;
5482             }
5483         }
5484
5485       /* If we have a single function from a using decl, pull it out.  */
5486       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5487         val = OVL_FUNCTION (val);
5488       return val;
5489     }
5490
5491   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5492   return error_mark_node;
5493 }
5494
5495 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5496
5497 static unsigned long
5498 typename_hash (k)
5499      hash_table_key k;
5500 {
5501   unsigned long hash;
5502   tree t;
5503
5504   t = (tree) k;
5505   hash = (((unsigned long) TYPE_CONTEXT (t))
5506           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5507
5508   return hash;
5509 }
5510
5511 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5512
5513 static boolean
5514 typename_compare (k1, k2)
5515      hash_table_key k1;
5516      hash_table_key k2;
5517 {
5518   tree t1;
5519   tree t2;
5520   tree d1;
5521   tree d2;
5522
5523   t1 = (tree) k1;
5524   t2 = (tree) k2;
5525   d1 = TYPE_NAME (t1);
5526   d2 = TYPE_NAME (t2);
5527
5528   return (DECL_NAME (d1) == DECL_NAME (d2)
5529           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5530           && ((TREE_TYPE (t1) != NULL_TREE)
5531               == (TREE_TYPE (t2) != NULL_TREE))
5532           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5533           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5534 }
5535
5536 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5537    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5538    is non-NULL, this type is being created by the implicit typename
5539    extension, and BASE_TYPE is a type named `t' in some base class of
5540    `T' which depends on template parameters.
5541
5542    Returns the new TYPENAME_TYPE.  */
5543
5544 tree
5545 build_typename_type (context, name, fullname, base_type)
5546      tree context;
5547      tree name;
5548      tree fullname;
5549      tree base_type;
5550 {
5551   tree t;
5552   tree d;
5553   struct hash_entry* e;
5554
5555   static struct hash_table ht;
5556
5557   if (!ht.table)
5558     {
5559       static struct hash_table *h = &ht;
5560       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5561                             &typename_compare))
5562         fatal ("virtual memory exhausted");
5563       ggc_add_tree_hash_table_root (&h, 1);
5564     }
5565
5566   /* Build the TYPENAME_TYPE.  */
5567   t = make_aggr_type (TYPENAME_TYPE);
5568   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5569   TYPENAME_TYPE_FULLNAME (t) = fullname;
5570   TREE_TYPE (t) = base_type;
5571
5572   /* Build the corresponding TYPE_DECL.  */
5573   d = build_decl (TYPE_DECL, name, t);
5574   TYPE_NAME (TREE_TYPE (d)) = d;
5575   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5576   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5577   DECL_ARTIFICIAL (d) = 1;
5578
5579   /* See if we already have this type.  */
5580   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5581   if (e)
5582     t = (tree) e->key;
5583   else
5584     /* Insert the type into the table.  */
5585     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5586
5587   return t;
5588 }
5589
5590 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5591    unless an error occurs, in which case error_mark_node is returned.
5592    If COMPLAIN zero, don't complain about any errors that occur.  */
5593
5594 tree
5595 make_typename_type (context, name, complain)
5596      tree context, name;
5597      int complain;
5598 {
5599   tree fullname;
5600
5601   if (TYPE_P (name))
5602     {
5603       if (!(TYPE_LANG_SPECIFIC (name)
5604             && (CLASSTYPE_IS_TEMPLATE (name)
5605                 || CLASSTYPE_USE_TEMPLATE (name))))
5606         name = TYPE_IDENTIFIER (name);
5607       else
5608         /* Create a TEMPLATE_ID_EXPR for the type.  */
5609         name = build_nt (TEMPLATE_ID_EXPR,
5610                          CLASSTYPE_TI_TEMPLATE (name),
5611                          CLASSTYPE_TI_ARGS (name));
5612     }
5613   else if (TREE_CODE (name) == TYPE_DECL)
5614     name = DECL_NAME (name);
5615
5616   fullname = name;
5617
5618   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5619     {
5620       name = TREE_OPERAND (name, 0);
5621       if (TREE_CODE (name) == TEMPLATE_DECL)
5622         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5623     }
5624   if (TREE_CODE (name) != IDENTIFIER_NODE)
5625     my_friendly_abort (2000);
5626
5627   if (TREE_CODE (context) == NAMESPACE_DECL)
5628     {
5629       /* We can get here from typename_sub0 in the explicit_template_type
5630          expansion.  Just fail.  */
5631       if (complain)
5632         cp_error ("no class template named `%#T' in `%#T'",
5633                   name, context);
5634       return error_mark_node;
5635     }
5636
5637   if (! uses_template_parms (context)
5638       || currently_open_class (context))
5639     {
5640       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5641         {
5642           tree tmpl = NULL_TREE;
5643           if (IS_AGGR_TYPE (context))
5644             tmpl = lookup_field (context, name, 0, 0);
5645           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5646             {
5647               if (complain)
5648                 cp_error ("no class template named `%#T' in `%#T'",
5649                           name, context);
5650               return error_mark_node;
5651             }
5652
5653           return lookup_template_class (tmpl,
5654                                         TREE_OPERAND (fullname, 1),
5655                                         NULL_TREE, context,
5656                                         /*entering_scope=*/0);
5657         }
5658       else
5659         {
5660           tree t;
5661
5662           if (!IS_AGGR_TYPE (context))
5663             {
5664               if (complain)
5665                 cp_error ("no type named `%#T' in `%#T'", name, context);
5666               return error_mark_node;
5667             }
5668
5669           t = lookup_field (context, name, 0, 1);
5670           if (t)
5671             return TREE_TYPE (t);
5672         }
5673     }
5674
5675   /* If the CONTEXT is not a template type, then either the field is
5676      there now or its never going to be.  */
5677   if (!uses_template_parms (context))
5678     {
5679       if (complain)
5680         cp_error ("no type named `%#T' in `%#T'", name, context);
5681       return error_mark_node;
5682     }
5683
5684
5685   return build_typename_type (context, name, fullname,  NULL_TREE);
5686 }
5687
5688 /* Select the right _DECL from multiple choices. */
5689
5690 static tree
5691 select_decl (binding, flags)
5692      tree binding;
5693      int flags;
5694 {
5695   tree val;
5696   val = BINDING_VALUE (binding);
5697
5698   /* When we implicitly declare some builtin entity, we mark it
5699      DECL_ANTICIPATED, so that we know to ignore it until it is
5700      really declared.  */
5701   if (val && DECL_P (val)
5702       && DECL_LANG_SPECIFIC (val)
5703       && DECL_ANTICIPATED (val))
5704     return NULL_TREE;
5705
5706   if (LOOKUP_NAMESPACES_ONLY (flags))
5707     {
5708       /* We are not interested in types. */
5709       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5710         return val;
5711       return NULL_TREE;
5712     }
5713
5714   /* If we could have a type and
5715      we have nothing or we need a type and have none.  */
5716   if (BINDING_TYPE (binding)
5717       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5718                    && TREE_CODE (val) != TYPE_DECL)))
5719     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5720   /* Don't return non-types if we really prefer types. */
5721   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5722            && (TREE_CODE (val) != TEMPLATE_DECL
5723                || !DECL_CLASS_TEMPLATE_P (val)))
5724     val = NULL_TREE;
5725
5726   return val;
5727 }
5728
5729 /* Unscoped lookup of a global: iterate over current namespaces,
5730    considering using-directives.  If SPACESP is non-NULL, store a list
5731    of the namespaces we've considered in it.  */
5732
5733 tree
5734 unqualified_namespace_lookup (name, flags, spacesp)
5735      tree name;
5736      int flags;
5737      tree *spacesp;
5738 {
5739   tree b = make_node (CPLUS_BINDING);
5740   tree initial = current_decl_namespace();
5741   tree scope = initial;
5742   tree siter;
5743   struct binding_level *level;
5744   tree val = NULL_TREE;
5745
5746   if (spacesp)
5747     *spacesp = NULL_TREE;
5748
5749   for (; !val; scope = CP_DECL_CONTEXT (scope))
5750     {
5751       if (spacesp)
5752         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5753       val = binding_for_name (name, scope);
5754
5755       /* Initialize binding for this context. */
5756       BINDING_VALUE (b) = BINDING_VALUE (val);
5757       BINDING_TYPE (b) = BINDING_TYPE (val);
5758
5759       /* Add all _DECLs seen through local using-directives. */
5760       for (level = current_binding_level;
5761            !level->namespace_p;
5762            level = level->level_chain)
5763         if (!lookup_using_namespace (name, b, level->using_directives,
5764                                      scope, flags, spacesp))
5765           /* Give up because of error. */
5766           return error_mark_node;
5767
5768       /* Add all _DECLs seen through global using-directives. */
5769       /* XXX local and global using lists should work equally. */
5770       siter = initial;
5771       while (1)
5772         {
5773           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5774                                        scope, flags, spacesp))
5775             /* Give up because of error. */
5776             return error_mark_node;
5777           if (siter == scope) break;
5778           siter = CP_DECL_CONTEXT (siter);
5779         }
5780
5781       val = select_decl (b, flags);
5782       if (scope == global_namespace)
5783         break;
5784     }
5785   return val;
5786 }
5787
5788 /* Combine prefer_type and namespaces_only into flags.  */
5789
5790 static int
5791 lookup_flags (prefer_type, namespaces_only)
5792   int prefer_type, namespaces_only;
5793 {
5794   if (namespaces_only)
5795     return LOOKUP_PREFER_NAMESPACES;
5796   if (prefer_type > 1)
5797     return LOOKUP_PREFER_TYPES;
5798   if (prefer_type > 0)
5799     return LOOKUP_PREFER_BOTH;
5800   return 0;
5801 }
5802
5803 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5804    ignore it or not.  Subroutine of lookup_name_real.  */
5805
5806 static tree
5807 qualify_lookup (val, flags)
5808      tree val;
5809      int flags;
5810 {
5811   if (val == NULL_TREE)
5812     return val;
5813   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5814     return val;
5815   if ((flags & LOOKUP_PREFER_TYPES)
5816       && (TREE_CODE (val) == TYPE_DECL
5817           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5818               && DECL_CLASS_TEMPLATE_P (val))))
5819     return val;
5820   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5821     return NULL_TREE;
5822   return val;
5823 }
5824
5825 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5826    that.  */
5827
5828 static void
5829 warn_about_implicit_typename_lookup (typename, binding)
5830      tree typename;
5831      tree binding;
5832 {
5833   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5834   tree name = DECL_NAME (typename);
5835
5836   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5837          && CLASSTYPE_TEMPLATE_INFO (subtype)
5838          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5839       && ! (TREE_CODE (binding) == TYPE_DECL
5840             && same_type_p (TREE_TYPE (binding), subtype)))
5841     {
5842       cp_warning ("lookup of `%D' finds `%#D'",
5843                   name, binding);
5844       cp_warning ("  instead of `%D' from dependent base class",
5845                   typename);
5846       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5847                   constructor_name (current_class_type), name);
5848     }
5849 }
5850
5851 /* Look up NAME in the current binding level and its superiors in the
5852    namespace of variables, functions and typedefs.  Return a ..._DECL
5853    node of some kind representing its definition if there is only one
5854    such declaration, or return a TREE_LIST with all the overloaded
5855    definitions if there are many, or return 0 if it is undefined.
5856
5857    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5858    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5859    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5860    Otherwise we prefer non-TYPE_DECLs.
5861
5862    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5863    using IDENTIFIER_CLASS_VALUE.  */
5864
5865 static tree
5866 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5867      tree name;
5868      int prefer_type, nonclass, namespaces_only;
5869 {
5870   tree t;
5871   tree val = NULL_TREE;
5872   int yylex = 0;
5873   tree from_obj = NULL_TREE;
5874   int flags;
5875   int val_is_implicit_typename = 0;
5876
5877   /* Hack: copy flag set by parser, if set. */
5878   if (only_namespace_names)
5879     namespaces_only = 1;
5880
5881   if (prefer_type == -2)
5882     {
5883       extern int looking_for_typename;
5884       tree type = NULL_TREE;
5885
5886       yylex = 1;
5887       prefer_type = looking_for_typename;
5888
5889       flags = lookup_flags (prefer_type, namespaces_only);
5890       /* If the next thing is '<', class templates are types. */
5891       if (looking_for_template)
5892         flags |= LOOKUP_TEMPLATES_EXPECTED;
5893
5894       /* std:: becomes :: for now.  */
5895       if (got_scope && got_scope == fake_std_node)
5896         got_scope = void_type_node;
5897
5898       if (got_scope)
5899         type = got_scope;
5900       else if (got_object != error_mark_node)
5901         type = got_object;
5902
5903       if (type)
5904         {
5905           if (type == error_mark_node)
5906             return error_mark_node;
5907           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5908             type = TREE_TYPE (type);
5909
5910           if (TYPE_P (type))
5911             type = complete_type (type);
5912
5913           if (TREE_CODE (type) == VOID_TYPE)
5914             type = global_namespace;
5915           if (TREE_CODE (type) == NAMESPACE_DECL)
5916             {
5917               val = make_node (CPLUS_BINDING);
5918               flags |= LOOKUP_COMPLAIN;
5919               if (!qualified_lookup_using_namespace (name, type, val, flags))
5920                 return NULL_TREE;
5921               val = select_decl (val, flags);
5922             }
5923           else if (! IS_AGGR_TYPE (type)
5924                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5925                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5926                    || TREE_CODE (type) == TYPENAME_TYPE)
5927             /* Someone else will give an error about this if needed.  */
5928             val = NULL_TREE;
5929           else if (type == current_class_type)
5930             val = IDENTIFIER_CLASS_VALUE (name);
5931           else
5932             {
5933               val = lookup_member (type, name, 0, prefer_type);
5934               type_access_control (type, val);
5935
5936               /* Restore the containing TYPENAME_TYPE if we looked
5937                  through it before.  */
5938               if (got_scope && got_scope != type
5939                   && val && TREE_CODE (val) == TYPE_DECL
5940                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5941                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5942             }
5943         }
5944       else
5945         val = NULL_TREE;
5946
5947       if (got_scope)
5948         goto done;
5949       else if (got_object && val)
5950         {
5951           from_obj = val;
5952           val = NULL_TREE;
5953         }
5954     }
5955   else
5956     {
5957       flags = lookup_flags (prefer_type, namespaces_only);
5958       /* If we're not parsing, we need to complain. */
5959       flags |= LOOKUP_COMPLAIN;
5960     }
5961
5962   /* First, look in non-namespace scopes.  */
5963
5964   if (current_class_type == NULL_TREE)
5965     nonclass = 1;
5966
5967   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5968     {
5969       tree binding;
5970
5971       if (!LOCAL_BINDING_P (t) && nonclass)
5972         /* We're not looking for class-scoped bindings, so keep going.  */
5973         continue;
5974
5975       /* If this is the kind of thing we're looking for, we're done.  */
5976       if (qualify_lookup (BINDING_VALUE (t), flags))
5977         binding = BINDING_VALUE (t);
5978       else if ((flags & LOOKUP_PREFER_TYPES)
5979                && qualify_lookup (BINDING_TYPE (t), flags))
5980         binding = BINDING_TYPE (t);
5981       else
5982         binding = NULL_TREE;
5983
5984       /* Handle access control on types from enclosing or base classes.  */
5985       if (binding && ! yylex
5986           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5987         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5988
5989       if (binding
5990           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5991         {
5992           if (val_is_implicit_typename && !yylex)
5993             warn_about_implicit_typename_lookup (val, binding);
5994           val = binding;
5995           val_is_implicit_typename
5996             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5997           if (!val_is_implicit_typename)
5998             break;
5999         }
6000     }
6001
6002   /* Now lookup in namespace scopes.  */
6003   if (!val || val_is_implicit_typename)
6004     {
6005       t = unqualified_namespace_lookup (name, flags, 0);
6006       if (t)
6007         {
6008           if (val_is_implicit_typename && !yylex)
6009             warn_about_implicit_typename_lookup (val, t);
6010           val = t;
6011         }
6012     }
6013
6014  done:
6015   if (val)
6016     {
6017       /* This should only warn about types used in qualified-ids.  */
6018       if (from_obj && from_obj != val)
6019         {
6020           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6021               && TREE_CODE (val) == TYPE_DECL
6022               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6023             cp_pedwarn ("\
6024 lookup of `%D' in the scope of `%#T' (`%#T') \
6025 does not match lookup in the current scope (`%#T')",
6026                         name, got_object, TREE_TYPE (from_obj),
6027                         TREE_TYPE (val));
6028
6029           /* We don't change val to from_obj if got_object depends on
6030              template parms because that breaks implicit typename for
6031              destructor calls.  */
6032           if (! uses_template_parms (got_object))
6033             val = from_obj;
6034         }
6035
6036       /* If we have a single function from a using decl, pull it out.  */
6037       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6038         val = OVL_FUNCTION (val);
6039     }
6040   else if (from_obj)
6041     val = from_obj;
6042
6043   return val;
6044 }
6045
6046 tree
6047 lookup_name_nonclass (name)
6048      tree name;
6049 {
6050   return lookup_name_real (name, 0, 1, 0);
6051 }
6052
6053 tree
6054 lookup_function_nonclass (name, args)
6055      tree name;
6056      tree args;
6057 {
6058   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6059 }
6060
6061 tree
6062 lookup_name_namespace_only (name)
6063      tree name;
6064 {
6065   /* type-or-namespace, nonclass, namespace_only */
6066   return lookup_name_real (name, 1, 1, 1);
6067 }
6068
6069 tree
6070 lookup_name (name, prefer_type)
6071      tree name;
6072      int prefer_type;
6073 {
6074   return lookup_name_real (name, prefer_type, 0, 0);
6075 }
6076
6077 /* Similar to `lookup_name' but look only in the innermost non-class
6078    binding level.  */
6079
6080 tree
6081 lookup_name_current_level (name)
6082      tree name;
6083 {
6084   struct binding_level *b;
6085   tree t = NULL_TREE;
6086
6087   b = current_binding_level;
6088   while (b->parm_flag == 2)
6089     b = b->level_chain;
6090
6091   if (b->namespace_p)
6092     {
6093       t = IDENTIFIER_NAMESPACE_VALUE (name);
6094
6095       /* extern "C" function() */
6096       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6097         t = TREE_VALUE (t);
6098     }
6099   else if (IDENTIFIER_BINDING (name)
6100            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6101     {
6102       while (1)
6103         {
6104           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6105             return IDENTIFIER_VALUE (name);
6106
6107           if (b->keep == 2)
6108             b = b->level_chain;
6109           else
6110             break;
6111         }
6112     }
6113
6114   return t;
6115 }
6116
6117 /* Like lookup_name_current_level, but for types.  */
6118
6119 tree
6120 lookup_type_current_level (name)
6121      tree name;
6122 {
6123   register tree t = NULL_TREE;
6124
6125   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6126
6127   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6128       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6129     {
6130       struct binding_level *b = current_binding_level;
6131       while (1)
6132         {
6133           if (purpose_member (name, b->type_shadowed))
6134             return REAL_IDENTIFIER_TYPE_VALUE (name);
6135           if (b->keep == 2)
6136             b = b->level_chain;
6137           else
6138             break;
6139         }
6140     }
6141
6142   return t;
6143 }
6144
6145 void
6146 begin_only_namespace_names ()
6147 {
6148   only_namespace_names = 1;
6149 }
6150
6151 void
6152 end_only_namespace_names ()
6153 {
6154   only_namespace_names = 0;
6155 }
6156 \f
6157 /* Push the declarations of builtin types into the namespace.
6158    RID_INDEX is the index of the builtin type
6159    in the array RID_POINTERS.  NAME is the name used when looking
6160    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6161
6162 static void
6163 record_builtin_type (rid_index, name, type)
6164      enum rid rid_index;
6165      const char *name;
6166      tree type;
6167 {
6168   tree rname = NULL_TREE, tname = NULL_TREE;
6169   tree tdecl = NULL_TREE;
6170
6171   if ((int) rid_index < (int) RID_MAX)
6172     rname = ridpointers[(int) rid_index];
6173   if (name)
6174     tname = get_identifier (name);
6175
6176   TYPE_BUILT_IN (type) = 1;
6177
6178   if (tname)
6179     {
6180       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6181       set_identifier_type_value (tname, NULL_TREE);
6182       if ((int) rid_index < (int) RID_MAX)
6183         /* Built-in types live in the global namespace. */
6184         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6185     }
6186   if (rname != NULL_TREE)
6187     {
6188       if (tname != NULL_TREE)
6189         {
6190           set_identifier_type_value (rname, NULL_TREE);
6191           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6192         }
6193       else
6194         {
6195           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6196           set_identifier_type_value (rname, NULL_TREE);
6197         }
6198     }
6199 }
6200
6201 /* Record one of the standard Java types.
6202  * Declare it as having the given NAME.
6203  * If SIZE > 0, it is the size of one of the integral types;
6204  * otherwise it is the negative of the size of one of the other types.  */
6205
6206 static tree
6207 record_builtin_java_type (name, size)
6208      const char *name;
6209      int size;
6210 {
6211   tree type, decl;
6212   if (size > 0)
6213     type = make_signed_type (size);
6214   else if (size > -32)
6215     { /* "__java_char" or ""__java_boolean". */
6216       type = make_unsigned_type (-size);
6217       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6218     }
6219   else
6220     { /* "__java_float" or ""__java_double". */
6221       type = make_node (REAL_TYPE);
6222       TYPE_PRECISION (type) = - size;
6223       layout_type (type);
6224     }
6225   record_builtin_type (RID_MAX, name, type);
6226   decl = TYPE_NAME (type);
6227
6228   /* Suppress generate debug symbol entries for these types,
6229      since for normal C++ they are just clutter.
6230      However, push_lang_context undoes this if extern "Java" is seen. */
6231   DECL_IGNORED_P (decl) = 1;
6232
6233   TYPE_FOR_JAVA (type) = 1;
6234   return type;
6235 }
6236
6237 /* Push a type into the namespace so that the back-ends ignore it. */
6238
6239 static void
6240 record_unknown_type (type, name)
6241      tree type;
6242      const char *name;
6243 {
6244   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6245   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6246   DECL_IGNORED_P (decl) = 1;
6247   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6248   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6249   TYPE_ALIGN (type) = 1;
6250   TYPE_USER_ALIGN (type) = 0;
6251   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6252 }
6253
6254 /* An string for which we should create an IDENTIFIER_NODE at
6255    startup.  */
6256
6257 typedef struct predefined_identifier
6258 {
6259   /* The name of the identifier.  */
6260   const char *name;
6261   /* The place where the IDENTIFIER_NODE should be stored.  */
6262   tree *node;
6263   /* Non-zero if this is the name of a constructor or destructor.  */
6264   int ctor_or_dtor_p;
6265 } predefined_identifier;
6266
6267 /* Create all the predefined identifiers.  */
6268
6269 static void
6270 initialize_predefined_identifiers ()
6271 {
6272   struct predefined_identifier *pid;
6273
6274   /* A table of identifiers to create at startup.  */
6275   static predefined_identifier predefined_identifiers[] = {
6276     { "C++", &lang_name_cplusplus, 0 },
6277     { "C", &lang_name_c, 0 },
6278     { "Java", &lang_name_java, 0 },
6279     { CTOR_NAME, &ctor_identifier, 1 },
6280     { "__base_ctor", &base_ctor_identifier, 1 },
6281     { "__comp_ctor", &complete_ctor_identifier, 1 },
6282     { DTOR_NAME, &dtor_identifier, 1 },
6283     { "__comp_dtor", &complete_dtor_identifier, 1 },
6284     { "__base_dtor", &base_dtor_identifier, 1 },
6285     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6286     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6287     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6288     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6289     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6290     { "nelts", &nelts_identifier, 0 },
6291     { THIS_NAME, &this_identifier, 0 },
6292     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6293     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6294     { "_vptr", &vptr_identifier, 0 },
6295     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6296     { "__vtt_parm", &vtt_parm_identifier, 0 },
6297     { "std", &std_identifier, 0 },
6298     { NULL, NULL, 0 }
6299   };
6300
6301   for (pid = predefined_identifiers; pid->name; ++pid)
6302     {
6303       *pid->node = get_identifier (pid->name);
6304       if (pid->ctor_or_dtor_p)
6305         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6306     }
6307 }
6308
6309 /* Create the predefined scalar types of C,
6310    and some nodes representing standard constants (0, 1, (void *)0).
6311    Initialize the global binding level.
6312    Make definitions for built-in primitive functions.  */
6313
6314 void
6315 init_decl_processing ()
6316 {
6317   tree fields[20];
6318   int wchar_type_size;
6319   tree array_domain_type;
6320
6321   /* Check to see that the user did not specify an invalid combination
6322      of command-line options.  */
6323   if (flag_new_abi && !flag_vtable_thunks)
6324     fatal ("the new ABI requires vtable thunks");
6325
6326   /* Create all the identifiers we need.  */
6327   initialize_predefined_identifiers ();
6328
6329   /* Fill in back-end hooks.  */
6330   init_lang_status = &push_cp_function_context;
6331   free_lang_status = &pop_cp_function_context;
6332   mark_lang_status = &mark_cp_function_context;
6333   lang_safe_from_p = &c_safe_from_p;
6334   lang_dump_tree = &cp_dump_tree;
6335
6336   cp_parse_init ();
6337   init_decl2 ();
6338   init_pt ();
6339
6340   /* Create the global variables.  */
6341   push_to_top_level ();
6342
6343   /* Enter the global namespace. */
6344   my_friendly_assert (global_namespace == NULL_TREE, 375);
6345   push_namespace (get_identifier ("::"));
6346   global_namespace = current_namespace;
6347   current_lang_name = NULL_TREE;
6348
6349   /* Adjust various flags based on command-line settings.  */
6350   if (! flag_permissive && ! pedantic)
6351     flag_pedantic_errors = 1;
6352   if (!flag_no_inline)
6353     flag_inline_trees = 1;
6354
6355   /* Initially, C.  */
6356   current_lang_name = lang_name_c;
6357
6358   current_function_decl = NULL_TREE;
6359   current_binding_level = NULL_BINDING_LEVEL;
6360   free_binding_level = NULL_BINDING_LEVEL;
6361
6362   build_common_tree_nodes (flag_signed_char);
6363
6364   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6365   TREE_TYPE (error_mark_list) = error_mark_node;
6366
6367   /* Make the binding_level structure for global names.  */
6368   pushlevel (0);
6369   global_binding_level = current_binding_level;
6370   /* The global level is the namespace level of ::.  */
6371   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6372   declare_namespace_level ();
6373
6374   /* Create the `std' namespace.  */
6375   if (flag_honor_std)
6376     {
6377       push_namespace (std_identifier);
6378       std_node = current_namespace;
6379       pop_namespace ();
6380       fake_std_node = error_mark_node;
6381     }
6382   else
6383     {
6384       fake_std_node = build_decl (NAMESPACE_DECL,
6385                                   std_identifier,
6386                                   void_type_node);
6387       pushdecl (fake_std_node);
6388     }
6389
6390   /* Define `int' and `char' first so that dbx will output them first.  */
6391   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6392   record_builtin_type (RID_CHAR, "char", char_type_node);
6393
6394   /* `signed' is the same as `int' */
6395   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6396   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6397   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6398   record_builtin_type (RID_MAX, "long unsigned int",
6399                        long_unsigned_type_node);
6400   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6401   record_builtin_type (RID_MAX, "long long int",
6402                        long_long_integer_type_node);
6403   record_builtin_type (RID_MAX, "long long unsigned int",
6404                        long_long_unsigned_type_node);
6405   record_builtin_type (RID_MAX, "long long unsigned",
6406                        long_long_unsigned_type_node);
6407   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6408   record_builtin_type (RID_MAX, "short unsigned int",
6409                        short_unsigned_type_node);
6410   record_builtin_type (RID_MAX, "unsigned short",
6411                        short_unsigned_type_node);
6412
6413   ptrdiff_type_node
6414     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6415   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
6416
6417   /* Define both `signed char' and `unsigned char'.  */
6418   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6419   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6420
6421   /* `unsigned long' is the standard type for sizeof.
6422      Note that stddef.h uses `unsigned long',
6423      and this must agree, even if long and int are the same size.  */
6424   c_size_type_node =
6425     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
6426   signed_size_type_node = signed_type (c_size_type_node);
6427   set_sizetype (c_size_type_node);
6428
6429   /* Create the widest literal types. */
6430   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6431   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6432                         widest_integer_literal_type_node));
6433
6434   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6435   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6436                         widest_unsigned_literal_type_node));
6437
6438   /* These are types that type_for_size and type_for_mode use.  */
6439   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6440   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6441   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6442   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6443 #if HOST_BITS_PER_WIDE_INT >= 64
6444   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6445 #endif
6446   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6447   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6448   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6449   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6450 #if HOST_BITS_PER_WIDE_INT >= 64
6451   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6452 #endif
6453
6454   build_common_tree_nodes_2 (flag_short_double);
6455
6456   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6457   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6458   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6459   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6460   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6461   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6462   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6463   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6464
6465   integer_two_node = build_int_2 (2, 0);
6466   TREE_TYPE (integer_two_node) = integer_type_node;
6467   integer_three_node = build_int_2 (3, 0);
6468   TREE_TYPE (integer_three_node) = integer_type_node;
6469
6470   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6471   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6472   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6473   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6474   TYPE_PRECISION (boolean_type_node) = 1;
6475   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6476   boolean_false_node = build_int_2 (0, 0);
6477   TREE_TYPE (boolean_false_node) = boolean_type_node;
6478   boolean_true_node = build_int_2 (1, 0);
6479   TREE_TYPE (boolean_true_node) = boolean_type_node;
6480
6481   signed_size_zero_node = build_int_2 (0, 0);
6482   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6483   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6484   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6485
6486   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6487                         complex_integer_type_node));
6488   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6489                         complex_float_type_node));
6490   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6491                         complex_double_type_node));
6492   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6493                         complex_long_double_type_node));
6494
6495   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6496
6497   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6498   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6499   TREE_PARMLIST (void_list_node) = 1;
6500
6501   string_type_node = build_pointer_type (char_type_node);
6502   const_string_type_node
6503     = build_pointer_type (build_qualified_type (char_type_node,
6504                                                 TYPE_QUAL_CONST));
6505   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6506 #if 0
6507   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6508 #endif
6509
6510   /* Make a type to be the domain of a few array types
6511      whose domains don't really matter.
6512      200 is small enough that it always fits in size_t.  */
6513   array_domain_type = build_index_type (build_int_2 (200, 0));
6514
6515   /* Make a type for arrays of characters.
6516      With luck nothing will ever really depend on the length of this
6517      array type.  */
6518   char_array_type_node
6519     = build_array_type (char_type_node, array_domain_type);
6520
6521   /* Likewise for arrays of ints.  */
6522   int_array_type_node
6523     = build_array_type (integer_type_node, array_domain_type);
6524
6525   if (flag_new_abi)
6526     delta_type_node = ptrdiff_type_node;
6527   else if (flag_huge_objects)
6528     delta_type_node = long_integer_type_node;
6529   else
6530     delta_type_node = short_integer_type_node;
6531
6532   if (flag_new_abi)
6533     vtable_index_type = ptrdiff_type_node;
6534   else
6535     vtable_index_type = delta_type_node;
6536
6537   default_function_type
6538     = build_function_type (integer_type_node, NULL_TREE);
6539
6540   ptr_type_node = build_pointer_type (void_type_node);
6541   const_ptr_type_node
6542     = build_pointer_type (build_qualified_type (void_type_node,
6543                                                 TYPE_QUAL_CONST));
6544   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6545   c_common_nodes_and_builtins ();
6546   lang_type_promotes_to = convert_type_from_ellipsis;
6547
6548   void_ftype_ptr
6549     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6550
6551 #ifdef MD_INIT_BUILTINS
6552   MD_INIT_BUILTINS;
6553 #endif
6554
6555   /* C++ extensions */
6556
6557   unknown_type_node = make_node (UNKNOWN_TYPE);
6558   record_unknown_type (unknown_type_node, "unknown type");
6559
6560   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6561   TREE_TYPE (unknown_type_node) = unknown_type_node;
6562
6563   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6564
6565   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6566      result.  */
6567   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6568   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6569
6570   /* This is special for C++ so functions can be overloaded.  */
6571   wchar_type_node = get_identifier (flag_short_wchar
6572                                     ? "short unsigned int"
6573                                     : WCHAR_TYPE);
6574   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6575   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6576   if (TREE_UNSIGNED (wchar_type_node))
6577     wchar_type_node = make_signed_type (wchar_type_size);
6578   else
6579     wchar_type_node = make_unsigned_type (wchar_type_size);
6580   record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
6581
6582   /* This is for wide string constants.  */
6583   wchar_array_type_node
6584     = build_array_type (wchar_type_node, array_domain_type);
6585
6586   wint_type_node =
6587     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WINT_TYPE)));
6588
6589   intmax_type_node =
6590     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE)));
6591   uintmax_type_node =
6592     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE)));
6593
6594   if (flag_vtable_thunks)
6595     {
6596       /* Make sure we get a unique function type, so we can give
6597          its pointer type a name.  (This wins for gdb.) */
6598       tree vfunc_type = make_node (FUNCTION_TYPE);
6599       TREE_TYPE (vfunc_type) = integer_type_node;
6600       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6601       layout_type (vfunc_type);
6602
6603       vtable_entry_type = build_pointer_type (vfunc_type);
6604     }
6605   else
6606     {
6607       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6608       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6609                               delta_type_node);
6610       fields[1] = build_decl (FIELD_DECL, index_identifier,
6611                               delta_type_node);
6612       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6613                               ptr_type_node);
6614       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6615                            double_type_node);
6616
6617       /* Make this part of an invisible union.  */
6618       fields[3] = copy_node (fields[2]);
6619       TREE_TYPE (fields[3]) = delta_type_node;
6620       DECL_NAME (fields[3]) = delta2_identifier;
6621       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6622       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6623       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6624       TREE_UNSIGNED (fields[3]) = 0;
6625       TREE_CHAIN (fields[2]) = fields[3];
6626       vtable_entry_type = build_qualified_type (vtable_entry_type,
6627                                                 TYPE_QUAL_CONST);
6628     }
6629   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6630
6631   vtbl_type_node
6632     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6633   layout_type (vtbl_type_node);
6634   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6635   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6636   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6637   layout_type (vtbl_ptr_type_node);
6638   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6639
6640   if (flag_new_abi)
6641     {
6642       push_namespace (get_identifier ("__cxxabiv1"));
6643       abi_node = current_namespace;
6644       pop_namespace ();
6645     }
6646
6647   global_type_node = make_node (LANG_TYPE);
6648   record_unknown_type (global_type_node, "global type");
6649
6650   /* Now, C++.  */
6651   current_lang_name = lang_name_cplusplus;
6652
6653   {
6654     tree bad_alloc_type_node, newtype, deltype;
6655     if (flag_honor_std)
6656       push_namespace (std_identifier);
6657     bad_alloc_type_node = xref_tag
6658       (class_type_node, get_identifier ("bad_alloc"), 1);
6659     if (flag_honor_std)
6660       pop_namespace ();
6661     newtype = build_exception_variant
6662       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6663     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6664     push_cp_library_fn (NEW_EXPR, newtype);
6665     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6666     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6667     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6668   }
6669
6670   abort_fndecl
6671     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6672
6673   /* Perform other language dependent initializations.  */
6674   init_class_processing ();
6675   init_init_processing ();
6676   init_search_processing ();
6677   init_rtti_processing ();
6678
6679   if (flag_exceptions)
6680     init_exception_processing ();
6681   if (flag_no_inline)
6682     {
6683       flag_inline_functions = 0;
6684     }
6685
6686   if (! supports_one_only ())
6687     flag_weak = 0;
6688
6689   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6690   function_id_node = get_identifier ("__FUNCTION__");
6691   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6692   func_id_node = get_identifier ("__func__");
6693
6694   make_fname_decl = cp_make_fname_decl;
6695   declare_function_name ();
6696
6697   /* Prepare to check format strings against argument lists.  */
6698   init_function_format_info ();
6699
6700   /* Show we use EH for cleanups.  */
6701   using_eh_for_cleanups ();
6702
6703   valid_lang_attribute = cp_valid_lang_attribute;
6704
6705   /* Maintain consistency.  Perhaps we should just complain if they
6706      say -fwritable-strings?  */
6707   if (flag_writable_strings)
6708     flag_const_strings = 0;
6709
6710   /* Add GC roots for all of our global variables.  */
6711   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6712   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6713   ggc_add_tree_root (&integer_three_node, 1);
6714   ggc_add_tree_root (&integer_two_node, 1);
6715   ggc_add_tree_root (&signed_size_zero_node, 1);
6716   ggc_add_tree_root (&size_one_node, 1);
6717   ggc_add_tree_root (&size_zero_node, 1);
6718   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6719                 mark_binding_level);
6720   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6721   ggc_add_tree_root (&static_ctors, 1);
6722   ggc_add_tree_root (&static_dtors, 1);
6723   ggc_add_tree_root (&lastiddecl, 1);
6724
6725   ggc_add_tree_root (&last_function_parm_tags, 1);
6726   ggc_add_tree_root (&current_function_return_value, 1);
6727   ggc_add_tree_root (&current_function_parm_tags, 1);
6728   ggc_add_tree_root (&last_function_parms, 1);
6729   ggc_add_tree_root (&error_mark_list, 1);
6730
6731   ggc_add_tree_root (&global_namespace, 1);
6732   ggc_add_tree_root (&global_type_node, 1);
6733   ggc_add_tree_root (&anonymous_namespace_name, 1);
6734
6735   ggc_add_tree_root (&got_object, 1);
6736   ggc_add_tree_root (&got_scope, 1);
6737
6738   ggc_add_tree_root (&current_lang_name, 1);
6739   ggc_add_tree_root (&static_aggregates, 1);
6740 }
6741
6742 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6743    decl, NAME is the initialization string and TYPE_DEP indicates whether
6744    NAME depended on the type of the function. We make use of that to detect
6745    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6746    the function before emitting any of it, we don't need to treat the
6747    VAR_DECL specially. We can decide whether to emit it later, if it was
6748    used.  */
6749
6750 static tree
6751 cp_make_fname_decl (id, name, type_dep)
6752      tree id;
6753      const char *name;
6754      int type_dep;
6755 {
6756   tree decl, type, init;
6757   size_t length = strlen (name);
6758   tree domain = NULL_TREE;
6759
6760   if (!processing_template_decl)
6761     type_dep = 0;
6762   if (!type_dep)
6763     domain = build_index_type (build_int_2 (length, 0));
6764
6765   type =  build_cplus_array_type
6766           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6767            domain);
6768
6769   decl = build_decl (VAR_DECL, id, type);
6770   TREE_STATIC (decl) = 1;
6771   TREE_READONLY (decl) = 1;
6772   DECL_SOURCE_LINE (decl) = 0;
6773   DECL_ARTIFICIAL (decl) = 1;
6774   DECL_IN_SYSTEM_HEADER (decl) = 1;
6775   pushdecl (decl);
6776   if (processing_template_decl)
6777     decl = push_template_decl (decl);
6778   if (type_dep)
6779     {
6780       init = build (FUNCTION_NAME, type);
6781       DECL_PRETTY_FUNCTION_P (decl) = 1;
6782     }
6783   else
6784     {
6785       init = build_string (length + 1, name);
6786       TREE_TYPE (init) = type;
6787     }
6788   DECL_INITIAL (decl) = init;
6789   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6790
6791   /* We will have to make sure we only emit this, if it is actually used. */
6792   return decl;
6793 }
6794
6795 /* Entry point for the benefit of c_common_nodes_and_builtins.
6796
6797    Make a definition for a builtin function named NAME and whose data type
6798    is TYPE.  TYPE should be a function type with argument types.
6799
6800    CLASS and CODE tell later passes how to compile calls to this function.
6801    See tree.h for possible values.
6802
6803    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6804    the name to be called if we can't opencode the function.  */
6805
6806 tree
6807 builtin_function (name, type, code, class, libname)
6808      const char *name;
6809      tree type;
6810      int code;
6811      enum built_in_class class;
6812      const char *libname;
6813 {
6814   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6815   DECL_BUILT_IN_CLASS (decl) = class;
6816   DECL_FUNCTION_CODE (decl) = code;
6817
6818   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6819
6820   /* All builtins that don't begin with an `_' should go in the `std'
6821      namespace.  */
6822   if (flag_honor_std && name[0] != '_')
6823     {
6824       push_namespace (std_identifier);
6825       DECL_CONTEXT (decl) = std_node;
6826     }
6827   pushdecl (decl);
6828   if (flag_honor_std && name[0] != '_')
6829     pop_namespace ();
6830
6831   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6832      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6833      function in the namespace.  */
6834   if (libname)
6835     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6836   make_function_rtl (decl);
6837
6838   /* Warn if a function in the namespace for users
6839      is used without an occasion to consider it declared.  */
6840   if (name[0] != '_' || name[1] != '_')
6841     DECL_ANTICIPATED (decl) = 1;
6842
6843   return decl;
6844 }
6845
6846 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6847    function.  Not called directly.  */
6848
6849 static tree
6850 build_library_fn_1 (name, operator_code, type)
6851      tree name;
6852      enum tree_code operator_code;
6853      tree type;
6854 {
6855   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6856   DECL_EXTERNAL (fn) = 1;
6857   TREE_PUBLIC (fn) = 1;
6858   DECL_ARTIFICIAL (fn) = 1;
6859   TREE_NOTHROW (fn) = 1;
6860   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6861   return fn;
6862 }
6863
6864 /* Returns the _DECL for a library function with C linkage.
6865    We assume that such functions never throw; if this is incorrect,
6866    callers should unset TREE_NOTHROW.  */
6867
6868 tree
6869 build_library_fn (name, type)
6870      tree name;
6871      tree type;
6872 {
6873   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6874   make_function_rtl (fn);
6875   return fn;
6876 }
6877
6878 /* Returns the _DECL for a library function with C++ linkage.  */
6879
6880 static tree
6881 build_cp_library_fn (name, operator_code, type)
6882      tree name;
6883      enum tree_code operator_code;
6884      tree type;
6885 {
6886   tree fn = build_library_fn_1 (name, operator_code, type);
6887   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6888   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6889   set_mangled_name_for_decl (fn);
6890   make_function_rtl (fn);
6891   return fn;
6892 }
6893
6894 /* Like build_library_fn, but takes a C string instead of an
6895    IDENTIFIER_NODE.  */
6896
6897 tree
6898 build_library_fn_ptr (name, type)
6899      const char *name;
6900      tree type;
6901 {
6902   return build_library_fn (get_identifier (name), type);
6903 }
6904
6905 /* Like build_cp_library_fn, but takes a C string instead of an
6906    IDENTIFIER_NODE.  */
6907
6908 tree
6909 build_cp_library_fn_ptr (name, type)
6910      const char *name;
6911      tree type;
6912 {
6913   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6914 }
6915
6916 /* Like build_library_fn, but also pushes the function so that we will
6917    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6918
6919 tree
6920 push_library_fn (name, type)
6921      tree name, type;
6922 {
6923   tree fn = build_library_fn (name, type);
6924   pushdecl_top_level (fn);
6925   return fn;
6926 }
6927
6928 /* Like build_cp_library_fn, but also pushes the function so that it
6929    will be found by normal lookup.  */
6930
6931 static tree
6932 push_cp_library_fn (operator_code, type)
6933      enum tree_code operator_code;
6934      tree type;
6935 {
6936   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6937                                  operator_code,
6938                                  type);
6939   pushdecl (fn);
6940   return fn;
6941 }
6942
6943 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6944    a FUNCTION_TYPE.  */
6945
6946 tree
6947 push_void_library_fn (name, parmtypes)
6948      tree name, parmtypes;
6949 {
6950   tree type = build_function_type (void_type_node, parmtypes);
6951   return push_library_fn (name, type);
6952 }
6953
6954 /* Like push_library_fn, but also note that this function throws
6955    and does not return.  Used for __throw_foo and the like.  */
6956
6957 tree
6958 push_throw_library_fn (name, type)
6959      tree name, type;
6960 {
6961   tree fn = push_library_fn (name, type);
6962   TREE_THIS_VOLATILE (fn) = 1;
6963   TREE_NOTHROW (fn) = 0;
6964   return fn;
6965 }
6966 \f
6967 /* When we call finish_struct for an anonymous union, we create
6968    default copy constructors and such.  But, an anonymous union
6969    shouldn't have such things; this function undoes the damage to the
6970    anonymous union type T.
6971
6972    (The reason that we create the synthesized methods is that we don't
6973    distinguish `union { int i; }' from `typedef union { int i; } U'.
6974    The first is an anonymous union; the second is just an ordinary
6975    union type.)  */
6976
6977 void
6978 fixup_anonymous_aggr (t)
6979      tree t;
6980 {
6981   tree *q;
6982
6983   /* Wipe out memory of synthesized methods */
6984   TYPE_HAS_CONSTRUCTOR (t) = 0;
6985   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6986   TYPE_HAS_INIT_REF (t) = 0;
6987   TYPE_HAS_CONST_INIT_REF (t) = 0;
6988   TYPE_HAS_ASSIGN_REF (t) = 0;
6989   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6990
6991   /* Splice the implicitly generated functions out of the TYPE_METHODS
6992      list.  */
6993   q = &TYPE_METHODS (t);
6994   while (*q)
6995     {
6996       if (DECL_ARTIFICIAL (*q))
6997         *q = TREE_CHAIN (*q);
6998       else
6999         q = &TREE_CHAIN (*q);
7000     }
7001
7002   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7003   if (TYPE_METHODS (t))
7004     error ("an anonymous union cannot have function members");
7005 }
7006
7007 /* Make sure that a declaration with no declarator is well-formed, i.e.
7008    just defines a tagged type or anonymous union.
7009
7010    Returns the type defined, if any.  */
7011
7012 tree
7013 check_tag_decl (declspecs)
7014      tree declspecs;
7015 {
7016   int found_type = 0;
7017   int saw_friend = 0;
7018   tree ob_modifier = NULL_TREE;
7019   register tree link;
7020   register tree t = NULL_TREE;
7021
7022   for (link = declspecs; link; link = TREE_CHAIN (link))
7023     {
7024       register tree value = TREE_VALUE (link);
7025
7026       if (TYPE_P (value)
7027           || (TREE_CODE (value) == IDENTIFIER_NODE
7028               && IDENTIFIER_GLOBAL_VALUE (value)
7029               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7030         {
7031           ++found_type;
7032
7033           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7034               || TREE_CODE (value) == ENUMERAL_TYPE)
7035             {
7036               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7037               t = value;
7038             }
7039         }
7040       else if (value == ridpointers[(int) RID_FRIEND])
7041         {
7042           if (current_class_type == NULL_TREE
7043               || current_scope () != current_class_type)
7044             ob_modifier = value;
7045           else
7046             saw_friend = 1;
7047         }
7048       else if (value == ridpointers[(int) RID_STATIC]
7049                || value == ridpointers[(int) RID_EXTERN]
7050                || value == ridpointers[(int) RID_AUTO]
7051                || value == ridpointers[(int) RID_REGISTER]
7052                || value == ridpointers[(int) RID_INLINE]
7053                || value == ridpointers[(int) RID_VIRTUAL]
7054                || value == ridpointers[(int) RID_CONST]
7055                || value == ridpointers[(int) RID_VOLATILE]
7056                || value == ridpointers[(int) RID_EXPLICIT])
7057         ob_modifier = value;
7058     }
7059
7060   if (found_type > 1)
7061     error ("multiple types in one declaration");
7062
7063   if (t == NULL_TREE && ! saw_friend)
7064     pedwarn ("declaration does not declare anything");
7065
7066   /* Check for an anonymous union.  We're careful
7067      accessing TYPE_IDENTIFIER because some built-in types, like
7068      pointer-to-member types, do not have TYPE_NAME.  */
7069   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7070            && TYPE_NAME (t)
7071            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7072     {
7073       /* Anonymous unions are objects, so they can have specifiers.  */;
7074       SET_ANON_AGGR_TYPE_P (t);
7075
7076       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7077         pedwarn ("ISO C++ prohibits anonymous structs");
7078     }
7079
7080   else if (ob_modifier)
7081     {
7082       if (ob_modifier == ridpointers[(int) RID_INLINE]
7083           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7084         cp_error ("`%D' can only be specified for functions", ob_modifier);
7085       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7086         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7087       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7088         cp_error ("`%D' can only be specified for constructors",
7089                   ob_modifier);
7090       else
7091         cp_error ("`%D' can only be specified for objects and functions",
7092                   ob_modifier);
7093     }
7094
7095   return t;
7096 }
7097
7098 /* Called when a declaration is seen that contains no names to declare.
7099    If its type is a reference to a structure, union or enum inherited
7100    from a containing scope, shadow that tag name for the current scope
7101    with a forward reference.
7102    If its type defines a new named structure or union
7103    or defines an enum, it is valid but we need not do anything here.
7104    Otherwise, it is an error.
7105
7106    C++: may have to grok the declspecs to learn about static,
7107    complain for anonymous unions.  */
7108
7109 void
7110 shadow_tag (declspecs)
7111      tree declspecs;
7112 {
7113   tree t = check_tag_decl (declspecs);
7114
7115   if (t)
7116     maybe_process_partial_specialization (t);
7117
7118   /* This is where the variables in an anonymous union are
7119      declared.  An anonymous union declaration looks like:
7120      union { ... } ;
7121      because there is no declarator after the union, the parser
7122      sends that declaration here.  */
7123   if (t && ANON_AGGR_TYPE_P (t))
7124     {
7125       fixup_anonymous_aggr (t);
7126
7127       if (TYPE_FIELDS (t))
7128         {
7129           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7130                                       NULL_TREE);
7131           finish_anon_union (decl);
7132         }
7133     }
7134 }
7135 \f
7136 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7137
7138 tree
7139 groktypename (typename)
7140      tree typename;
7141 {
7142   if (TREE_CODE (typename) != TREE_LIST)
7143     return typename;
7144   return grokdeclarator (TREE_VALUE (typename),
7145                          TREE_PURPOSE (typename),
7146                          TYPENAME, 0, NULL_TREE);
7147 }
7148
7149 /* Decode a declarator in an ordinary declaration or data definition.
7150    This is called as soon as the type information and variable name
7151    have been parsed, before parsing the initializer if any.
7152    Here we create the ..._DECL node, fill in its type,
7153    and put it on the list of decls for the current context.
7154    The ..._DECL node is returned as the value.
7155
7156    Exception: for arrays where the length is not specified,
7157    the type is left null, to be filled in by `cp_finish_decl'.
7158
7159    Function definitions do not come here; they go to start_function
7160    instead.  However, external and forward declarations of functions
7161    do go through here.  Structure field declarations are done by
7162    grokfield and not through here.  */
7163
7164 tree
7165 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7166      tree declarator, declspecs;
7167      int initialized;
7168      tree attributes, prefix_attributes;
7169 {
7170   register tree decl;
7171   register tree type, tem;
7172   tree context;
7173   extern int have_extern_spec;
7174   extern int used_extern_spec;
7175   tree attrlist;
7176
7177 #if 0
7178   /* See code below that used this.  */
7179   int init_written = initialized;
7180 #endif
7181
7182   /* This should only be done once on the top most decl.  */
7183   if (have_extern_spec && !used_extern_spec)
7184     {
7185       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7186                              declspecs);
7187       used_extern_spec = 1;
7188     }
7189
7190   if (attributes || prefix_attributes)
7191     attrlist = build_tree_list (attributes, prefix_attributes);
7192   else
7193     attrlist = NULL_TREE;
7194
7195   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7196                          attrlist);
7197
7198   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7199     return NULL_TREE;
7200
7201   type = TREE_TYPE (decl);
7202
7203   if (type == error_mark_node)
7204     return NULL_TREE;
7205
7206   context = DECL_CONTEXT (decl);
7207
7208   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7209       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7210     {
7211       /* When parsing the initializer, lookup should use the object's
7212          namespace. */
7213       push_decl_namespace (context);
7214     }
7215
7216   /* We are only interested in class contexts, later. */
7217   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7218     context = NULL_TREE;
7219
7220   if (initialized)
7221     /* Is it valid for this decl to have an initializer at all?
7222        If not, set INITIALIZED to zero, which will indirectly
7223        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7224     switch (TREE_CODE (decl))
7225       {
7226       case TYPE_DECL:
7227         /* typedef foo = bar  means give foo the same type as bar.
7228            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7229            Any other case of an initialization in a TYPE_DECL is an error.  */
7230         if (pedantic || list_length (declspecs) > 1)
7231           {
7232             cp_error ("typedef `%D' is initialized", decl);
7233             initialized = 0;
7234           }
7235         break;
7236
7237       case FUNCTION_DECL:
7238         cp_error ("function `%#D' is initialized like a variable", decl);
7239         initialized = 0;
7240         break;
7241
7242       default:
7243         break;
7244       }
7245
7246   if (initialized)
7247     {
7248       if (! toplevel_bindings_p ()
7249           && DECL_EXTERNAL (decl))
7250         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7251                     decl);
7252       DECL_EXTERNAL (decl) = 0;
7253       if (toplevel_bindings_p ())
7254         TREE_STATIC (decl) = 1;
7255
7256       /* Tell `pushdecl' this is an initialized decl
7257          even though we don't yet have the initializer expression.
7258          Also tell `cp_finish_decl' it may store the real initializer.  */
7259       DECL_INITIAL (decl) = error_mark_node;
7260     }
7261
7262 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7263   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7264 #endif
7265
7266   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7267   cplus_decl_attributes (decl, attributes, prefix_attributes);
7268
7269   if (context && COMPLETE_TYPE_P (complete_type (context)))
7270     {
7271       push_nested_class (context, 2);
7272
7273       if (TREE_CODE (decl) == VAR_DECL)
7274         {
7275           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7276           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7277             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7278           else
7279             {
7280               if (DECL_CONTEXT (field) != context)
7281                 {
7282                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7283                               DECL_CONTEXT (field), DECL_NAME (decl),
7284                               context, DECL_NAME (decl));
7285                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7286                 }
7287               /* Static data member are tricky; an in-class initialization
7288                  still doesn't provide a definition, so the in-class
7289                  declaration will have DECL_EXTERNAL set, but will have an
7290                  initialization.  Thus, duplicate_decls won't warn
7291                  about this situation, and so we check here.  */
7292               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7293                 cp_error ("duplicate initialization of %D", decl);
7294               if (duplicate_decls (decl, field))
7295                 decl = field;
7296             }
7297         }
7298       else
7299         {
7300           tree field = check_classfn (context, decl);
7301           if (field && duplicate_decls (decl, field))
7302             decl = field;
7303         }
7304
7305       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7306       DECL_IN_AGGR_P (decl) = 0;
7307       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7308           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7309         {
7310           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7311           /* [temp.expl.spec] An explicit specialization of a static data
7312              member of a template is a definition if the declaration
7313              includes an initializer; otherwise, it is a declaration.
7314
7315              We check for processing_specialization so this only applies
7316              to the new specialization syntax.  */
7317           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7318             DECL_EXTERNAL (decl) = 1;
7319         }
7320
7321       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7322         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7323                     decl);
7324     }
7325
7326   /* Enter this declaration into the symbol table.  */
7327   tem = maybe_push_decl (decl);
7328
7329   if (processing_template_decl)
7330     tem = push_template_decl (tem);
7331
7332 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7333   /* Tell the back-end to use or not use .common as appropriate.  If we say
7334      -fconserve-space, we want this to save .data space, at the expense of
7335      wrong semantics.  If we say -fno-conserve-space, we want this to
7336      produce errors about redefs; to do this we force variables into the
7337      data segment.  */
7338   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7339 #endif
7340
7341   if (! processing_template_decl)
7342     start_decl_1 (tem);
7343
7344   return tem;
7345 }
7346
7347 void
7348 start_decl_1 (decl)
7349      tree decl;
7350 {
7351   tree type = TREE_TYPE (decl);
7352   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7353
7354   if (type == error_mark_node)
7355     return;
7356
7357   /* If this type of object needs a cleanup, but we're not allowed to
7358      add any more objects with cleanups to the current scope, create a
7359      new binding level.  */
7360   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7361       && current_binding_level->more_cleanups_ok == 0)
7362     {
7363       keep_next_level (2);
7364       pushlevel (1);
7365       clear_last_expr ();
7366       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7367     }
7368
7369   if (initialized)
7370     /* Is it valid for this decl to have an initializer at all?
7371        If not, set INITIALIZED to zero, which will indirectly
7372        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7373     {
7374       /* Don't allow initializations for incomplete types except for
7375          arrays which might be completed by the initialization.  */
7376       if (COMPLETE_TYPE_P (complete_type (type)))
7377         ;                       /* A complete type is ok.  */
7378       else if (TREE_CODE (type) != ARRAY_TYPE)
7379         {
7380           cp_error ("variable `%#D' has initializer but incomplete type",
7381                     decl);
7382           initialized = 0;
7383           type = TREE_TYPE (decl) = error_mark_node;
7384         }
7385       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7386         {
7387           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7388             cp_error ("elements of array `%#D' have incomplete type", decl);
7389           /* else we already gave an error in start_decl.  */
7390           initialized = 0;
7391         }
7392     }
7393
7394   if (!initialized
7395       && TREE_CODE (decl) != TYPE_DECL
7396       && TREE_CODE (decl) != TEMPLATE_DECL
7397       && type != error_mark_node
7398       && IS_AGGR_TYPE (type)
7399       && ! DECL_EXTERNAL (decl))
7400     {
7401       if ((! processing_template_decl || ! uses_template_parms (type))
7402           && !COMPLETE_TYPE_P (complete_type (type)))
7403         {
7404           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7405                  decl);
7406           /* Change the type so that assemble_variable will give
7407              DECL an rtl we can live with: (mem (const_int 0)).  */
7408           type = TREE_TYPE (decl) = error_mark_node;
7409         }
7410       else
7411         {
7412           /* If any base type in the hierarchy of TYPE needs a constructor,
7413              then we set initialized to 1.  This way any nodes which are
7414              created for the purposes of initializing this aggregate
7415              will live as long as it does.  This is necessary for global
7416              aggregates which do not have their initializers processed until
7417              the end of the file.  */
7418           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7419         }
7420     }
7421
7422   if (! initialized)
7423     DECL_INITIAL (decl) = NULL_TREE;
7424 }
7425
7426 /* Handle initialization of references.
7427    These three arguments are from `cp_finish_decl', and have the
7428    same meaning here that they do there.
7429
7430    Quotes on semantics can be found in ARM 8.4.3.  */
7431
7432 static void
7433 grok_reference_init (decl, type, init)
7434      tree decl, type, init;
7435 {
7436   tree tmp;
7437
7438   if (init == NULL_TREE)
7439     {
7440       if ((DECL_LANG_SPECIFIC (decl) == 0
7441            || DECL_IN_AGGR_P (decl) == 0)
7442           && ! DECL_THIS_EXTERN (decl))
7443         cp_error ("`%D' declared as reference but not initialized", decl);
7444       return;
7445     }
7446
7447   if (init == error_mark_node)
7448     return;
7449
7450   if (TREE_CODE (init) == CONSTRUCTOR)
7451     {
7452       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7453       return;
7454     }
7455
7456   if (TREE_CODE (init) == TREE_LIST)
7457     init = build_compound_expr (init);
7458
7459   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7460     init = convert_from_reference (init);
7461
7462   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7463       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7464     {
7465       /* Note: default conversion is only called in very special cases.  */
7466       init = default_conversion (init);
7467     }
7468
7469   /* Convert INIT to the reference type TYPE.  This may involve the
7470      creation of a temporary, whose lifetime must be the same as that
7471      of the reference.  If so, a DECL_STMT for the temporary will be
7472      added just after the DECL_STMT for DECL.  That's why we don't set
7473      DECL_INITIAL for local references (instead assigning to them
7474      explicitly); we need to allow the temporary to be initialized
7475      first.  */
7476   tmp = convert_to_reference
7477     (type, init, CONV_IMPLICIT,
7478      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7479      decl);
7480
7481   if (tmp == error_mark_node)
7482     return;
7483   else if (tmp != NULL_TREE)
7484     {
7485       init = tmp;
7486       tmp = save_expr (tmp);
7487       if (building_stmt_tree ())
7488         {
7489           /* Initialize the declaration.  */
7490           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7491           finish_expr_stmt (tmp);
7492         }
7493       else
7494         DECL_INITIAL (decl) = tmp;
7495     }
7496   else
7497     {
7498       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7499       return;
7500     }
7501
7502   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7503     {
7504       expand_static_init (decl, DECL_INITIAL (decl));
7505       DECL_INITIAL (decl) = NULL_TREE;
7506     }
7507   return;
7508 }
7509
7510 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7511    mucking with forces it does not comprehend (i.e. initialization with a
7512    constructor).  If we are at global scope and won't go into COMMON, fill
7513    it in with a dummy CONSTRUCTOR to force the variable into .data;
7514    otherwise we can use error_mark_node.  */
7515
7516 static tree
7517 obscure_complex_init (decl, init)
7518      tree decl, init;
7519 {
7520   if (! flag_no_inline && TREE_STATIC (decl))
7521     {
7522       if (extract_init (decl, init))
7523         return NULL_TREE;
7524     }
7525
7526 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7527   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7528     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7529                                  NULL_TREE);
7530   else
7531 #endif
7532     DECL_INITIAL (decl) = error_mark_node;
7533
7534   return init;
7535 }
7536
7537 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7538    array until we finish parsing the initializer.  If that's the
7539    situation we're in, update DECL accordingly.  */
7540
7541 static void
7542 maybe_deduce_size_from_array_init (decl, init)
7543      tree decl;
7544      tree init;
7545 {
7546   tree type = TREE_TYPE (decl);
7547
7548   if (TREE_CODE (type) == ARRAY_TYPE
7549       && TYPE_DOMAIN (type) == NULL_TREE
7550       && TREE_CODE (decl) != TYPE_DECL)
7551     {
7552       /* do_default is really a C-ism to deal with tentative definitions.
7553          But let's leave it here to ease the eventual merge.  */
7554       int do_default = !DECL_EXTERNAL (decl);
7555       tree initializer = init ? init : DECL_INITIAL (decl);
7556       int failure = complete_array_type (type, initializer, do_default);
7557
7558       if (failure == 1)
7559         cp_error ("initializer fails to determine size of `%D'", decl);
7560
7561       if (failure == 2)
7562         {
7563           if (do_default)
7564             cp_error ("array size missing in `%D'", decl);
7565           /* If a `static' var's size isn't known, make it extern as
7566              well as static, so it does not get allocated.  If it's not
7567              `static', then don't mark it extern; finish_incomplete_decl
7568              will give it a default size and it will get allocated.  */
7569           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7570             DECL_EXTERNAL (decl) = 1;
7571         }
7572
7573       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7574           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7575                               integer_zero_node))
7576         cp_error ("zero-size array `%D'", decl);
7577
7578       layout_decl (decl, 0);
7579     }
7580 }
7581
7582 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7583    any appropriate error messages regarding the layout.  */
7584
7585 static void
7586 layout_var_decl (decl)
7587      tree decl;
7588 {
7589   tree type = TREE_TYPE (decl);
7590 #if 0
7591   tree ttype = target_type (type);
7592 #endif
7593
7594   /* If we haven't already layed out this declaration, do so now.
7595      Note that we must not call complete type for an external object
7596      because it's type might involve templates that we are not
7597      supposed to isntantiate yet.  (And it's perfectly legal to say
7598      `extern X x' for some incomplete type `X'.)  */
7599   if (!DECL_EXTERNAL (decl))
7600     complete_type (type);
7601   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7602     layout_decl (decl, 0);
7603
7604   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7605     {
7606       /* An automatic variable with an incomplete type: that is an error.
7607          Don't talk about array types here, since we took care of that
7608          message in grokdeclarator.  */
7609       cp_error ("storage size of `%D' isn't known", decl);
7610       TREE_TYPE (decl) = error_mark_node;
7611     }
7612 #if 0
7613   /* Keep this code around in case we later want to control debug info
7614      based on whether a type is "used".  (jason 1999-11-11) */
7615
7616   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7617     /* Let debugger know it should output info for this type.  */
7618     note_debug_info_needed (ttype);
7619
7620   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7621     note_debug_info_needed (DECL_CONTEXT (decl));
7622 #endif
7623
7624   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7625       && DECL_SIZE (decl) != NULL_TREE
7626       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7627     {
7628       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7629         constant_expression_warning (DECL_SIZE (decl));
7630       else
7631         cp_error ("storage size of `%D' isn't constant", decl);
7632     }
7633 }
7634
7635 /* If a local static variable is declared in an inline function, or if
7636    we have a weak definition, we must endeavor to create only one
7637    instance of the variable at link-time.  */
7638
7639 static void
7640 maybe_commonize_var (decl)
7641      tree decl;
7642 {
7643   /* Static data in a function with comdat linkage also has comdat
7644      linkage.  */
7645   if (TREE_STATIC (decl)
7646       /* Don't mess with __FUNCTION__.  */
7647       && ! DECL_ARTIFICIAL (decl)
7648       && current_function_decl
7649       && DECL_CONTEXT (decl) == current_function_decl
7650       && (DECL_THIS_INLINE (current_function_decl)
7651           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7652       && TREE_PUBLIC (current_function_decl))
7653     {
7654       /* Rather than try to get this right with inlining, we suppress
7655          inlining of such functions.  */
7656       current_function_cannot_inline
7657         = "function with static variable cannot be inline";
7658       DECL_UNINLINABLE (current_function_decl) = 1;
7659
7660       /* If flag_weak, we don't need to mess with this, as we can just
7661          make the function weak, and let it refer to its unique local
7662          copy.  This works because we don't allow the function to be
7663          inlined.  */
7664       if (! flag_weak)
7665         {
7666           if (DECL_INTERFACE_KNOWN (current_function_decl))
7667             {
7668               TREE_PUBLIC (decl) = 1;
7669               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7670             }
7671           else if (DECL_INITIAL (decl) == NULL_TREE
7672                    || DECL_INITIAL (decl) == error_mark_node)
7673             {
7674               TREE_PUBLIC (decl) = 1;
7675               DECL_COMMON (decl) = 1;
7676             }
7677           /* else we lose. We can only do this if we can use common,
7678              which we can't if it has been initialized.  */
7679
7680           if (TREE_PUBLIC (decl))
7681             DECL_ASSEMBLER_NAME (decl)
7682               = build_static_name (current_function_decl, DECL_NAME (decl));
7683           else
7684             {
7685               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7686               cp_warning_at ("  you can work around this by removing the initializer", decl);
7687             }
7688         }
7689     }
7690   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7691     /* Set it up again; we might have set DECL_INITIAL since the last
7692        time.  */
7693     comdat_linkage (decl);
7694 }
7695
7696 /* Issue an error message if DECL is an uninitialized const variable.  */
7697
7698 static void
7699 check_for_uninitialized_const_var (decl)
7700      tree decl;
7701 {
7702   tree type = TREE_TYPE (decl);
7703
7704   /* ``Unless explicitly declared extern, a const object does not have
7705      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7706      7.1.6 */
7707   if (TREE_CODE (decl) == VAR_DECL
7708       && TREE_CODE (type) != REFERENCE_TYPE
7709       && CP_TYPE_CONST_P (type)
7710       && !TYPE_NEEDS_CONSTRUCTING (type)
7711       && !DECL_INITIAL (decl))
7712     cp_error ("uninitialized const `%D'", decl);
7713 }
7714
7715 /* Verify INIT (the initializer for DECL), and record the
7716    initialization in DECL_INITIAL, if appropriate.  Returns a new
7717    value for INIT.  */
7718
7719 static tree
7720 check_initializer (decl, init)
7721      tree decl;
7722      tree init;
7723 {
7724   tree type;
7725
7726   if (TREE_CODE (decl) == FIELD_DECL)
7727     return init;
7728
7729   type = TREE_TYPE (decl);
7730
7731   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7732   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7733     init = NULL_TREE;
7734
7735   /* Check the initializer.  */
7736   if (init)
7737     {
7738       /* Things that are going to be initialized need to have complete
7739          type.  */
7740       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7741
7742       if (type == error_mark_node)
7743         /* We will have already complained.  */
7744         init = NULL_TREE;
7745       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7746         {
7747           cp_error ("variable-sized object `%D' may not be initialized", decl);
7748           init = NULL_TREE;
7749         }
7750       else if (TREE_CODE (type) == ARRAY_TYPE
7751                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7752         {
7753           cp_error ("elements of array `%#D' have incomplete type", decl);
7754           init = NULL_TREE;
7755         }
7756       else if (!COMPLETE_TYPE_P (type))
7757         {
7758           cp_error ("`%D' has incomplete type", decl);
7759           TREE_TYPE (decl) = error_mark_node;
7760           init = NULL_TREE;
7761         }
7762     }
7763
7764   if (TREE_CODE (decl) == CONST_DECL)
7765     {
7766       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7767
7768       DECL_INITIAL (decl) = init;
7769
7770       /* This will keep us from needing to worry about our obstacks.  */
7771       my_friendly_assert (init != NULL_TREE, 149);
7772       init = NULL_TREE;
7773     }
7774   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7775     {
7776       if (TREE_STATIC (decl))
7777         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7778       grok_reference_init (decl, type, init);
7779       init = NULL_TREE;
7780     }
7781   else if (init)
7782     {
7783       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7784         {
7785           if (TREE_CODE (type) == ARRAY_TYPE)
7786             init = digest_init (type, init, (tree *) 0);
7787           else if (TREE_CODE (init) == CONSTRUCTOR
7788                    && TREE_HAS_CONSTRUCTOR (init))
7789             {
7790               if (TYPE_NON_AGGREGATE_CLASS (type))
7791                 {
7792                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7793                             decl);
7794                   init = error_mark_node;
7795                 }
7796               else
7797                 goto dont_use_constructor;
7798             }
7799         }
7800       else
7801         {
7802         dont_use_constructor:
7803           if (TREE_CODE (init) != TREE_VEC)
7804             init = store_init_value (decl, init);
7805         }
7806
7807       if (init)
7808         /* We must hide the initializer so that expand_decl
7809            won't try to do something it does not understand.  */
7810         init = obscure_complex_init (decl, init);
7811     }
7812   else if (DECL_EXTERNAL (decl))
7813     ;
7814   else if (TYPE_P (type)
7815            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7816     {
7817       tree core_type = strip_array_types (type);
7818
7819       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7820         {
7821           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7822             cp_error ("structure `%D' with uninitialized const members", decl);
7823           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7824             cp_error ("structure `%D' with uninitialized reference members",
7825                       decl);
7826         }
7827
7828       check_for_uninitialized_const_var (decl);
7829
7830       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7831         init = obscure_complex_init (decl, NULL_TREE);
7832
7833     }
7834   else
7835     check_for_uninitialized_const_var (decl);
7836
7837   return init;
7838 }
7839
7840 /* If DECL is not a local variable, give it RTL.  */
7841
7842 static void
7843 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7844      tree decl;
7845      tree init;
7846      const char *asmspec;
7847 {
7848   int toplev = toplevel_bindings_p ();
7849   int defer_p;
7850
7851   /* Handle non-variables up front.  */
7852   if (TREE_CODE (decl) != VAR_DECL)
7853     {
7854       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7855       return;
7856     }
7857
7858   /* If we see a class member here, it should be a static data
7859      member.  */
7860   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7861     {
7862       my_friendly_assert (TREE_STATIC (decl), 19990828);
7863       /* An in-class declaration of a static data member should be
7864          external; it is only a declaration, and not a definition.  */
7865       if (init == NULL_TREE)
7866         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7867     }
7868
7869   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7870   if (asmspec)
7871     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7872
7873   /* We don't create any RTL for local variables.  */
7874   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7875     return;
7876
7877   /* We defer emission of local statics until the corresponding
7878      DECL_STMT is expanded.  */
7879   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7880
7881   /* We try to defer namespace-scope static constants so that they are
7882      not emitted into the object file unncessarily.  */
7883   if (!DECL_VIRTUAL_P (decl)
7884       && TREE_READONLY (decl)
7885       && DECL_INITIAL (decl) != NULL_TREE
7886       && DECL_INITIAL (decl) != error_mark_node
7887       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7888       && toplev
7889       && !TREE_PUBLIC (decl))
7890     {
7891       /* Fool with the linkage according to #pragma interface.  */
7892       if (!interface_unknown)
7893         {
7894           TREE_PUBLIC (decl) = 1;
7895           DECL_EXTERNAL (decl) = interface_only;
7896         }
7897
7898       defer_p = 1;
7899     }
7900
7901   /* If we're deferring the variable, just make RTL.  Do not actually
7902      emit the variable.  */
7903   if (defer_p)
7904     make_decl_rtl (decl, asmspec, toplev);
7905   /* If we're not deferring, go ahead and assemble the variable.  */
7906   else
7907     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7908 }
7909
7910 /* The old ARM scoping rules injected variables declared in the
7911    initialization statement of a for-statement into the surrounding
7912    scope.  We support this usage, in order to be backward-compatible.
7913    DECL is a just-declared VAR_DECL; if necessary inject its
7914    declaration into the surrounding scope.  */
7915
7916 void
7917 maybe_inject_for_scope_var (decl)
7918      tree decl;
7919 {
7920   if (!DECL_NAME (decl))
7921     return;
7922
7923   if (current_binding_level->is_for_scope)
7924     {
7925       struct binding_level *outer
7926         = current_binding_level->level_chain;
7927
7928       /* Check to see if the same name is already bound at the outer
7929          level, either because it was directly declared, or because a
7930          dead for-decl got preserved.  In either case, the code would
7931          not have been valid under the ARM scope rules, so clear
7932          is_for_scope for the current_binding_level.
7933
7934          Otherwise, we need to preserve the temp slot for decl to last
7935          into the outer binding level.  */
7936
7937       tree outer_binding
7938         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7939
7940       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7941           && (TREE_CODE (BINDING_VALUE (outer_binding))
7942               == VAR_DECL)
7943           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7944         {
7945           BINDING_VALUE (outer_binding)
7946             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7947           current_binding_level->is_for_scope = 0;
7948         }
7949       else if (DECL_IN_MEMORY_P (decl))
7950         preserve_temp_slots (DECL_RTL (decl));
7951     }
7952 }
7953
7954 /* Generate code to initialize DECL (a local variable).  */
7955
7956 void
7957 initialize_local_var (decl, init, flags)
7958      tree decl;
7959      tree init;
7960      int flags;
7961 {
7962   tree type = TREE_TYPE (decl);
7963
7964   /* If the type is bogus, don't bother initializing the variable.  */
7965   if (type == error_mark_node)
7966     return;
7967
7968   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7969     {
7970       /* If we used it already as memory, it must stay in memory.  */
7971       DECL_INITIAL (decl) = NULL_TREE;
7972       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7973     }
7974
7975   /* Local statics are handled differently from ordinary automatic
7976      variables.  */
7977   if (TREE_STATIC (decl))
7978     {
7979       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7980           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7981         expand_static_init (decl, init);
7982       return;
7983     }
7984
7985   if (DECL_SIZE (decl) && type != error_mark_node)
7986     {
7987       int already_used;
7988
7989       /* Compute and store the initial value.  */
7990       already_used = TREE_USED (decl) || TREE_USED (type);
7991
7992       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7993         {
7994           int saved_stmts_are_full_exprs_p;
7995
7996           my_friendly_assert (building_stmt_tree (), 20000906);
7997           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7998           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7999           finish_expr_stmt (build_aggr_init (decl, init, flags));
8000           current_stmt_tree ()->stmts_are_full_exprs_p =
8001             saved_stmts_are_full_exprs_p;
8002         }
8003
8004       /* Set this to 0 so we can tell whether an aggregate which was
8005          initialized was ever used.  Don't do this if it has a
8006          destructor, so we don't complain about the 'resource
8007          allocation is initialization' idiom.  Now set
8008          attribute((unused)) on types so decls of that type will be
8009          marked used. (see TREE_USED, above.)  */
8010       if (TYPE_NEEDS_CONSTRUCTING (type)
8011           && ! already_used
8012           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8013           && DECL_NAME (decl))
8014         TREE_USED (decl) = 0;
8015       else if (already_used)
8016         TREE_USED (decl) = 1;
8017     }
8018 }
8019
8020 /* Generate code to destroy DECL (a local variable).  */
8021
8022 static void
8023 destroy_local_var (decl)
8024      tree decl;
8025 {
8026   tree type = TREE_TYPE (decl);
8027   tree cleanup;
8028
8029   /* Only variables get cleaned up.  */
8030   if (TREE_CODE (decl) != VAR_DECL)
8031     return;
8032
8033   /* And only things with destructors need cleaning up.  */
8034   if (type == error_mark_node
8035       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8036     return;
8037
8038   if (TREE_CODE (decl) == VAR_DECL &&
8039       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8040     /* We don't clean up things that aren't defined in this
8041        translation unit, or that need a static cleanup.  The latter
8042        are handled by finish_file.  */
8043     return;
8044
8045   /* Compute the cleanup.  */
8046   cleanup = maybe_build_cleanup (decl);
8047
8048   /* Record the cleanup required for this declaration.  */
8049   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8050       && cleanup)
8051     finish_decl_cleanup (decl, cleanup);
8052 }
8053
8054 /* Finish processing of a declaration;
8055    install its line number and initial value.
8056    If the length of an array type is not known before,
8057    it must be determined now, from the initial value, or it is an error.
8058
8059    INIT holds the value of an initializer that should be allowed to escape
8060    the normal rules.
8061
8062    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8063    if the (init) syntax was used.  */
8064
8065 void
8066 cp_finish_decl (decl, init, asmspec_tree, flags)
8067      tree decl, init;
8068      tree asmspec_tree;
8069      int flags;
8070 {
8071   register tree type;
8072   tree ttype = NULL_TREE;
8073   const char *asmspec = NULL;
8074   int was_readonly = 0;
8075
8076   if (! decl)
8077     {
8078       if (init)
8079         error ("assignment (not initialization) in declaration");
8080       return;
8081     }
8082
8083   /* If a name was specified, get the string.  */
8084   if (asmspec_tree)
8085       asmspec = TREE_STRING_POINTER (asmspec_tree);
8086
8087   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8088     {
8089       cp_error ("cannot initialize `%D' to namespace `%D'",
8090                 decl, init);
8091       init = NULL_TREE;
8092     }
8093
8094   if (current_class_type
8095       && CP_DECL_CONTEXT (decl) == current_class_type
8096       && TYPE_BEING_DEFINED (current_class_type)
8097       && (DECL_INITIAL (decl) || init))
8098     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8099
8100   if (TREE_CODE (decl) == VAR_DECL
8101       && DECL_CONTEXT (decl)
8102       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8103       && DECL_CONTEXT (decl) != current_namespace
8104       && init)
8105     {
8106       /* Leave the namespace of the object. */
8107       pop_decl_namespace ();
8108     }
8109
8110   type = TREE_TYPE (decl);
8111
8112   if (type == error_mark_node)
8113     return;
8114
8115   /* Add this declaration to the statement-tree.  */
8116   if (building_stmt_tree ()
8117       && at_function_scope_p ()
8118       && TREE_CODE (decl) != RESULT_DECL)
8119     add_decl_stmt (decl);
8120
8121   if (TYPE_HAS_MUTABLE_P (type))
8122     TREE_READONLY (decl) = 0;
8123
8124   if (processing_template_decl)
8125     {
8126       if (init && DECL_INITIAL (decl))
8127         DECL_INITIAL (decl) = init;
8128       goto finish_end0;
8129     }
8130
8131   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8132   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8133
8134   /* Take care of TYPE_DECLs up front.  */
8135   if (TREE_CODE (decl) == TYPE_DECL)
8136     {
8137       if (init && DECL_INITIAL (decl))
8138         {
8139           /* typedef foo = bar; store the type of bar as the type of foo.  */
8140           TREE_TYPE (decl) = type = TREE_TYPE (init);
8141           DECL_INITIAL (decl) = init = NULL_TREE;
8142         }
8143       if (type != error_mark_node
8144           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8145         {
8146           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8147             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8148           set_identifier_type_value (DECL_NAME (decl), type);
8149           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8150         }
8151       GNU_xref_decl (current_function_decl, decl);
8152
8153       /* If we have installed this as the canonical typedef for this
8154          type, and that type has not been defined yet, delay emitting
8155          the debug information for it, as we will emit it later.  */
8156       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8157           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8158         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8159
8160       rest_of_decl_compilation (decl, NULL_PTR,
8161                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8162       goto finish_end;
8163     }
8164
8165   if (TREE_CODE (decl) != FUNCTION_DECL)
8166     ttype = target_type (type);
8167
8168   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8169       && TYPE_NEEDS_CONSTRUCTING (type))
8170     {
8171       /* Currently, GNU C++ puts constants in text space, making them
8172          impossible to initialize.  In the future, one would hope for
8173          an operating system which understood the difference between
8174          initialization and the running of a program.  */
8175       was_readonly = 1;
8176       TREE_READONLY (decl) = 0;
8177     }
8178
8179   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8180     {
8181       /* This must override the asm specifier which was placed by
8182          grokclassfn.  Lay this out fresh.  */
8183       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8184       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8185       make_decl_rtl (decl, asmspec, 0);
8186     }
8187
8188   /* Deduce size of array from initialization, if not already known.  */
8189   maybe_deduce_size_from_array_init (decl, init);
8190   init = check_initializer (decl, init);
8191
8192   GNU_xref_decl (current_function_decl, decl);
8193
8194   if (TREE_CODE (decl) == VAR_DECL)
8195     layout_var_decl (decl);
8196
8197   /* Output the assembler code and/or RTL code for variables and functions,
8198      unless the type is an undefined structure or union.
8199      If not, it will get done when the type is completed.  */
8200   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8201       || TREE_CODE (decl) == RESULT_DECL)
8202     {
8203       if (TREE_CODE (decl) == VAR_DECL)
8204         maybe_commonize_var (decl);
8205
8206       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8207
8208       if (TREE_CODE (type) == FUNCTION_TYPE
8209           || TREE_CODE (type) == METHOD_TYPE)
8210         abstract_virtuals_error (decl,
8211                                  strip_array_types (TREE_TYPE (type)));
8212       else
8213         abstract_virtuals_error (decl, strip_array_types (type));
8214
8215       if (TREE_CODE (decl) == FUNCTION_DECL)
8216         ;
8217       else if (DECL_EXTERNAL (decl)
8218                && ! (DECL_LANG_SPECIFIC (decl)
8219                      && DECL_NOT_REALLY_EXTERN (decl)))
8220         {
8221           if (init)
8222             DECL_INITIAL (decl) = init;
8223         }
8224       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8225         {
8226           /* This is a local declaration.  */
8227           if (doing_semantic_analysis_p ())
8228             maybe_inject_for_scope_var (decl);
8229           /* Initialize the local variable.  But, if we're building a
8230              statement-tree, we'll do the initialization when we
8231              expand the tree.  */
8232           if (processing_template_decl)
8233             {
8234               if (init || DECL_INITIAL (decl) == error_mark_node)
8235                 DECL_INITIAL (decl) = init;
8236             }
8237           else
8238             {
8239               /* If we're not building RTL, then we need to do so
8240                  now.  */
8241               my_friendly_assert (building_stmt_tree (), 20000906);
8242               /* Initialize the variable.  */
8243               initialize_local_var (decl, init, flags);
8244               /* Clean up the variable.  */
8245               destroy_local_var (decl);
8246             }
8247         }
8248       else if (TREE_STATIC (decl) && type != error_mark_node)
8249         {
8250           /* Cleanups for static variables are handled by `finish_file'.  */
8251           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8252               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8253             expand_static_init (decl, init);
8254         }
8255     finish_end0:
8256
8257       /* Undo call to `pushclass' that was done in `start_decl'
8258          due to initialization of qualified member variable.
8259          I.e., Foo::x = 10;  */
8260       {
8261         tree context = CP_DECL_CONTEXT (decl);
8262         if (context
8263             && TYPE_P (context)
8264             && (TREE_CODE (decl) == VAR_DECL
8265                 /* We also have a pushclass done that we need to undo here
8266                    if we're at top level and declare a method.  */
8267                 || TREE_CODE (decl) == FUNCTION_DECL)
8268             /* If size hasn't been set, we're still defining it,
8269                and therefore inside the class body; don't pop
8270                the binding level..  */
8271             && COMPLETE_TYPE_P (context)
8272             && context == current_class_type)
8273           pop_nested_class ();
8274       }
8275     }
8276
8277  finish_end:
8278
8279   if (was_readonly)
8280     TREE_READONLY (decl) = 1;
8281 }
8282
8283 /* This is here for a midend callback from c-common.c */
8284
8285 void
8286 finish_decl (decl, init, asmspec_tree)
8287      tree decl, init;
8288      tree asmspec_tree;
8289 {
8290   cp_finish_decl (decl, init, asmspec_tree, 0);
8291 }
8292
8293 /* Returns a declaration for a VAR_DECL as if:
8294
8295      extern "C" TYPE NAME;
8296
8297    had been seen.  Used to create compiler-generated global
8298    variables.  */
8299
8300 tree
8301 declare_global_var (name, type)
8302      tree name;
8303      tree type;
8304 {
8305   tree decl;
8306
8307   push_to_top_level ();
8308   decl = build_decl (VAR_DECL, name, type);
8309   TREE_PUBLIC (decl) = 1;
8310   DECL_EXTERNAL (decl) = 1;
8311   DECL_ARTIFICIAL (decl) = 1;
8312   pushdecl (decl);
8313   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8314   pop_from_top_level ();
8315
8316   return decl;
8317 }
8318
8319 /* Returns a pointer to the `atexit' function.  Note that if
8320    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8321    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8322
8323 static tree
8324 get_atexit_node ()
8325 {
8326   tree atexit_fndecl;
8327   tree arg_types;
8328   tree fn_type;
8329   tree fn_ptr_type;
8330   const char *name;
8331
8332   if (atexit_node)
8333     return atexit_node;
8334
8335   if (flag_use_cxa_atexit)
8336     {
8337       /* The declaration for `__cxa_atexit' is:
8338
8339            int __cxa_atexit (void (*)(void *), void *, void *)
8340
8341          We build up the argument types and then then function type
8342          itself.  */
8343
8344       /* First, build the pointer-to-function type for the first
8345          argument.  */
8346       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8347       fn_type = build_function_type (void_type_node, arg_types);
8348       fn_ptr_type = build_pointer_type (fn_type);
8349       /* Then, build the rest of the argument types.  */
8350       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8351       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8352       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8353       /* And the final __cxa_atexit type.  */
8354       fn_type = build_function_type (integer_type_node, arg_types);
8355       fn_ptr_type = build_pointer_type (fn_type);
8356       name = "__cxa_atexit";
8357     }
8358   else
8359     {
8360       /* The declaration for `atexit' is:
8361
8362            int atexit (void (*)());
8363
8364          We build up the argument types and then then function type
8365          itself.  */
8366       fn_type = build_function_type (void_type_node, void_list_node);
8367       fn_ptr_type = build_pointer_type (fn_type);
8368       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8369       /* Build the final atexit type.  */
8370       fn_type = build_function_type (integer_type_node, arg_types);
8371       name = "atexit";
8372     }
8373
8374   /* Now, build the function declaration.  */
8375   push_lang_context (lang_name_c);
8376   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8377   mark_used (atexit_fndecl);
8378   pop_lang_context ();
8379   atexit_node = default_conversion (atexit_fndecl);
8380
8381   return atexit_node;
8382 }
8383
8384 /* Returns the __dso_handle VAR_DECL.  */
8385
8386 static tree
8387 get_dso_handle_node ()
8388 {
8389   if (dso_handle_node)
8390     return dso_handle_node;
8391
8392   /* Declare the variable.  */
8393   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8394                                         ptr_type_node);
8395
8396   return dso_handle_node;
8397 }
8398
8399 /* Begin a new function with internal linkage whose job will be simply
8400    to destroy some particular variable.  */
8401
8402 static tree
8403 start_cleanup_fn ()
8404 {
8405   static int counter = 0;
8406   int old_interface_unknown = interface_unknown;
8407   char name[32];
8408   tree parmtypes;
8409   tree fntype;
8410   tree fndecl;
8411
8412   push_to_top_level ();
8413
8414   /* No need to mangle this.  */
8415   push_lang_context (lang_name_c);
8416
8417   interface_unknown = 1;
8418
8419   /* Build the parameter-types.  */
8420   parmtypes = void_list_node;
8421   /* Functions passed to __cxa_atexit take an additional parameter.
8422      We'll just ignore it.  After we implement the new calling
8423      convention for destructors, we can eliminate the use of
8424      additional cleanup functions entirely in the -fnew-abi case.  */
8425   if (flag_use_cxa_atexit)
8426     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8427   /* Build the function type itself.  */
8428   fntype = build_function_type (void_type_node, parmtypes);
8429   /* Build the name of the function.  */
8430   sprintf (name, "__tcf_%d", counter++);
8431   /* Build the function declaration.  */
8432   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8433   /* It's a function with internal linkage, generated by the
8434      compiler.  */
8435   TREE_PUBLIC (fndecl) = 0;
8436   DECL_ARTIFICIAL (fndecl) = 1;
8437   /* Make the function `inline' so that it is only emitted if it is
8438      actually needed.  It is unlikely that it will be inlined, since
8439      it is only called via a function pointer, but we avoid unncessary
8440      emissions this way.  */
8441   DECL_INLINE (fndecl) = 1;
8442   /* Build the parameter.  */
8443   if (flag_use_cxa_atexit)
8444     {
8445       tree parmdecl;
8446
8447       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8448       DECL_CONTEXT (parmdecl) = fndecl;
8449       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8450       TREE_USED (parmdecl) = 1;
8451       DECL_ARGUMENTS (fndecl) = parmdecl;
8452     }
8453
8454   pushdecl (fndecl);
8455   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8456   do_pushlevel ();
8457
8458   interface_unknown = old_interface_unknown;
8459
8460   pop_lang_context ();
8461
8462   return current_function_decl;
8463 }
8464
8465 /* Finish the cleanup function begun by start_cleanup_fn.  */
8466
8467 static void
8468 end_cleanup_fn ()
8469 {
8470   do_poplevel ();
8471
8472   expand_body (finish_function (0));
8473
8474   pop_from_top_level ();
8475 }
8476
8477 /* Generate code to handle the destruction of DECL, an object with
8478    static storage duration.  */
8479
8480 void
8481 register_dtor_fn (decl)
8482      tree decl;
8483 {
8484   tree cleanup;
8485   tree compound_stmt;
8486   tree args;
8487   tree fcall;
8488
8489   int saved_flag_access_control;
8490
8491   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8492     return;
8493
8494   /* Call build_cleanup before we enter the anonymous function so that
8495      any access checks will be done relative to the current scope,
8496      rather than the scope of the anonymous function.  */
8497   build_cleanup (decl);
8498
8499   /* Now start the function.  */
8500   cleanup = start_cleanup_fn ();
8501
8502   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8503      to the original function, rather than the anonymous one.  That
8504      will make the back-end think that nested functions are in use,
8505      which causes confusion.  */
8506   saved_flag_access_control = flag_access_control;
8507   flag_access_control = 0;
8508   fcall = build_cleanup (decl);
8509   flag_access_control = saved_flag_access_control;
8510
8511   /* Create the body of the anonymous function.  */
8512   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8513   finish_expr_stmt (fcall);
8514   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8515   end_cleanup_fn ();
8516
8517   /* Call atexit with the cleanup function.  */
8518   mark_addressable (cleanup);
8519   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8520   if (flag_use_cxa_atexit)
8521     {
8522       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8523       args = tree_cons (NULL_TREE, null_pointer_node, args);
8524       args = tree_cons (NULL_TREE, cleanup, args);
8525     }
8526   else
8527     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8528   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8529 }
8530
8531 void
8532 expand_static_init (decl, init)
8533      tree decl;
8534      tree init;
8535 {
8536   tree oldstatic = value_member (decl, static_aggregates);
8537
8538   if (oldstatic)
8539     {
8540       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8541         cp_error ("multiple initializations given for `%D'", decl);
8542     }
8543   else if (! toplevel_bindings_p ())
8544     {
8545       /* Emit code to perform this initialization but once.  */
8546       tree if_stmt;
8547       tree then_clause;
8548       tree assignment;
8549       tree guard;
8550       tree guard_init;
8551
8552       /* Emit code to perform this initialization but once.  This code
8553          looks like:
8554
8555            static int guard = 0;
8556            if (!guard) {
8557              // Do initialization.
8558              guard = 1;
8559              // Register variable for destruction at end of program.
8560            }
8561
8562          Note that the `temp' variable is only set to 1 *after* the
8563          initialization is complete.  This ensures that an exception,
8564          thrown during the construction, will cause the variable to
8565          reinitialized when we pass through this code again, as per:
8566
8567            [stmt.dcl]
8568
8569            If the initialization exits by throwing an exception, the
8570            initialization is not complete, so it will be tried again
8571            the next time control enters the declaration.
8572
8573          In theory, this process should be thread-safe, too; multiple
8574          threads should not be able to initialize the variable more
8575          than once.  We don't yet attempt to ensure thread-safety.  */
8576
8577       /* Create the guard variable.  */
8578       guard = get_guard (decl);
8579
8580       /* Begin the conditional initialization.  */
8581       if_stmt = begin_if_stmt ();
8582       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8583       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8584
8585       /* Do the initialization itself.  */
8586       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8587           || (init && TREE_CODE (init) == TREE_LIST))
8588         assignment = build_aggr_init (decl, init, 0);
8589       else if (init)
8590         /* The initialization we're doing here is just a bitwise
8591            copy.  */
8592         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8593       else
8594         assignment = NULL_TREE;
8595
8596       /* Once the assignment is complete, set TEMP to 1.  Since the
8597          construction of the static object is complete at this point,
8598          we want to make sure TEMP is set to 1 even if a temporary
8599          constructed during the initialization throws an exception
8600          when it is destroyed.  So, we combine the initialization and
8601          the assignment to TEMP into a single expression, ensuring
8602          that when we call finish_expr_stmt the cleanups will not be
8603          run until after TEMP is set to 1.  */
8604       guard_init = set_guard (guard);
8605       if (assignment)
8606         {
8607           assignment = tree_cons (NULL_TREE, assignment,
8608                                   build_tree_list (NULL_TREE,
8609                                                    guard_init));
8610           assignment = build_compound_expr (assignment);
8611         }
8612       else
8613         assignment = guard_init;
8614       finish_expr_stmt (assignment);
8615
8616       /* Use atexit to register a function for destroying this static
8617          variable.  */
8618       register_dtor_fn (decl);
8619
8620       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8621       finish_then_clause (if_stmt);
8622       finish_if_stmt ();
8623     }
8624   else
8625     static_aggregates = tree_cons (init, decl, static_aggregates);
8626 }
8627
8628 /* Finish the declaration of a catch-parameter.  */
8629
8630 tree
8631 start_handler_parms (declspecs, declarator)
8632      tree declspecs;
8633      tree declarator;
8634 {
8635   tree decl;
8636   if (declspecs)
8637     {
8638       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8639                              1, NULL_TREE);
8640       if (decl == NULL_TREE)
8641         error ("invalid catch parameter");
8642     }
8643   else
8644     decl = NULL_TREE;
8645
8646   return decl;
8647 }
8648
8649 \f
8650 /* Make TYPE a complete type based on INITIAL_VALUE.
8651    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8652    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8653
8654 int
8655 complete_array_type (type, initial_value, do_default)
8656      tree type, initial_value;
8657      int do_default;
8658 {
8659   register tree maxindex = NULL_TREE;
8660   int value = 0;
8661
8662   if (initial_value)
8663     {
8664       /* An array of character type can be initialized from a
8665          brace-enclosed string constant.  */
8666       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8667           && TREE_CODE (initial_value) == CONSTRUCTOR
8668           && CONSTRUCTOR_ELTS (initial_value)
8669           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8670               == STRING_CST)
8671           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8672         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8673
8674       /* Note MAXINDEX is really the maximum index, one less than the
8675          size.  */
8676       if (TREE_CODE (initial_value) == STRING_CST)
8677         {
8678           int eltsize
8679             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8680           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8681                                    / eltsize) - 1, 0);
8682         }
8683       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8684         {
8685           tree elts = CONSTRUCTOR_ELTS (initial_value);
8686
8687           maxindex = ssize_int (-1);
8688           for (; elts; elts = TREE_CHAIN (elts))
8689             {
8690               if (TREE_PURPOSE (elts))
8691                 maxindex = TREE_PURPOSE (elts);
8692               else
8693                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8694             }
8695           maxindex = copy_node (maxindex);
8696         }
8697       else
8698         {
8699           /* Make an error message unless that happened already.  */
8700           if (initial_value != error_mark_node)
8701             value = 1;
8702           else
8703             initial_value = NULL_TREE;
8704
8705           /* Prevent further error messages.  */
8706           maxindex = build_int_2 (0, 0);
8707         }
8708     }
8709
8710   if (!maxindex)
8711     {
8712       if (do_default)
8713         maxindex = build_int_2 (0, 0);
8714       value = 2;
8715     }
8716
8717   if (maxindex)
8718     {
8719       tree itype;
8720       tree domain;
8721
8722       domain = build_index_type (maxindex);
8723       TYPE_DOMAIN (type) = domain;
8724
8725       if (! TREE_TYPE (maxindex))
8726         TREE_TYPE (maxindex) = domain;
8727       if (initial_value)
8728         itype = TREE_TYPE (initial_value);
8729       else
8730         itype = NULL;
8731       if (itype && !TYPE_DOMAIN (itype))
8732         TYPE_DOMAIN (itype) = domain;
8733       /* The type of the main variant should never be used for arrays
8734          of different sizes.  It should only ever be completed with the
8735          size of the array.  */
8736       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8737         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8738     }
8739
8740   /* Lay out the type now that we can get the real answer.  */
8741
8742   layout_type (type);
8743
8744   return value;
8745 }
8746 \f
8747 /* Return zero if something is declared to be a member of type
8748    CTYPE when in the context of CUR_TYPE.  STRING is the error
8749    message to print in that case.  Otherwise, quietly return 1.  */
8750
8751 static int
8752 member_function_or_else (ctype, cur_type, flags)
8753      tree ctype, cur_type;
8754      enum overload_flags flags;
8755 {
8756   if (ctype && ctype != cur_type)
8757     {
8758       if (flags == DTOR_FLAG)
8759         cp_error ("destructor for alien class `%T' cannot be a member",
8760                   ctype);
8761       else
8762         cp_error ("constructor for alien class `%T' cannot be a member",
8763                   ctype);
8764       return 0;
8765     }
8766   return 1;
8767 }
8768 \f
8769 /* Subroutine of `grokdeclarator'.  */
8770
8771 /* Generate errors possibly applicable for a given set of specifiers.
8772    This is for ARM $7.1.2.  */
8773
8774 static void
8775 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8776      tree object;
8777      const char *type;
8778      int virtualp, quals, friendp, raises, inlinep;
8779 {
8780   if (virtualp)
8781     cp_error ("`%D' declared as a `virtual' %s", object, type);
8782   if (inlinep)
8783     cp_error ("`%D' declared as an `inline' %s", object, type);
8784   if (quals)
8785     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8786               object, type);
8787   if (friendp)
8788     cp_error_at ("`%D' declared as a friend", object);
8789   if (raises)
8790     cp_error_at ("`%D' declared with an exception specification", object);
8791 }
8792
8793 /* CTYPE is class type, or null if non-class.
8794    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8795    or METHOD_TYPE.
8796    DECLARATOR is the function's name.
8797    VIRTUALP is truthvalue of whether the function is virtual or not.
8798    FLAGS are to be passed through to `grokclassfn'.
8799    QUALS are qualifiers indicating whether the function is `const'
8800    or `volatile'.
8801    RAISES is a list of exceptions that this function can raise.
8802    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8803    not look, and -1 if we should not call `grokclassfn' at all.
8804
8805    Returns `NULL_TREE' if something goes wrong, after issuing
8806    applicable error messages.  */
8807
8808 static tree
8809 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8810             raises, check, friendp, publicp, inlinep, funcdef_flag,
8811             template_count, in_namespace)
8812      tree ctype, type;
8813      tree declarator;
8814      tree orig_declarator;
8815      int virtualp;
8816      enum overload_flags flags;
8817      tree quals, raises;
8818      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8819      tree in_namespace;
8820 {
8821   tree cname, decl;
8822   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8823   int has_default_arg = 0;
8824   tree t;
8825
8826   if (ctype)
8827     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8828       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8829   else
8830     cname = NULL_TREE;
8831
8832   if (raises)
8833     {
8834       type = build_exception_variant (type, raises);
8835     }
8836
8837   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8838   /* Propagate volatile out from type to decl. */
8839   if (TYPE_VOLATILE (type))
8840     TREE_THIS_VOLATILE (decl) = 1;
8841
8842   /* If this decl has namespace scope, set that up.  */
8843   if (in_namespace)
8844     set_decl_namespace (decl, in_namespace, friendp);
8845   else if (!ctype)
8846     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8847
8848   /* `main' and builtins have implicit 'C' linkage.  */
8849   if ((MAIN_NAME_P (declarator)
8850        || (IDENTIFIER_LENGTH (declarator) > 10
8851            && IDENTIFIER_POINTER (declarator)[0] == '_'
8852            && IDENTIFIER_POINTER (declarator)[1] == '_'
8853            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8854       && current_lang_name == lang_name_cplusplus
8855       && ctype == NULL_TREE
8856       /* NULL_TREE means global namespace.  */
8857       && DECL_CONTEXT (decl) == NULL_TREE)
8858     DECL_LANGUAGE (decl) = lang_c;
8859
8860   /* Should probably propagate const out from type to decl I bet (mrs).  */
8861   if (staticp)
8862     {
8863       DECL_STATIC_FUNCTION_P (decl) = 1;
8864       DECL_CONTEXT (decl) = ctype;
8865     }
8866
8867   if (ctype)
8868     DECL_CONTEXT (decl) = ctype;
8869
8870   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8871     {
8872       if (processing_template_decl)
8873         error ("cannot declare `::main' to be a template");
8874       if (inlinep)
8875         error ("cannot declare `::main' to be inline");
8876       if (!publicp)
8877         error ("cannot declare `::main' to be static");
8878       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8879                         integer_type_node))
8880         error ("`main' must return `int'");
8881       inlinep = 0;
8882       publicp = 1;
8883     }
8884
8885   /* Members of anonymous types and local classes have no linkage; make
8886      them internal.  */
8887   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8888                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8889     publicp = 0;
8890
8891   if (publicp)
8892     {
8893       /* [basic.link]: A name with no linkage (notably, the name of a class
8894          or enumeration declared in a local scope) shall not be used to
8895          declare an entity with linkage.
8896
8897          Only check this for public decls for now.  */
8898       t = no_linkage_check (TREE_TYPE (decl));
8899       if (t)
8900         {
8901           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8902             {
8903               if (DECL_EXTERN_C_P (decl))
8904                 /* Allow this; it's pretty common in C.  */;
8905               else
8906                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8907                             decl);
8908             }
8909           else
8910             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8911                         decl, t);
8912         }
8913     }
8914
8915   TREE_PUBLIC (decl) = publicp;
8916   if (! publicp)
8917     {
8918       DECL_INTERFACE_KNOWN (decl) = 1;
8919       DECL_NOT_REALLY_EXTERN (decl) = 1;
8920     }
8921
8922   if (inlinep)
8923     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8924
8925   DECL_EXTERNAL (decl) = 1;
8926   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8927     {
8928       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8929                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8930       quals = NULL_TREE;
8931     }
8932
8933   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8934     grok_op_properties (decl, virtualp, check < 0);
8935
8936   if (ctype && decl_function_context (decl))
8937     DECL_NO_STATIC_CHAIN (decl) = 1;
8938
8939   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8940     if (TREE_PURPOSE (t)
8941         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8942       {
8943         has_default_arg = 1;
8944         break;
8945       }
8946
8947   if (friendp
8948       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8949     {
8950       if (funcdef_flag)
8951         cp_error
8952           ("defining explicit specialization `%D' in friend declaration",
8953            orig_declarator);
8954       else
8955         {
8956           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8957             {
8958               /* Something like `template <class T> friend void f<T>()'.  */
8959               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8960                         orig_declarator);
8961               return NULL_TREE;
8962             }
8963
8964
8965           /* A friend declaration of the form friend void f<>().  Record
8966              the information in the TEMPLATE_ID_EXPR.  */
8967           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8968           DECL_TEMPLATE_INFO (decl)
8969             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8970                          TREE_OPERAND (orig_declarator, 1),
8971                          NULL_TREE);
8972
8973           if (has_default_arg)
8974             {
8975               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8976                         decl);
8977               return NULL_TREE;
8978             }
8979
8980           if (inlinep)
8981             {
8982               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8983                         decl);
8984               return NULL_TREE;
8985             }
8986         }
8987     }
8988
8989   if (has_default_arg)
8990     add_defarg_fn (decl);
8991
8992   /* Plain overloading: will not be grok'd by grokclassfn.  */
8993   if (! ctype && ! processing_template_decl
8994       && !DECL_EXTERN_C_P (decl)
8995       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8996     set_mangled_name_for_decl (decl);
8997
8998   if (funcdef_flag)
8999     /* Make the init_value nonzero so pushdecl knows this is not
9000        tentative.  error_mark_node is replaced later with the BLOCK.  */
9001     DECL_INITIAL (decl) = error_mark_node;
9002
9003   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9004     TREE_NOTHROW (decl) = 1;
9005
9006   /* Caller will do the rest of this.  */
9007   if (check < 0)
9008     return decl;
9009
9010   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9011     DECL_CONSTRUCTOR_P (decl) = 1;
9012
9013   /* Function gets the ugly name, field gets the nice one.  This call
9014      may change the type of the function (because of default
9015      parameters)!  */
9016   if (ctype != NULL_TREE)
9017     grokclassfn (ctype, decl, flags, quals);
9018
9019   decl = check_explicit_specialization (orig_declarator, decl,
9020                                         template_count,
9021                                         2 * (funcdef_flag != 0) +
9022                                         4 * (friendp != 0));
9023   if (decl == error_mark_node)
9024     return NULL_TREE;
9025
9026   if (ctype != NULL_TREE
9027       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9028       && check)
9029     {
9030       tree old_decl;
9031
9032       old_decl = check_classfn (ctype, decl);
9033
9034       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9035         /* Because grokfndecl is always supposed to return a
9036            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9037            here.  We depend on our callers to figure out that its
9038            really a template that's being returned.  */
9039         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9040
9041       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9042           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9043         {
9044           /* Remove the `this' parm added by grokclassfn.
9045              XXX Isn't this done in start_function, too?  */
9046           revert_static_member_fn (decl);
9047           last_function_parms = TREE_CHAIN (last_function_parms);
9048         }
9049       if (old_decl && DECL_ARTIFICIAL (old_decl))
9050         cp_error ("definition of implicitly-declared `%D'", old_decl);
9051
9052       if (old_decl)
9053         {
9054           /* Since we've smashed OLD_DECL to its
9055              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9056           if (TREE_CODE (decl) == TEMPLATE_DECL)
9057             decl = DECL_TEMPLATE_RESULT (decl);
9058
9059           /* Attempt to merge the declarations.  This can fail, in
9060              the case of some illegal specialization declarations.  */
9061           if (!duplicate_decls (decl, old_decl))
9062             cp_error ("no `%#D' member function declared in class `%T'",
9063                       decl, ctype);
9064           return old_decl;
9065         }
9066     }
9067
9068   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9069     return NULL_TREE;
9070
9071   if (ctype == NULL_TREE || check)
9072     return decl;
9073
9074   if (virtualp)
9075     {
9076       DECL_VIRTUAL_P (decl) = 1;
9077       if (DECL_VINDEX (decl) == NULL_TREE)
9078         DECL_VINDEX (decl) = error_mark_node;
9079       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9080     }
9081
9082   return decl;
9083 }
9084
9085 static tree
9086 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9087      tree type;
9088      tree declarator;
9089      RID_BIT_TYPE *specbits_in;
9090      int initialized;
9091      int constp;
9092      tree in_namespace;
9093 {
9094   tree decl;
9095   RID_BIT_TYPE specbits;
9096
9097   specbits = *specbits_in;
9098
9099   if (TREE_CODE (type) == OFFSET_TYPE)
9100     {
9101       /* If you declare a static member so that it
9102          can be initialized, the code will reach here.  */
9103       tree basetype = TYPE_OFFSET_BASETYPE (type);
9104       type = TREE_TYPE (type);
9105       decl = build_lang_decl (VAR_DECL, declarator, type);
9106       DECL_CONTEXT (decl) = basetype;
9107       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9108          templates.  */
9109       if (!uses_template_parms (decl))
9110         {
9111           if (flag_new_abi)
9112             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9113           else
9114             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9115                                                             declarator);
9116         }
9117     }
9118   else
9119     {
9120       tree context;
9121
9122       if (in_namespace)
9123         context = in_namespace;
9124       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9125         context = current_namespace;
9126       else
9127         context = NULL_TREE;
9128
9129       if (processing_template_decl && context)
9130         /* For global variables, declared in a template, we need the
9131            full lang_decl.  */
9132         decl = build_lang_decl (VAR_DECL, declarator, type);
9133       else
9134         decl = build_decl (VAR_DECL, declarator, type);
9135
9136       if (context)
9137         set_decl_namespace (decl, context, 0);
9138
9139       context = DECL_CONTEXT (decl);
9140       if (declarator && context && current_lang_name != lang_name_c)
9141         {
9142           if (flag_new_abi)
9143             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9144           else
9145             DECL_ASSEMBLER_NAME (decl)
9146               = build_static_name (context, declarator);
9147         }
9148     }
9149
9150   if (in_namespace)
9151     set_decl_namespace (decl, in_namespace, 0);
9152
9153   if (RIDBIT_SETP (RID_EXTERN, specbits))
9154     {
9155       DECL_THIS_EXTERN (decl) = 1;
9156       DECL_EXTERNAL (decl) = !initialized;
9157     }
9158
9159   /* In class context, static means one per class,
9160      public access, and static storage.  */
9161   if (DECL_CLASS_SCOPE_P (decl))
9162     {
9163       TREE_PUBLIC (decl) = 1;
9164       TREE_STATIC (decl) = 1;
9165       DECL_EXTERNAL (decl) = 0;
9166     }
9167   /* At top level, either `static' or no s.c. makes a definition
9168      (perhaps tentative), and absence of `static' makes it public.  */
9169   else if (toplevel_bindings_p ())
9170     {
9171       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9172                             && (DECL_THIS_EXTERN (decl) || ! constp));
9173       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9174     }
9175   /* Not at top level, only `static' makes a static definition.  */
9176   else
9177     {
9178       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9179       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9180     }
9181
9182   if (TREE_PUBLIC (decl))
9183     {
9184       /* [basic.link]: A name with no linkage (notably, the name of a class
9185          or enumeration declared in a local scope) shall not be used to
9186          declare an entity with linkage.
9187
9188          Only check this for public decls for now.  */
9189       tree t = no_linkage_check (TREE_TYPE (decl));
9190       if (t)
9191         {
9192           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9193             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9194           else
9195             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9196                         decl, t);
9197         }
9198     }
9199
9200   return decl;
9201 }
9202
9203 /* Create and return a canonical pointer to member function type, for
9204    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9205
9206 tree
9207 build_ptrmemfunc_type (type)
9208      tree type;
9209 {
9210   tree fields[4];
9211   tree t;
9212   tree u;
9213   tree unqualified_variant = NULL_TREE;
9214
9215   if (type == error_mark_node)
9216     return type;
9217
9218   /* If a canonical type already exists for this type, use it.  We use
9219      this method instead of type_hash_canon, because it only does a
9220      simple equality check on the list of field members.  */
9221
9222   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9223     return t;
9224
9225   /* Make sure that we always have the unqualified pointer-to-member
9226      type first.  */
9227   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9228     unqualified_variant
9229       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9230
9231   t = make_aggr_type (RECORD_TYPE);
9232   /* Let the front-end know this is a pointer to member function...  */
9233   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9234   /* ... and not really an aggregate.  */
9235   SET_IS_AGGR_TYPE (t, 0);
9236
9237   if (!flag_new_abi)
9238     {
9239       u = make_aggr_type (UNION_TYPE);
9240       SET_IS_AGGR_TYPE (u, 0);
9241       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9242       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9243                               delta_type_node);
9244       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9245       TYPE_NAME (u) = NULL_TREE;
9246
9247       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9248                               delta_type_node);
9249       fields[1] = build_decl (FIELD_DECL, index_identifier,
9250                               delta_type_node);
9251       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9252       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9253     }
9254   else
9255     {
9256       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9257       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9258                               delta_type_node);
9259       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9260     }
9261
9262   /* Zap out the name so that the back-end will give us the debugging
9263      information for this anonymous RECORD_TYPE.  */
9264   TYPE_NAME (t) = NULL_TREE;
9265
9266   /* If this is not the unqualified form of this pointer-to-member
9267      type, set the TYPE_MAIN_VARIANT for this type to be the
9268      unqualified type.  Since they are actually RECORD_TYPEs that are
9269      not variants of each other, we must do this manually.  */
9270   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9271     {
9272       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9273       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9274       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9275       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9276     }
9277
9278   /* Cache this pointer-to-member type so that we can find it again
9279      later.  */
9280   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9281
9282   /* Seems to be wanted.  */
9283   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9284
9285   return t;
9286 }
9287
9288 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9289    Check to see that the definition is valid.  Issue appropriate error
9290    messages.  Return 1 if the definition is particularly bad, or 0
9291    otherwise.  */
9292
9293 int
9294 check_static_variable_definition (decl, type)
9295      tree decl;
9296      tree type;
9297 {
9298   /* Motion 10 at San Diego: If a static const integral data member is
9299      initialized with an integral constant expression, the initializer
9300      may appear either in the declaration (within the class), or in
9301      the definition, but not both.  If it appears in the class, the
9302      member is a member constant.  The file-scope definition is always
9303      required.  */
9304   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9305     {
9306       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9307                 type);
9308       /* If we just return the declaration, crashes will sometimes
9309          occur.  We therefore return void_type_node, as if this was a
9310          friend declaration, to cause callers to completely ignore
9311          this declaration.  */
9312       return 1;
9313     }
9314   else if (!CP_TYPE_CONST_P (type))
9315     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9316               decl);
9317   else if (pedantic && !INTEGRAL_TYPE_P (type))
9318     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9319
9320   return 0;
9321 }
9322
9323 /* Given the SIZE (i.e., number of elements) in an array, compute an
9324    appropriate index type for the array.  If non-NULL, NAME is the
9325    name of the thing being declared.  */
9326
9327 tree
9328 compute_array_index_type (name, size)
9329      tree name;
9330      tree size;
9331 {
9332   tree itype;
9333
9334   /* The size might be the result of a cast. */
9335   STRIP_TYPE_NOPS (size);
9336
9337   /* It might be a const variable or enumeration constant.  */
9338   size = decl_constant_value (size);
9339
9340   /* If this involves a template parameter, it will be a constant at
9341      instantiation time, but we don't know what the value is yet.
9342      Even if no template parameters are involved, we may an expression
9343      that is not a constant; we don't even simplify `1 + 2' when
9344      processing a template.  */
9345   if (processing_template_decl)
9346     {
9347       /* Resolve a qualified reference to an enumerator or static
9348          const data member of ours.  */
9349       if (TREE_CODE (size) == SCOPE_REF
9350           && TREE_OPERAND (size, 0) == current_class_type)
9351         {
9352           tree t = lookup_field (current_class_type,
9353                                  TREE_OPERAND (size, 1), 0, 0);
9354           if (t)
9355             size = t;
9356         }
9357
9358       return build_index_type (build_min (MINUS_EXPR, sizetype,
9359                                           size, integer_one_node));
9360     }
9361
9362   /* The array bound must be an integer type.  */
9363   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9364       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9365       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9366     {
9367       if (name)
9368         cp_error ("size of array `%D' has non-integer type", name);
9369       else
9370         cp_error ("size of array has non-integer type");
9371       size = integer_one_node;
9372     }
9373
9374   /* Normally, the array-bound will be a constant.  */
9375   if (TREE_CODE (size) == INTEGER_CST)
9376     {
9377       /* Check to see if the array bound overflowed.  Make that an
9378          error, no matter how generous we're being.  */
9379       int old_flag_pedantic_errors = flag_pedantic_errors;
9380       int old_pedantic = pedantic;
9381       pedantic = flag_pedantic_errors = 1;
9382       constant_expression_warning (size);
9383       pedantic = old_pedantic;
9384       flag_pedantic_errors = old_flag_pedantic_errors;
9385
9386       /* An array must have a positive number of elements.  */
9387       if (INT_CST_LT (size, integer_zero_node))
9388         {
9389           if (name)
9390             cp_error ("size of array `%D' is negative", name);
9391           else
9392             cp_error ("size of array is negative");
9393           size = integer_one_node;
9394         }
9395       /* Except that an extension we allow zero-sized arrays.  We
9396          always allow them in system headers because glibc uses
9397          them.  */
9398       else if (integer_zerop (size) && pedantic && !in_system_header)
9399         {
9400           if (name)
9401             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9402           else
9403             cp_pedwarn ("ISO C++ forbids zero-size array");
9404         }
9405     }
9406   else if (TREE_CONSTANT (size))
9407     {
9408       /* `(int) &fn' is not a valid array bound.  */
9409       if (name)
9410         cp_error ("size of array `%D' is not an integral constant-expression",
9411                   name);
9412       else
9413         cp_error ("size of array is not an integral constant-expression");
9414     }
9415
9416   /* Compute the index of the largest element in the array.  It is
9417      one less than the number of elements in the array.  */
9418   itype
9419     = fold (cp_build_binary_op (MINUS_EXPR,
9420                                 cp_convert (ssizetype, size),
9421                                 cp_convert (ssizetype,
9422                                             integer_one_node)));
9423
9424   /* Check for variable-sized arrays.  We allow such things as an
9425      extension, even though they are not allowed in ANSI/ISO C++.  */
9426   if (!TREE_CONSTANT (itype))
9427     {
9428       if (pedantic)
9429         {
9430           if (name)
9431             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9432                         name);
9433           else
9434             cp_pedwarn ("ISO C++ forbids variable-size array");
9435         }
9436
9437       /* Create a variable-sized array index type.  */
9438       itype = variable_size (itype);
9439     }
9440   /* Make sure that there was no overflow when creating to a signed
9441      index type.  (For example, on a 32-bit machine, an array with
9442      size 2^32 - 1 is too big.)  */
9443   else if (TREE_OVERFLOW (itype))
9444     {
9445       error ("overflow in array dimension");
9446       TREE_OVERFLOW (itype) = 0;
9447     }
9448
9449   /* Create and return the appropriate index type.  */
9450   return build_index_type (itype);
9451 }
9452
9453 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9454    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9455    with this type.  */
9456
9457 static tree
9458 create_array_type_for_decl (name, type, size)
9459      tree name;
9460      tree type;
9461      tree size;
9462 {
9463   tree itype = NULL_TREE;
9464   const char* error_msg;
9465
9466   /* If things have already gone awry, bail now.  */
9467   if (type == error_mark_node || size == error_mark_node)
9468     return error_mark_node;
9469
9470   /* Assume that everything will go OK.  */
9471   error_msg = NULL;
9472
9473   /* There are some types which cannot be array elements.  */
9474   switch (TREE_CODE (type))
9475     {
9476     case VOID_TYPE:
9477       error_msg = "array of void";
9478       break;
9479
9480     case FUNCTION_TYPE:
9481       error_msg = "array of functions";
9482       break;
9483
9484     case REFERENCE_TYPE:
9485       error_msg = "array of references";
9486       break;
9487
9488     case OFFSET_TYPE:
9489       error_msg = "array of data members";
9490       break;
9491
9492     case METHOD_TYPE:
9493       error_msg = "array of function members";
9494       break;
9495
9496     default:
9497       break;
9498     }
9499
9500   /* If something went wrong, issue an error-message and return.  */
9501   if (error_msg)
9502     {
9503       if (name)
9504         cp_error ("declaration of `%D' as %s", name, error_msg);
9505       else
9506         cp_error ("creating %s", error_msg);
9507
9508       return error_mark_node;
9509     }
9510
9511   /* [dcl.array]
9512
9513      The constant expressions that specify the bounds of the arrays
9514      can be omitted only for the first member of the sequence.  */
9515   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9516     {
9517       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9518                 name);
9519
9520       return error_mark_node;
9521     }
9522
9523   /* Figure out the index type for the array.  */
9524   if (size)
9525     itype = compute_array_index_type (name, size);
9526
9527   return build_cplus_array_type (type, itype);
9528 }
9529
9530 /* Check that it's OK to declare a function with the indicated TYPE.
9531    SFK indicates the kind of special function (if any) that this
9532    function is.  CTYPE is the class of which this function is a
9533    member.  OPTYPE is the type given in a conversion operator
9534    declaration.  Returns the actual return type of the function; that
9535    may be different than TYPE if an error occurs, or for certain
9536    special functions.  */
9537
9538 static tree
9539 check_special_function_return_type (sfk, type, ctype, optype)
9540      special_function_kind sfk;
9541      tree type;
9542      tree ctype;
9543      tree optype;
9544 {
9545   switch (sfk)
9546     {
9547     case sfk_constructor:
9548       if (type)
9549         cp_error ("return type specification for constructor invalid");
9550
9551       /* In the old ABI, we return `this'; in the new ABI we don't
9552          bother.  */
9553       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9554       break;
9555
9556     case sfk_destructor:
9557       if (type)
9558         cp_error ("return type specification for destructor invalid");
9559       type = void_type_node;
9560       break;
9561
9562     case sfk_conversion:
9563       if (type && !same_type_p (type, optype))
9564         cp_error ("operator `%T' declared to return `%T'", optype, type);
9565       else if (type)
9566         cp_pedwarn ("return type specified for `operator %T'",  optype);
9567       type = optype;
9568       break;
9569
9570     default:
9571       my_friendly_abort (20000408);
9572       break;
9573     }
9574
9575   return type;
9576 }
9577
9578 /* Given declspecs and a declarator,
9579    determine the name and type of the object declared
9580    and construct a ..._DECL node for it.
9581    (In one case we can return a ..._TYPE node instead.
9582     For invalid input we sometimes return 0.)
9583
9584    DECLSPECS is a chain of tree_list nodes whose value fields
9585     are the storage classes and type specifiers.
9586
9587    DECL_CONTEXT says which syntactic context this declaration is in:
9588      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9589      FUNCDEF for a function definition.  Like NORMAL but a few different
9590       error messages in each case.  Return value may be zero meaning
9591       this definition is too screwy to try to parse.
9592      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9593       handle member functions (which have FIELD context).
9594       Return value may be zero meaning this definition is too screwy to
9595       try to parse.
9596      PARM for a parameter declaration (either within a function prototype
9597       or before a function body).  Make a PARM_DECL, or return void_type_node.
9598      CATCHPARM for a parameter declaration before a catch clause.
9599      TYPENAME if for a typename (in a cast or sizeof).
9600       Don't make a DECL node; just return the ..._TYPE node.
9601      FIELD for a struct or union field; make a FIELD_DECL.
9602      BITFIELD for a field with specified width.
9603    INITIALIZED is 1 if the decl has an initializer.
9604
9605    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9606    normal attributes in TREE_PURPOSE, or NULL_TREE.
9607
9608    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9609    It may also be so in the PARM case, for a prototype where the
9610    argument type is specified but not the name.
9611
9612    This function is where the complicated C meanings of `static'
9613    and `extern' are interpreted.
9614
9615    For C++, if there is any monkey business to do, the function which
9616    calls this one must do it, i.e., prepending instance variables,
9617    renaming overloaded function names, etc.
9618
9619    Note that for this C++, it is an error to define a method within a class
9620    which does not belong to that class.
9621
9622    Except in the case where SCOPE_REFs are implicitly known (such as
9623    methods within a class being redundantly qualified),
9624    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9625    (class_name::decl_name).  The caller must also deal with this.
9626
9627    If a constructor or destructor is seen, and the context is FIELD,
9628    then the type gains the attribute TREE_HAS_x.  If such a declaration
9629    is erroneous, NULL_TREE is returned.
9630
9631    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9632    function, these are the qualifiers to give to the `this' pointer. We
9633    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9634
9635    May return void_type_node if the declarator turned out to be a friend.
9636    See grokfield for details.  */
9637
9638 tree
9639 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9640      tree declspecs;
9641      tree declarator;
9642      enum decl_context decl_context;
9643      int initialized;
9644      tree attrlist;
9645 {
9646   RID_BIT_TYPE specbits;
9647   int nclasses = 0;
9648   tree spec;
9649   tree type = NULL_TREE;
9650   int longlong = 0;
9651   int constp;
9652   int restrictp;
9653   int volatilep;
9654   int type_quals;
9655   int virtualp, explicitp, friendp, inlinep, staticp;
9656   int explicit_int = 0;
9657   int explicit_char = 0;
9658   int defaulted_int = 0;
9659   tree typedef_decl = NULL_TREE;
9660   const char *name;
9661   tree typedef_type = NULL_TREE;
9662   int funcdef_flag = 0;
9663   enum tree_code innermost_code = ERROR_MARK;
9664   int bitfield = 0;
9665 #if 0
9666   /* See the code below that used this.  */
9667   tree decl_machine_attr = NULL_TREE;
9668 #endif
9669   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9670      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9671   tree init = NULL_TREE;
9672
9673   /* Keep track of what sort of function is being processed
9674      so that we can warn about default return values, or explicit
9675      return values which do not match prescribed defaults.  */
9676   special_function_kind sfk = sfk_none;
9677
9678   tree dname = NULL_TREE;
9679   tree ctype = current_class_type;
9680   tree ctor_return_type = NULL_TREE;
9681   enum overload_flags flags = NO_SPECIAL;
9682   tree quals = NULL_TREE;
9683   tree raises = NULL_TREE;
9684   int template_count = 0;
9685   tree in_namespace = NULL_TREE;
9686   tree inner_attrs;
9687   int ignore_attrs;
9688
9689   RIDBIT_RESET_ALL (specbits);
9690   if (decl_context == FUNCDEF)
9691     funcdef_flag = 1, decl_context = NORMAL;
9692   else if (decl_context == MEMFUNCDEF)
9693     funcdef_flag = -1, decl_context = FIELD;
9694   else if (decl_context == BITFIELD)
9695     bitfield = 1, decl_context = FIELD;
9696
9697   /* Look inside a declarator for the name being declared
9698      and get it as a string, for an error message.  */
9699   {
9700     tree *next = &declarator;
9701     register tree decl;
9702     name = NULL;
9703
9704     while (next && *next)
9705       {
9706         decl = *next;
9707         switch (TREE_CODE (decl))
9708           {
9709           case TREE_LIST:
9710             /* For attributes.  */
9711             next = &TREE_VALUE (decl);
9712             break;
9713
9714           case COND_EXPR:
9715             ctype = NULL_TREE;
9716             next = &TREE_OPERAND (decl, 0);
9717             break;
9718
9719           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9720             {
9721               tree name = TREE_OPERAND (decl, 0);
9722               tree rename = NULL_TREE;
9723
9724               my_friendly_assert (flags == NO_SPECIAL, 152);
9725               flags = DTOR_FLAG;
9726               sfk = sfk_destructor;
9727               if (TREE_CODE (name) == TYPE_DECL)
9728                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9729               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9730               if (ctype == NULL_TREE)
9731                 {
9732                   if (current_class_type == NULL_TREE)
9733                     {
9734                       error ("destructors must be member functions");
9735                       flags = NO_SPECIAL;
9736                     }
9737                   else
9738                     {
9739                       tree t = constructor_name (current_class_name);
9740                       if (t != name)
9741                         rename = t;
9742                     }
9743                 }
9744               else
9745                 {
9746                   tree t = constructor_name (ctype);
9747                   if (t != name)
9748                     rename = t;
9749                 }
9750
9751               if (rename)
9752                 {
9753                   cp_error ("destructor `%T' must match class name `%T'",
9754                             name, rename);
9755                   TREE_OPERAND (decl, 0) = rename;
9756                 }
9757               next = &name;
9758             }
9759             break;
9760
9761           case ADDR_EXPR:       /* C++ reference declaration */
9762             /* Fall through. */
9763           case ARRAY_REF:
9764           case INDIRECT_REF:
9765             ctype = NULL_TREE;
9766             innermost_code = TREE_CODE (decl);
9767             next = &TREE_OPERAND (decl, 0);
9768             break;
9769
9770           case CALL_EXPR:
9771             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9772               {
9773                 /* This is actually a variable declaration using
9774                    constructor syntax.  We need to call start_decl and
9775                    cp_finish_decl so we can get the variable
9776                    initialized...  */
9777
9778                 tree attributes, prefix_attributes;
9779
9780                 *next = TREE_OPERAND (decl, 0);
9781                 init = CALL_DECLARATOR_PARMS (decl);
9782
9783                 if (attrlist)
9784                   {
9785                     attributes = TREE_PURPOSE (attrlist);
9786                     prefix_attributes = TREE_VALUE (attrlist);
9787                   }
9788                 else
9789                   {
9790                     attributes = NULL_TREE;
9791                     prefix_attributes = NULL_TREE;
9792                   }
9793
9794                 decl = start_decl (declarator, declspecs, 1,
9795                                    attributes, prefix_attributes);
9796                 decl_type_access_control (decl);
9797                 if (decl)
9798                   {
9799                     /* Look for __unused__ attribute */
9800                     if (TREE_USED (TREE_TYPE (decl)))
9801                       TREE_USED (decl) = 1;
9802                     finish_decl (decl, init, NULL_TREE);
9803                   }
9804                 else
9805                   cp_error ("invalid declarator");
9806                 return 0;
9807               }
9808             innermost_code = TREE_CODE (decl);
9809             if (decl_context == FIELD && ctype == NULL_TREE)
9810               ctype = current_class_type;
9811             if (ctype
9812                 && TREE_OPERAND (decl, 0)
9813                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9814                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9815                          == constructor_name_full (ctype))
9816                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9817                             == constructor_name (ctype)))))
9818               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9819             next = &TREE_OPERAND (decl, 0);
9820             decl = *next;
9821             if (ctype != NULL_TREE
9822                 && decl != NULL_TREE && flags != DTOR_FLAG
9823                 && decl == constructor_name (ctype))
9824               {
9825                 sfk = sfk_constructor;
9826                 ctor_return_type = ctype;
9827               }
9828             ctype = NULL_TREE;
9829             break;
9830
9831           case TEMPLATE_ID_EXPR:
9832               {
9833                 tree fns = TREE_OPERAND (decl, 0);
9834
9835                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9836                   fns = TREE_OPERAND (fns, 0);
9837
9838                 dname = fns;
9839                 if (TREE_CODE (dname) == COMPONENT_REF)
9840                   dname = TREE_OPERAND (dname, 1);
9841                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9842                   {
9843                     my_friendly_assert (is_overloaded_fn (dname),
9844                                         19990331);
9845                     dname = DECL_NAME (get_first_fn (dname));
9846                   }
9847               }
9848           /* Fall through. */
9849
9850           case IDENTIFIER_NODE:
9851             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9852               dname = decl;
9853
9854             next = 0;
9855
9856             if (C_IS_RESERVED_WORD (dname))
9857               {
9858                 cp_error ("declarator-id missing; using reserved word `%D'",
9859                           dname);
9860                 name = IDENTIFIER_POINTER (dname);
9861               }
9862             else if (!IDENTIFIER_TYPENAME_P (dname))
9863               name = IDENTIFIER_POINTER (dname);
9864             else
9865               {
9866                 my_friendly_assert (flags == NO_SPECIAL, 154);
9867                 flags = TYPENAME_FLAG;
9868                 ctor_return_type = TREE_TYPE (dname);
9869                 sfk = sfk_conversion;
9870                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9871                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9872                         == TYPE_DECL))
9873                   name = IDENTIFIER_POINTER (dname);
9874                 else
9875                   name = "<invalid operator>";
9876               }
9877             break;
9878
9879             /* C++ extension */
9880           case SCOPE_REF:
9881             {
9882               /* Perform error checking, and decide on a ctype.  */
9883               tree cname = TREE_OPERAND (decl, 0);
9884               if (cname == NULL_TREE)
9885                 ctype = NULL_TREE;
9886               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9887                 {
9888                   ctype = NULL_TREE;
9889                   in_namespace = TREE_OPERAND (decl, 0);
9890                   TREE_OPERAND (decl, 0) = NULL_TREE;
9891                 }
9892               else if (! is_aggr_type (cname, 1))
9893                 TREE_OPERAND (decl, 0) = NULL_TREE;
9894               /* Must test TREE_OPERAND (decl, 1), in case user gives
9895                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9896               else if (TREE_OPERAND (decl, 1)
9897                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9898                 ctype = cname;
9899               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9900                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9901                 {
9902                   cp_error ("`%T::%D' is not a valid declarator", cname,
9903                             TREE_OPERAND (decl, 1));
9904                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9905                             cname, TREE_OPERAND (decl, 1));
9906                   return void_type_node;
9907                 }
9908               else if (ctype == NULL_TREE)
9909                 ctype = cname;
9910               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9911                 TREE_OPERAND (decl, 0) = ctype;
9912               else
9913                 {
9914                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9915                     {
9916                       cp_error ("type `%T' is not derived from type `%T'",
9917                                 cname, ctype);
9918                       TREE_OPERAND (decl, 0) = NULL_TREE;
9919                     }
9920                   else
9921                     ctype = cname;
9922                 }
9923
9924               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9925                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9926                        == constructor_name_full (ctype))
9927                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9928                           == constructor_name (ctype))))
9929                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9930               next = &TREE_OPERAND (decl, 1);
9931               decl = *next;
9932               if (ctype)
9933                 {
9934                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9935                       && constructor_name (ctype) == decl)
9936                     {
9937                       sfk = sfk_constructor;
9938                       ctor_return_type = ctype;
9939                     }
9940                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9941                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9942                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9943                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9944                     {
9945                       sfk = sfk_destructor;
9946                       ctor_return_type = ctype;
9947                       flags = DTOR_FLAG;
9948                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9949                       next = &TREE_OPERAND (decl, 0);
9950                     }
9951                 }
9952             }
9953             break;
9954
9955           case ERROR_MARK:
9956             next = 0;
9957             break;
9958
9959           case TYPE_DECL:
9960             /* Parse error puts this typespec where
9961                a declarator should go.  */
9962             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9963             if (TREE_TYPE (decl) == current_class_type)
9964               cp_error ("  perhaps you want `%T' for a constructor",
9965                         current_class_name);
9966             dname = DECL_NAME (decl);
9967             name = IDENTIFIER_POINTER (dname);
9968
9969             /* Avoid giving two errors for this.  */
9970             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9971
9972             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9973             *next = dname;
9974             next = 0;
9975             break;
9976
9977           default:
9978             cp_compiler_error ("`%D' as declarator", decl);
9979             return 0; /* We used to do a 155 abort here.  */
9980           }
9981       }
9982   }
9983
9984   /* A function definition's declarator must have the form of
9985      a function declarator.  */
9986
9987   if (funcdef_flag && innermost_code != CALL_EXPR)
9988     return 0;
9989
9990   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9991       && innermost_code != CALL_EXPR
9992       && ! (ctype && declspecs == NULL_TREE))
9993     {
9994       cp_error ("declaration of `%D' as non-function", dname);
9995       return void_type_node;
9996     }
9997
9998   /* Anything declared one level down from the top level
9999      must be one of the parameters of a function
10000      (because the body is at least two levels down).  */
10001
10002   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10003      by not allowing C++ class definitions to specify their parameters
10004      with xdecls (must be spec.d in the parmlist).
10005
10006      Since we now wait to push a class scope until we are sure that
10007      we are in a legitimate method context, we must set oldcname
10008      explicitly (since current_class_name is not yet alive).
10009
10010      We also want to avoid calling this a PARM if it is in a namespace.  */
10011
10012   if (decl_context == NORMAL && !toplevel_bindings_p ())
10013     {
10014       struct binding_level *b = current_binding_level;
10015       current_binding_level = b->level_chain;
10016       if (current_binding_level != 0 && toplevel_bindings_p ())
10017         decl_context = PARM;
10018       current_binding_level = b;
10019     }
10020
10021   if (name == NULL)
10022     name = decl_context == PARM ? "parameter" : "type name";
10023
10024   /* Look through the decl specs and record which ones appear.
10025      Some typespecs are defined as built-in typenames.
10026      Others, the ones that are modifiers of other types,
10027      are represented by bits in SPECBITS: set the bits for
10028      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10029
10030      If there is a typedef name or a type, store the type in TYPE.
10031      This includes builtin typedefs such as `int'.
10032
10033      Set EXPLICIT_INT if the type is `int' or `char' and did not
10034      come from a user typedef.
10035
10036      Set LONGLONG if `long' is mentioned twice.
10037
10038      For C++, constructors and destructors have their own fast treatment.  */
10039
10040   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10041     {
10042       register int i;
10043       register tree id;
10044
10045       /* Certain parse errors slip through.  For example,
10046          `int class;' is not caught by the parser. Try
10047          weakly to recover here.  */
10048       if (TREE_CODE (spec) != TREE_LIST)
10049         return 0;
10050
10051       id = TREE_VALUE (spec);
10052
10053       if (TREE_CODE (id) == IDENTIFIER_NODE)
10054         {
10055           if (id == ridpointers[(int) RID_INT]
10056               || id == ridpointers[(int) RID_CHAR]
10057               || id == ridpointers[(int) RID_BOOL]
10058               || id == ridpointers[(int) RID_WCHAR])
10059             {
10060               if (type)
10061                 {
10062                   if (id == ridpointers[(int) RID_BOOL])
10063                     error ("`bool' is now a keyword");
10064                   else
10065                     cp_error ("extraneous `%T' ignored", id);
10066                 }
10067               else
10068                 {
10069                   if (id == ridpointers[(int) RID_INT])
10070                     explicit_int = 1;
10071                   else if (id == ridpointers[(int) RID_CHAR])
10072                     explicit_char = 1;
10073                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10074                 }
10075               goto found;
10076             }
10077           /* C++ aggregate types.  */
10078           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10079             {
10080               if (type)
10081                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10082               else
10083                 type = IDENTIFIER_TYPE_VALUE (id);
10084               goto found;
10085             }
10086
10087           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10088             {
10089               if (ridpointers[i] == id)
10090                 {
10091                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10092                     {
10093                       if (pedantic && ! in_system_header && warn_long_long)
10094                         pedwarn ("ISO C++ does not support `long long'");
10095                       if (longlong)
10096                         error ("`long long long' is too long for GCC");
10097                       else
10098                         longlong = 1;
10099                     }
10100                   else if (RIDBIT_SETP (i, specbits))
10101                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10102                   RIDBIT_SET (i, specbits);
10103                   goto found;
10104                 }
10105             }
10106         }
10107       /* C++ aggregate types.  */
10108       else if (TREE_CODE (id) == TYPE_DECL)
10109         {
10110           if (type)
10111             cp_error ("multiple declarations `%T' and `%T'", type,
10112                       TREE_TYPE (id));
10113           else
10114             {
10115               type = TREE_TYPE (id);
10116               TREE_VALUE (spec) = type;
10117             }
10118           goto found;
10119         }
10120       if (type)
10121         error ("two or more data types in declaration of `%s'", name);
10122       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10123         {
10124           register tree t = lookup_name (id, 1);
10125           if (!t || TREE_CODE (t) != TYPE_DECL)
10126             error ("`%s' fails to be a typedef or built in type",
10127                    IDENTIFIER_POINTER (id));
10128           else
10129             {
10130               type = TREE_TYPE (t);
10131 #if 0
10132               /* See the code below that used this.  */
10133               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10134 #endif
10135               typedef_decl = t;
10136             }
10137         }
10138       else if (id != error_mark_node)
10139         /* Can't change CLASS nodes into RECORD nodes here!  */
10140         type = id;
10141
10142     found: ;
10143     }
10144
10145   typedef_type = type;
10146
10147   /* No type at all: default to `int', and set DEFAULTED_INT
10148      because it was not a user-defined typedef.  */
10149
10150   if (type == NULL_TREE
10151       && (RIDBIT_SETP (RID_SIGNED, specbits)
10152           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10153           || RIDBIT_SETP (RID_LONG, specbits)
10154           || RIDBIT_SETP (RID_SHORT, specbits)))
10155     {
10156       /* These imply 'int'.  */
10157       type = integer_type_node;
10158       defaulted_int = 1;
10159     }
10160
10161   if (sfk != sfk_none)
10162     type = check_special_function_return_type (sfk, type,
10163                                                ctor_return_type,
10164                                                ctor_return_type);
10165   else if (type == NULL_TREE)
10166     {
10167       int is_main;
10168
10169       explicit_int = -1;
10170
10171           /* We handle `main' specially here, because 'main () { }' is so
10172              common.  With no options, it is allowed.  With -Wreturn-type,
10173              it is a warning.  It is only an error with -pedantic-errors.  */
10174       is_main = (funcdef_flag
10175                  && MAIN_NAME_P (dname)
10176                  && ctype == NULL_TREE
10177                  && in_namespace == NULL_TREE
10178                  && current_namespace == global_namespace);
10179
10180       if (in_system_header || flag_ms_extensions)
10181         /* Allow it, sigh.  */;
10182       else if (pedantic || ! is_main)
10183         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10184                     name);
10185       else if (warn_return_type)
10186         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10187                     name);
10188
10189       type = integer_type_node;
10190     }
10191
10192   ctype = NULL_TREE;
10193
10194   /* Now process the modifiers that were specified
10195      and check for invalid combinations.  */
10196
10197   /* Long double is a special combination.  */
10198
10199   if (RIDBIT_SETP (RID_LONG, specbits)
10200       && TYPE_MAIN_VARIANT (type) == double_type_node)
10201     {
10202       RIDBIT_RESET (RID_LONG, specbits);
10203       type = build_qualified_type (long_double_type_node,
10204                                    CP_TYPE_QUALS (type));
10205     }
10206
10207   /* Check all other uses of type modifiers.  */
10208
10209   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10210       || RIDBIT_SETP (RID_SIGNED, specbits)
10211       || RIDBIT_SETP (RID_LONG, specbits)
10212       || RIDBIT_SETP (RID_SHORT, specbits))
10213     {
10214       int ok = 0;
10215
10216       if (TREE_CODE (type) == REAL_TYPE)
10217         error ("short, signed or unsigned invalid for `%s'", name);
10218       else if (TREE_CODE (type) != INTEGER_TYPE)
10219         error ("long, short, signed or unsigned invalid for `%s'", name);
10220       else if (RIDBIT_SETP (RID_LONG, specbits)
10221                && RIDBIT_SETP (RID_SHORT, specbits))
10222         error ("long and short specified together for `%s'", name);
10223       else if ((RIDBIT_SETP (RID_LONG, specbits)
10224                 || RIDBIT_SETP (RID_SHORT, specbits))
10225                && explicit_char)
10226         error ("long or short specified with char for `%s'", name);
10227       else if ((RIDBIT_SETP (RID_LONG, specbits)
10228                 || RIDBIT_SETP (RID_SHORT, specbits))
10229                && TREE_CODE (type) == REAL_TYPE)
10230         error ("long or short specified with floating type for `%s'", name);
10231       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10232                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10233         error ("signed and unsigned given together for `%s'", name);
10234       else
10235         {
10236           ok = 1;
10237           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10238             {
10239               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10240                        name);
10241               if (flag_pedantic_errors)
10242                 ok = 0;
10243             }
10244         }
10245
10246       /* Discard the type modifiers if they are invalid.  */
10247       if (! ok)
10248         {
10249           RIDBIT_RESET (RID_UNSIGNED, specbits);
10250           RIDBIT_RESET (RID_SIGNED, specbits);
10251           RIDBIT_RESET (RID_LONG, specbits);
10252           RIDBIT_RESET (RID_SHORT, specbits);
10253           longlong = 0;
10254         }
10255     }
10256
10257   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10258       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10259     {
10260       error ("complex invalid for `%s'", name);
10261       RIDBIT_RESET (RID_COMPLEX, specbits);
10262     }
10263
10264   /* Decide whether an integer type is signed or not.
10265      Optionally treat bitfields as signed by default.  */
10266   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10267       /* [class.bit]
10268
10269          It is implementation-defined whether a plain (neither
10270          explicitly signed or unsigned) char, short, int, or long
10271          bit-field is signed or unsigned.
10272
10273          Naturally, we extend this to long long as well.  Note that
10274          this does not include wchar_t.  */
10275       || (bitfield && !flag_signed_bitfields
10276           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10277           /* A typedef for plain `int' without `signed' can be
10278              controlled just like plain `int', but a typedef for
10279              `signed int' cannot be so controlled.  */
10280           && !(typedef_decl
10281                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10282           && (TREE_CODE (type) == INTEGER_TYPE
10283               || TREE_CODE (type) == CHAR_TYPE)
10284           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10285     {
10286       if (longlong)
10287         type = long_long_unsigned_type_node;
10288       else if (RIDBIT_SETP (RID_LONG, specbits))
10289         type = long_unsigned_type_node;
10290       else if (RIDBIT_SETP (RID_SHORT, specbits))
10291         type = short_unsigned_type_node;
10292       else if (type == char_type_node)
10293         type = unsigned_char_type_node;
10294       else if (typedef_decl)
10295         type = unsigned_type (type);
10296       else
10297         type = unsigned_type_node;
10298     }
10299   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10300            && type == char_type_node)
10301     type = signed_char_type_node;
10302   else if (longlong)
10303     type = long_long_integer_type_node;
10304   else if (RIDBIT_SETP (RID_LONG, specbits))
10305     type = long_integer_type_node;
10306   else if (RIDBIT_SETP (RID_SHORT, specbits))
10307     type = short_integer_type_node;
10308
10309   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10310     {
10311       /* If we just have "complex", it is equivalent to
10312          "complex double", but if any modifiers at all are specified it is
10313          the complex form of TYPE.  E.g, "complex short" is
10314          "complex short int".  */
10315
10316       if (defaulted_int && ! longlong
10317           && ! (RIDBIT_SETP (RID_LONG, specbits)
10318                 || RIDBIT_SETP (RID_SHORT, specbits)
10319                 || RIDBIT_SETP (RID_SIGNED, specbits)
10320                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10321         type = complex_double_type_node;
10322       else if (type == integer_type_node)
10323         type = complex_integer_type_node;
10324       else if (type == float_type_node)
10325         type = complex_float_type_node;
10326       else if (type == double_type_node)
10327         type = complex_double_type_node;
10328       else if (type == long_double_type_node)
10329         type = complex_long_double_type_node;
10330       else
10331         type = build_complex_type (type);
10332     }
10333
10334   if (sfk == sfk_conversion
10335       && (RIDBIT_SETP (RID_CONST, specbits)
10336           || RIDBIT_SETP (RID_VOLATILE, specbits)
10337           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10338     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10339               ctor_return_type);
10340
10341   /* Set CONSTP if this declaration is `const', whether by
10342      explicit specification or via a typedef.
10343      Likewise for VOLATILEP.  */
10344
10345   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10346   restrictp =
10347     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10348   volatilep =
10349     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10350   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10351                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10352                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10353   type = cp_build_qualified_type (type, type_quals);
10354   staticp = 0;
10355   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10356   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10357   RIDBIT_RESET (RID_VIRTUAL, specbits);
10358   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10359   RIDBIT_RESET (RID_EXPLICIT, specbits);
10360
10361   if (RIDBIT_SETP (RID_STATIC, specbits))
10362     staticp = 1 + (decl_context == FIELD);
10363
10364   if (virtualp && staticp == 2)
10365     {
10366       cp_error ("member `%D' cannot be declared both virtual and static",
10367                 dname);
10368       staticp = 0;
10369     }
10370   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10371   RIDBIT_RESET (RID_FRIEND, specbits);
10372
10373   /* Warn if two storage classes are given. Default to `auto'.  */
10374
10375   if (RIDBIT_ANY_SET (specbits))
10376     {
10377       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10378       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10379       if (decl_context == PARM && nclasses > 0)
10380         error ("storage class specifiers invalid in parameter declarations");
10381       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10382         {
10383           if (decl_context == PARM)
10384             error ("typedef declaration invalid in parameter declaration");
10385           nclasses++;
10386         }
10387       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10388       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10389     }
10390
10391   /* Give error if `virtual' is used outside of class declaration.  */
10392   if (virtualp
10393       && (current_class_name == NULL_TREE || decl_context != FIELD))
10394     {
10395       error ("virtual outside class declaration");
10396       virtualp = 0;
10397     }
10398
10399   /* Static anonymous unions are dealt with here.  */
10400   if (staticp && decl_context == TYPENAME
10401       && TREE_CODE (declspecs) == TREE_LIST
10402       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10403     decl_context = FIELD;
10404
10405   /* Warn about storage classes that are invalid for certain
10406      kinds of declarations (parameters, typenames, etc.).  */
10407
10408   if (nclasses > 1)
10409     error ("multiple storage classes in declaration of `%s'", name);
10410   else if (decl_context != NORMAL && nclasses > 0)
10411     {
10412       if ((decl_context == PARM || decl_context == CATCHPARM)
10413           && (RIDBIT_SETP (RID_REGISTER, specbits)
10414               || RIDBIT_SETP (RID_AUTO, specbits)))
10415         ;
10416       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10417         ;
10418       else if (decl_context == FIELD
10419                /* C++ allows static class elements  */
10420                && RIDBIT_SETP (RID_STATIC, specbits))
10421         /* C++ also allows inlines and signed and unsigned elements,
10422            but in those cases we don't come in here.  */
10423         ;
10424       else
10425         {
10426           if (decl_context == FIELD)
10427             {
10428               tree tmp = NULL_TREE;
10429               register int op = 0;
10430
10431               if (declarator)
10432                 {
10433                   /* Avoid trying to get an operand off an identifier node.  */
10434                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10435                     tmp = declarator;
10436                   else
10437                     tmp = TREE_OPERAND (declarator, 0);
10438                   op = IDENTIFIER_OPNAME_P (tmp);
10439                   if (IDENTIFIER_TYPENAME_P (tmp))
10440                     {
10441                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10442                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10443                               == TYPE_DECL))
10444                         name = IDENTIFIER_POINTER (tmp);
10445                       else
10446                         name = "<invalid operator>";
10447                     }
10448                 }
10449               error ("storage class specified for %s `%s'",
10450                      op ? "member operator" : "field",
10451                      name);
10452             }
10453           else
10454             {
10455               if (decl_context == PARM || decl_context == CATCHPARM)
10456                 error ("storage class specified for parameter `%s'", name);
10457               else
10458                 error ("storage class specified for typename");
10459             }
10460           RIDBIT_RESET (RID_REGISTER, specbits);
10461           RIDBIT_RESET (RID_AUTO, specbits);
10462           RIDBIT_RESET (RID_EXTERN, specbits);
10463         }
10464     }
10465   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10466     {
10467       if (toplevel_bindings_p ())
10468         {
10469           /* It's common practice (and completely valid) to have a const
10470              be initialized and declared extern.  */
10471           if (!(type_quals & TYPE_QUAL_CONST))
10472             warning ("`%s' initialized and declared `extern'", name);
10473         }
10474       else
10475         error ("`%s' has both `extern' and initializer", name);
10476     }
10477   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10478            && ! toplevel_bindings_p ())
10479     error ("nested function `%s' declared `extern'", name);
10480   else if (toplevel_bindings_p ())
10481     {
10482       if (RIDBIT_SETP (RID_AUTO, specbits))
10483         error ("top-level declaration of `%s' specifies `auto'", name);
10484     }
10485
10486   if (nclasses > 0 && friendp)
10487     error ("storage class specifiers invalid in friend function declarations");
10488
10489   /* Now figure out the structure of the declarator proper.
10490      Descend through it, creating more complex types, until we reach
10491      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10492
10493   inner_attrs = NULL_TREE;
10494   ignore_attrs = 0;
10495
10496   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10497          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10498     {
10499       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10500          an INDIRECT_REF (for *...),
10501          a CALL_EXPR (for ...(...)),
10502          an identifier (for the name being declared)
10503          or a null pointer (for the place in an absolute declarator
10504          where the name was omitted).
10505          For the last two cases, we have just exited the loop.
10506
10507          For C++ it could also be
10508          a SCOPE_REF (for class :: ...).  In this case, we have converted
10509          sensible names to types, and those are the values we use to
10510          qualify the member name.
10511          an ADDR_EXPR (for &...),
10512          a BIT_NOT_EXPR (for destructors)
10513
10514          At this point, TYPE is the type of elements of an array,
10515          or for a function to return, or for a pointer to point to.
10516          After this sequence of ifs, TYPE is the type of the
10517          array or function or pointer, and DECLARATOR has had its
10518          outermost layer removed.  */
10519
10520       if (type == error_mark_node)
10521         {
10522           if (TREE_CODE (declarator) == SCOPE_REF)
10523             declarator = TREE_OPERAND (declarator, 1);
10524           else
10525             declarator = TREE_OPERAND (declarator, 0);
10526           continue;
10527         }
10528       if (quals != NULL_TREE
10529           && (declarator == NULL_TREE
10530               || TREE_CODE (declarator) != SCOPE_REF))
10531         {
10532           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10533             ctype = TYPE_METHOD_BASETYPE (type);
10534           if (ctype != NULL_TREE)
10535             {
10536               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10537               grok_method_quals (ctype, dummy, quals);
10538               type = TREE_TYPE (dummy);
10539               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10540               quals = NULL_TREE;
10541             }
10542         }
10543
10544       /* See the comment for the TREE_LIST case, below.  */
10545       if (ignore_attrs)
10546         ignore_attrs = 0;
10547       else if (inner_attrs)
10548         {
10549           decl_attributes (type, inner_attrs, NULL_TREE);
10550           inner_attrs = NULL_TREE;
10551         }
10552
10553       switch (TREE_CODE (declarator))
10554         {
10555         case TREE_LIST:
10556           {
10557             /* We encode a declarator with embedded attributes using
10558                a TREE_LIST.  The attributes apply to the declarator
10559                directly inside them, so we have to skip an iteration
10560                before applying them to the type.  If the declarator just
10561                inside is the declarator-id, we apply the attrs to the
10562                decl itself.  */
10563             inner_attrs = TREE_PURPOSE (declarator);
10564             ignore_attrs = 1;
10565             declarator = TREE_VALUE (declarator);
10566           }
10567           break;
10568
10569         case ARRAY_REF:
10570           {
10571             register tree size;
10572
10573             size = TREE_OPERAND (declarator, 1);
10574
10575             /* VC++ spells a zero-sized array with [].  */
10576             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10577                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10578               size = integer_zero_node;
10579
10580             declarator = TREE_OPERAND (declarator, 0);
10581
10582             type = create_array_type_for_decl (dname, type, size);
10583
10584             /* VLAs never work as fields. */
10585             if (decl_context == FIELD && !processing_template_decl
10586                 && TREE_CODE (type) == ARRAY_TYPE
10587                 && TYPE_DOMAIN (type) != NULL_TREE
10588                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10589               {
10590                 cp_error ("size of member `%D' is not constant", dname);
10591                 /* Proceed with arbitrary constant size, so that offset
10592                    computations don't get confused. */
10593                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10594                                                    integer_one_node);
10595               }
10596
10597             ctype = NULL_TREE;
10598           }
10599           break;
10600
10601         case CALL_EXPR:
10602           {
10603             tree arg_types;
10604             int funcdecl_p;
10605             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10606             tree inner_decl = TREE_OPERAND (declarator, 0);
10607
10608             /* Declaring a function type.
10609                Make sure we have a valid type for the function to return.  */
10610
10611             /* We now know that the TYPE_QUALS don't apply to the
10612                decl, but to its return type.  */
10613             type_quals = TYPE_UNQUALIFIED;
10614
10615             /* Warn about some types functions can't return.  */
10616
10617             if (TREE_CODE (type) == FUNCTION_TYPE)
10618               {
10619                 error ("`%s' declared as function returning a function", name);
10620                 type = integer_type_node;
10621               }
10622             if (TREE_CODE (type) == ARRAY_TYPE)
10623               {
10624                 error ("`%s' declared as function returning an array", name);
10625                 type = integer_type_node;
10626               }
10627
10628             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10629               inner_decl = TREE_OPERAND (inner_decl, 1);
10630
10631             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10632               inner_decl = dname;
10633
10634             /* Pick up type qualifiers which should be applied to `this'.  */
10635             quals = CALL_DECLARATOR_QUALS (declarator);
10636
10637             /* Pick up the exception specifications.  */
10638             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10639
10640             /* Say it's a definition only for the CALL_EXPR
10641                closest to the identifier.  */
10642             funcdecl_p
10643               = inner_decl
10644               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10645                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10646                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10647
10648             if (ctype == NULL_TREE
10649                 && decl_context == FIELD
10650                 && funcdecl_p
10651                 && (friendp == 0 || dname == current_class_name))
10652               ctype = current_class_type;
10653
10654             if (ctype && sfk == sfk_conversion)
10655               TYPE_HAS_CONVERSION (ctype) = 1;
10656             if (ctype && constructor_name (ctype) == dname)
10657               {
10658                 /* We are within a class's scope. If our declarator name
10659                    is the same as the class name, and we are defining
10660                    a function, then it is a constructor/destructor, and
10661                    therefore returns a void type.  */
10662
10663                 if (flags == DTOR_FLAG)
10664                   {
10665                     /* ISO C++ 12.4/2.  A destructor may not be
10666                        declared const or volatile.  A destructor may
10667                        not be static.  */
10668                     if (staticp == 2)
10669                       error ("destructor cannot be static member function");
10670                     if (quals)
10671                       {
10672                         cp_error ("destructors may not be `%s'",
10673                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10674                         quals = NULL_TREE;
10675                       }
10676                     if (decl_context == FIELD)
10677                       {
10678                         if (! member_function_or_else (ctype,
10679                                                        current_class_type,
10680                                                        flags))
10681                           return void_type_node;
10682                       }
10683                   }
10684                 else            /* It's a constructor.  */
10685                   {
10686                     if (explicitp == 1)
10687                       explicitp = 2;
10688                     /* ISO C++ 12.1.  A constructor may not be
10689                        declared const or volatile.  A constructor may
10690                        not be virtual.  A constructor may not be
10691                        static.  */
10692                     if (staticp == 2)
10693                       error ("constructor cannot be static member function");
10694                     if (virtualp)
10695                       {
10696                         pedwarn ("constructors cannot be declared virtual");
10697                         virtualp = 0;
10698                       }
10699                     if (quals)
10700                       {
10701                         cp_error ("constructors may not be `%s'",
10702                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10703                         quals = NULL_TREE;
10704                       }
10705                     {
10706                       RID_BIT_TYPE tmp_bits;
10707                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10708                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10709                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10710                       if (RIDBIT_ANY_SET (tmp_bits))
10711                         error ("return value type specifier for constructor ignored");
10712                     }
10713                     if (decl_context == FIELD)
10714                       {
10715                         if (! member_function_or_else (ctype,
10716                                                        current_class_type,
10717                                                        flags))
10718                           return void_type_node;
10719                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10720                         if (sfk != sfk_constructor)
10721                           return NULL_TREE;
10722                       }
10723                   }
10724                 if (decl_context == FIELD)
10725                   staticp = 0;
10726               }
10727             else if (friendp)
10728               {
10729                 if (initialized)
10730                   error ("can't initialize friend function `%s'", name);
10731                 if (virtualp)
10732                   {
10733                     /* Cannot be both friend and virtual.  */
10734                     error ("virtual functions cannot be friends");
10735                     RIDBIT_RESET (RID_FRIEND, specbits);
10736                     friendp = 0;
10737                   }
10738                 if (decl_context == NORMAL)
10739                   error ("friend declaration not in class definition");
10740                 if (current_function_decl && funcdef_flag)
10741                   cp_error ("can't define friend function `%s' in a local class definition",
10742                             name);
10743               }
10744
10745             /* Construct the function type and go to the next
10746                inner layer of declarator.  */
10747
10748             declarator = TREE_OPERAND (declarator, 0);
10749
10750             /* FIXME: This is where default args should be fully
10751                processed.  */
10752
10753             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10754
10755             if (declarator && flags == DTOR_FLAG)
10756               {
10757                 /* A destructor declared in the body of a class will
10758                    be represented as a BIT_NOT_EXPR.  But, we just
10759                    want the underlying IDENTIFIER.  */
10760                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10761                   declarator = TREE_OPERAND (declarator, 0);
10762
10763                 if (arg_types != void_list_node)
10764                   {
10765                     cp_error ("destructors may not have parameters");
10766                     arg_types = void_list_node;
10767                     last_function_parms = NULL_TREE;
10768                   }
10769               }
10770
10771             /* ANSI says that `const int foo ();'
10772                does not make the function foo const.  */
10773             type = build_function_type (type, arg_types);
10774
10775             {
10776               tree t;
10777               for (t = arg_types; t; t = TREE_CHAIN (t))
10778                 if (TREE_PURPOSE (t)
10779                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10780                   {
10781                     add_defarg_fn (type);
10782                     break;
10783                   }
10784             }
10785           }
10786           break;
10787
10788         case ADDR_EXPR:
10789         case INDIRECT_REF:
10790           /* Filter out pointers-to-references and references-to-references.
10791              We can get these if a TYPE_DECL is used.  */
10792
10793           if (TREE_CODE (type) == REFERENCE_TYPE)
10794             {
10795               error ("cannot declare %s to references",
10796                      TREE_CODE (declarator) == ADDR_EXPR
10797                      ? "references" : "pointers");
10798               declarator = TREE_OPERAND (declarator, 0);
10799               continue;
10800             }
10801
10802           if (TREE_CODE (type) == OFFSET_TYPE
10803               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10804                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10805             {
10806               cp_error ("cannot declare pointer to `%#T' member",
10807                         TREE_TYPE (type));
10808               type = TREE_TYPE (type);
10809             }
10810
10811           /* Merge any constancy or volatility into the target type
10812              for the pointer.  */
10813
10814           /* We now know that the TYPE_QUALS don't apply to the decl,
10815              but to the target of the pointer.  */
10816           type_quals = TYPE_UNQUALIFIED;
10817
10818           if (TREE_CODE (declarator) == ADDR_EXPR)
10819             {
10820               if (TREE_CODE (type) == VOID_TYPE)
10821                 error ("invalid type: `void &'");
10822               else
10823                 type = build_reference_type (type);
10824             }
10825           else if (TREE_CODE (type) == METHOD_TYPE)
10826             type = build_ptrmemfunc_type (build_pointer_type (type));
10827           else
10828             type = build_pointer_type (type);
10829
10830           /* Process a list of type modifier keywords (such as
10831              const or volatile) that were given inside the `*' or `&'.  */
10832
10833           if (TREE_TYPE (declarator))
10834             {
10835               register tree typemodlist;
10836               int erred = 0;
10837
10838               constp = 0;
10839               volatilep = 0;
10840               restrictp = 0;
10841               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10842                    typemodlist = TREE_CHAIN (typemodlist))
10843                 {
10844                   tree qualifier = TREE_VALUE (typemodlist);
10845
10846                   if (qualifier == ridpointers[(int) RID_CONST])
10847                     constp++;
10848                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10849                     volatilep++;
10850                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10851                     restrictp++;
10852                   else if (!erred)
10853                     {
10854                       erred = 1;
10855                       error ("invalid type modifier within pointer declarator");
10856                     }
10857                 }
10858               if (constp > 1)
10859                 pedwarn ("duplicate `const'");
10860               if (volatilep > 1)
10861                 pedwarn ("duplicate `volatile'");
10862               if (restrictp > 1)
10863                 pedwarn ("duplicate `restrict'");
10864
10865               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10866                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10867                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10868               if (TREE_CODE (declarator) == ADDR_EXPR
10869                   && (constp || volatilep))
10870                 {
10871                   if (constp)
10872                     pedwarn ("discarding `const' applied to a reference");
10873                   if (volatilep)
10874                     pedwarn ("discarding `volatile' applied to a reference");
10875                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10876                 }
10877               type = cp_build_qualified_type (type, type_quals);
10878             }
10879           declarator = TREE_OPERAND (declarator, 0);
10880           ctype = NULL_TREE;
10881           break;
10882
10883         case SCOPE_REF:
10884           {
10885             /* We have converted type names to NULL_TREE if the
10886                name was bogus, or to a _TYPE node, if not.
10887
10888                The variable CTYPE holds the type we will ultimately
10889                resolve to.  The code here just needs to build
10890                up appropriate member types.  */
10891             tree sname = TREE_OPERAND (declarator, 1);
10892             tree t;
10893
10894             /* Destructors can have their visibilities changed as well.  */
10895             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10896               sname = TREE_OPERAND (sname, 0);
10897
10898             if (TREE_COMPLEXITY (declarator) == 0)
10899               /* This needs to be here, in case we are called
10900                  multiple times.  */ ;
10901             else if (TREE_COMPLEXITY (declarator) == -1)
10902               /* Namespace member. */
10903               pop_decl_namespace ();
10904             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10905               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10906             else if (! IS_AGGR_TYPE_CODE
10907                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10908               ;
10909             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10910               {
10911                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10912                    that refer to ctype.  They couldn't be resolved earlier
10913                    because we hadn't pushed into the class yet.
10914                    Example: resolve 'B<T>::type' in
10915                    'B<typename B<T>::type> B<T>::f () { }'.  */
10916                 if (current_template_parms
10917                     && uses_template_parms (type)
10918                     && uses_template_parms (current_class_type))
10919                   {
10920                     tree args = current_template_args ();
10921                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10922                   }
10923
10924                 /* This pop_nested_class corresponds to the
10925                    push_nested_class used to push into class scope for
10926                    parsing the argument list of a function decl, in
10927                    qualified_id.  */
10928                 pop_nested_class ();
10929                 TREE_COMPLEXITY (declarator) = current_class_depth;
10930               }
10931             else
10932               my_friendly_abort (16);
10933
10934             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10935               {
10936                 /* We had a reference to a global decl, or
10937                    perhaps we were given a non-aggregate typedef,
10938                    in which case we cleared this out, and should just
10939                    keep going as though it wasn't there.  */
10940                 declarator = sname;
10941                 continue;
10942               }
10943             ctype = TREE_OPERAND (declarator, 0);
10944
10945             t = ctype;
10946             while (t != NULL_TREE && CLASS_TYPE_P (t))
10947               {
10948                 /* You're supposed to have one `template <...>'
10949                    for every template class, but you don't need one
10950                    for a full specialization.  For example:
10951
10952                      template <class T> struct S{};
10953                      template <> struct S<int> { void f(); };
10954                      void S<int>::f () {}
10955
10956                    is correct; there shouldn't be a `template <>' for
10957                    the definition of `S<int>::f'.  */
10958                 if (CLASSTYPE_TEMPLATE_INFO (t)
10959                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10960                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10961                   template_count += 1;
10962
10963                 t = TYPE_MAIN_DECL (t);
10964                 if (DECL_LANG_SPECIFIC (t))
10965                   t = DECL_CONTEXT (t);
10966                 else
10967                   t = NULL_TREE;
10968               }
10969
10970             if (sname == NULL_TREE)
10971               goto done_scoping;
10972
10973             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10974               {
10975                 /* This is the `standard' use of the scoping operator:
10976                    basetype :: member .  */
10977
10978                 if (ctype == current_class_type)
10979                   {
10980                     /* class A {
10981                          void A::f ();
10982                        };
10983
10984                        Is this ill-formed?  */
10985
10986                     if (pedantic)
10987                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10988                                   ctype, name);
10989                   }
10990                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10991                   {
10992                     if (current_class_type == NULL_TREE
10993                         || friendp)
10994                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10995                                                       TYPE_ARG_TYPES (type));
10996                     else
10997                       {
10998                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10999                                   ctype, name, current_class_type);
11000                         return void_type_node;
11001                       }
11002                   }
11003                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11004                          || COMPLETE_TYPE_P (complete_type (ctype)))
11005                   {
11006                     /* Have to move this code elsewhere in this function.
11007                        this code is used for i.e., typedef int A::M; M *pm;
11008
11009                        It is?  How? jason 10/2/94 */
11010
11011                     if (current_class_type)
11012                       {
11013                         cp_error ("cannot declare member `%T::%s' within `%T'",
11014                                   ctype, name, current_class_type);
11015                         return void_type_node;
11016                       }
11017                     type = build_offset_type (ctype, type);
11018                   }
11019                 else if (uses_template_parms (ctype))
11020                   {
11021                     if (TREE_CODE (type) == FUNCTION_TYPE)
11022                       type
11023                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11024                                                    TYPE_ARG_TYPES (type));
11025                   }
11026                 else
11027                   {
11028                     cp_error ("structure `%T' not yet defined", ctype);
11029                     return error_mark_node;
11030                   }
11031
11032                 declarator = sname;
11033               }
11034             else if (TREE_CODE (sname) == SCOPE_REF)
11035               my_friendly_abort (17);
11036             else
11037               {
11038               done_scoping:
11039                 declarator = TREE_OPERAND (declarator, 1);
11040                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11041                   /* In this case, we will deal with it later.  */
11042                   ;
11043                 else
11044                   {
11045                     if (TREE_CODE (type) == FUNCTION_TYPE)
11046                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11047                                                       TYPE_ARG_TYPES (type));
11048                     else
11049                       type = build_offset_type (ctype, type);
11050                   }
11051               }
11052           }
11053           break;
11054
11055         case BIT_NOT_EXPR:
11056           declarator = TREE_OPERAND (declarator, 0);
11057           break;
11058
11059         case RECORD_TYPE:
11060         case UNION_TYPE:
11061         case ENUMERAL_TYPE:
11062           declarator = NULL_TREE;
11063           break;
11064
11065         case ERROR_MARK:
11066           declarator = NULL_TREE;
11067           break;
11068
11069         default:
11070           my_friendly_abort (158);
11071         }
11072     }
11073
11074   /* See the comment for the TREE_LIST case, above.  */
11075   if (inner_attrs)
11076     {
11077       if (! ignore_attrs)
11078         decl_attributes (type, inner_attrs, NULL_TREE);
11079       else if (attrlist)
11080         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11081       else
11082         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11083     }
11084
11085   /* Now TYPE has the actual type.  */
11086
11087   if (explicitp == 1 || (explicitp && friendp))
11088     {
11089       /* [dcl.fct.spec] The explicit specifier shall only be used in
11090          declarations of constructors within a class definition.  */
11091       error ("only declarations of constructors can be `explicit'");
11092       explicitp = 0;
11093     }
11094
11095   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11096     {
11097       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11098         {
11099           error ("non-member `%s' cannot be declared `mutable'", name);
11100           RIDBIT_RESET (RID_MUTABLE, specbits);
11101         }
11102       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11103         {
11104           error ("non-object member `%s' cannot be declared `mutable'", name);
11105           RIDBIT_RESET (RID_MUTABLE, specbits);
11106         }
11107       else if (TREE_CODE (type) == FUNCTION_TYPE
11108                || TREE_CODE (type) == METHOD_TYPE)
11109         {
11110           error ("function `%s' cannot be declared `mutable'", name);
11111           RIDBIT_RESET (RID_MUTABLE, specbits);
11112         }
11113       else if (staticp)
11114         {
11115           error ("static `%s' cannot be declared `mutable'", name);
11116           RIDBIT_RESET (RID_MUTABLE, specbits);
11117         }
11118       else if (type_quals & TYPE_QUAL_CONST)
11119         {
11120           error ("const `%s' cannot be declared `mutable'", name);
11121           RIDBIT_RESET (RID_MUTABLE, specbits);
11122         }
11123     }
11124
11125   if (declarator == NULL_TREE
11126       || TREE_CODE (declarator) == IDENTIFIER_NODE
11127       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11128           && (TREE_CODE (type) == FUNCTION_TYPE
11129               || TREE_CODE (type) == METHOD_TYPE)))
11130     /* OK */;
11131   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11132     {
11133       cp_error ("template-id `%D' used as a declarator", declarator);
11134       declarator = dname;
11135     }
11136   else
11137     /* Unexpected declarator format.  */
11138     my_friendly_abort (990210);
11139
11140   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11141
11142   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11143     {
11144       tree decl;
11145
11146       /* Note that the grammar rejects storage classes
11147          in typenames, fields or parameters.  */
11148       if (current_lang_name == lang_name_java)
11149         TYPE_FOR_JAVA (type) = 1;
11150
11151       if (decl_context == FIELD)
11152         {
11153           if (declarator == constructor_name (current_class_type))
11154             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11155                         declarator);
11156           decl = build_lang_decl (TYPE_DECL, declarator, type);
11157         }
11158       else
11159         decl = build_decl (TYPE_DECL, declarator, type);
11160
11161       /* If the user declares "typedef struct {...} foo" then the
11162          struct will have an anonymous name.  Fill that name in now.
11163          Nothing can refer to it, so nothing needs know about the name
11164          change.  */
11165       if (type != error_mark_node
11166           && declarator
11167           && TYPE_NAME (type)
11168           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11169           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11170           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11171         {
11172           tree oldname = TYPE_NAME (type);
11173           tree t;
11174
11175           /* Replace the anonymous name with the real name everywhere.  */
11176           lookup_tag_reverse (type, declarator);
11177           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11178             if (TYPE_NAME (t) == oldname)
11179               TYPE_NAME (t) = decl;
11180
11181           if (TYPE_LANG_SPECIFIC (type))
11182             TYPE_WAS_ANONYMOUS (type) = 1;
11183
11184           /* If this is a typedef within a template class, the nested
11185              type is a (non-primary) template.  The name for the
11186              template needs updating as well.  */
11187           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11188             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11189               = TYPE_IDENTIFIER (type);
11190
11191           if (flag_new_abi)
11192             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11193           else
11194             {
11195               /* XXX Temporarily set the scope.
11196                  When returning, start_decl expects it as NULL_TREE,
11197                  and will then then set it using pushdecl. */
11198               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11199               if (current_class_type)
11200                 DECL_CONTEXT (decl) = current_class_type;
11201               else
11202                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11203
11204               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11205               DECL_ASSEMBLER_NAME (decl)
11206                 = get_identifier (build_overload_name (type, 1, 1));
11207               DECL_CONTEXT (decl) = NULL_TREE;
11208             }
11209
11210           /* FIXME remangle member functions; member functions of a
11211              type with external linkage have external linkage.  */
11212         }
11213
11214       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11215         {
11216           cp_error_at ("typedef name may not be class-qualified", decl);
11217           return NULL_TREE;
11218         }
11219       else if (quals)
11220         {
11221           if (ctype == NULL_TREE)
11222             {
11223               if (TREE_CODE (type) != METHOD_TYPE)
11224                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11225               else
11226                 ctype = TYPE_METHOD_BASETYPE (type);
11227             }
11228           if (ctype != NULL_TREE)
11229             grok_method_quals (ctype, decl, quals);
11230         }
11231
11232       if (RIDBIT_SETP (RID_SIGNED, specbits)
11233           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11234         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11235
11236       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11237                       inlinep, friendp, raises != NULL_TREE);
11238
11239       if (initialized)
11240         error ("typedef declaration includes an initializer");
11241
11242       return decl;
11243     }
11244
11245   /* Detect the case of an array type of unspecified size
11246      which came, as such, direct from a typedef name.
11247      We must copy the type, so that each identifier gets
11248      a distinct type, so that each identifier's size can be
11249      controlled separately by its own initializer.  */
11250
11251   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11252       && TYPE_DOMAIN (type) == NULL_TREE)
11253     {
11254       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11255     }
11256
11257   /* If this is a type name (such as, in a cast or sizeof),
11258      compute the type and return it now.  */
11259
11260   if (decl_context == TYPENAME)
11261     {
11262       /* Note that the grammar rejects storage classes
11263          in typenames, fields or parameters.  */
11264       if (type_quals != TYPE_UNQUALIFIED)
11265         type_quals = TYPE_UNQUALIFIED;
11266
11267       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11268       if (friendp)
11269         {
11270           if (type_quals != TYPE_UNQUALIFIED)
11271             {
11272               cp_error ("type qualifiers specified for friend class declaration");
11273               type_quals = TYPE_UNQUALIFIED;
11274             }
11275           if (inlinep)
11276             {
11277               cp_error ("`inline' specified for friend class declaration");
11278               inlinep = 0;
11279             }
11280
11281           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11282              But don't allow implicit typenames.  */
11283           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11284                                 || IMPLICIT_TYPENAME_P (type)))
11285             {
11286               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11287                 cp_pedwarn ("template parameters cannot be friends");
11288               else if (TREE_CODE (type) == TYPENAME_TYPE)
11289                 cp_pedwarn ("\
11290 friend declaration requires class-key, i.e. `friend class %T::%T'",
11291                             constructor_name (current_class_type),
11292                             TYPE_IDENTIFIER (type));
11293               else
11294                 cp_pedwarn ("\
11295 friend declaration requires class-key, i.e. `friend %#T'",
11296                             type);
11297             }
11298
11299           /* Only try to do this stuff if we didn't already give up.  */
11300           if (type != integer_type_node)
11301             {
11302               /* A friendly class?  */
11303               if (current_class_type)
11304                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11305               else
11306                 cp_error ("trying to make class `%T' a friend of global scope",
11307                           type);
11308               type = void_type_node;
11309             }
11310         }
11311       else if (quals)
11312         {
11313           if (ctype == NULL_TREE)
11314             {
11315               if (TREE_CODE (type) != METHOD_TYPE)
11316                 cp_error ("invalid qualifiers on non-member function type");
11317               else
11318                 ctype = TYPE_METHOD_BASETYPE (type);
11319             }
11320           if (ctype)
11321             {
11322               tree dummy = build_decl (TYPE_DECL, declarator, type);
11323               grok_method_quals (ctype, dummy, quals);
11324               type = TREE_TYPE (dummy);
11325             }
11326         }
11327
11328       return type;
11329     }
11330   else if (declarator == NULL_TREE && decl_context != PARM
11331            && decl_context != CATCHPARM
11332            && TREE_CODE (type) != UNION_TYPE
11333            && ! bitfield)
11334     {
11335       cp_error ("abstract declarator `%T' used as declaration", type);
11336       declarator = make_anon_name ();
11337     }
11338
11339   /* `void' at top level (not within pointer)
11340      is allowed only in typedefs or type names.
11341      We don't complain about parms either, but that is because
11342      a better error message can be made later.  */
11343
11344   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11345     {
11346       if (! declarator)
11347         error ("unnamed variable or field declared void");
11348       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11349         {
11350           if (IDENTIFIER_OPNAME_P (declarator))
11351             my_friendly_abort (356);
11352           else
11353             error ("variable or field `%s' declared void", name);
11354         }
11355       else
11356         error ("variable or field declared void");
11357       type = integer_type_node;
11358     }
11359
11360   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11361      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11362
11363   if (decl_context == PARM || decl_context == CATCHPARM)
11364     {
11365       if (ctype || in_namespace)
11366         error ("cannot use `::' in parameter declaration");
11367
11368       /* A parameter declared as an array of T is really a pointer to T.
11369          One declared as a function is really a pointer to a function.
11370          One declared as a member is really a pointer to member.  */
11371
11372       if (TREE_CODE (type) == ARRAY_TYPE)
11373         {
11374           /* Transfer const-ness of array into that of type pointed to.  */
11375           type = build_pointer_type (TREE_TYPE (type));
11376           type_quals = TYPE_UNQUALIFIED;
11377         }
11378       else if (TREE_CODE (type) == FUNCTION_TYPE)
11379         type = build_pointer_type (type);
11380       else if (TREE_CODE (type) == OFFSET_TYPE)
11381         type = build_pointer_type (type);
11382       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11383         {
11384           error ("declaration of `%s' as void", name);
11385           return NULL_TREE;
11386         }
11387     }
11388
11389   {
11390     register tree decl;
11391
11392     if (decl_context == PARM)
11393       {
11394         decl = build_decl (PARM_DECL, declarator, type);
11395
11396         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11397                         inlinep, friendp, raises != NULL_TREE);
11398
11399         /* Compute the type actually passed in the parmlist,
11400            for the case where there is no prototype.
11401            (For example, shorts and chars are passed as ints.)
11402            When there is a prototype, this is overridden later.  */
11403
11404         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11405       }
11406     else if (decl_context == FIELD)
11407       {
11408         if (type == error_mark_node)
11409           {
11410             /* Happens when declaring arrays of sizes which
11411                are error_mark_node, for example.  */
11412             decl = NULL_TREE;
11413           }
11414         else if (in_namespace && !friendp)
11415           {
11416             /* Something like struct S { int N::j; };  */
11417             cp_error ("invalid use of `::'");
11418             decl = NULL_TREE;
11419           }
11420         else if (TREE_CODE (type) == FUNCTION_TYPE)
11421           {
11422             int publicp = 0;
11423             tree function_context;
11424
11425             /* We catch the others as conflicts with the builtin
11426                typedefs.  */
11427             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11428               {
11429                 cp_error ("function `%D' cannot be declared friend",
11430                           declarator);
11431                 friendp = 0;
11432               }
11433
11434             if (friendp == 0)
11435               {
11436                 if (ctype == NULL_TREE)
11437                   ctype = current_class_type;
11438
11439                 if (ctype == NULL_TREE)
11440                   {
11441                     cp_error ("can't make `%D' into a method -- not in a class",
11442                               declarator);
11443                     return void_type_node;
11444                   }
11445
11446                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11447                    ARM 9.5 */
11448                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11449                   {
11450                     cp_error ("function `%D' declared virtual inside a union",
11451                               declarator);
11452                     return void_type_node;
11453                   }
11454
11455                 if (declarator == ansi_opname (NEW_EXPR)
11456                     || declarator == ansi_opname (VEC_NEW_EXPR)
11457                     || declarator == ansi_opname (DELETE_EXPR)
11458                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11459                   {
11460                     if (virtualp)
11461                       {
11462                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11463                                   declarator);
11464                         virtualp = 0;
11465                       }
11466                   }
11467                 else if (staticp < 2)
11468                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11469                                                   TYPE_ARG_TYPES (type));
11470               }
11471
11472             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11473             function_context = (ctype != NULL_TREE) ?
11474               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11475             publicp = (! friendp || ! staticp)
11476               && function_context == NULL_TREE;
11477             decl = grokfndecl (ctype, type,
11478                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11479                                ? declarator : dname,
11480                                declarator,
11481                                virtualp, flags, quals, raises,
11482                                friendp ? -1 : 0, friendp, publicp, inlinep,
11483                                funcdef_flag, template_count, in_namespace);
11484             if (decl == NULL_TREE)
11485               return decl;
11486 #if 0
11487             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11488             /* The decl and setting of decl_machine_attr is also turned off.  */
11489             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11490 #endif
11491
11492             /* [class.conv.ctor]
11493
11494                A constructor declared without the function-specifier
11495                explicit that can be called with a single parameter
11496                specifies a conversion from the type of its first
11497                parameter to the type of its class.  Such a constructor
11498                is called a converting constructor.  */
11499             if (explicitp == 2)
11500               DECL_NONCONVERTING_P (decl) = 1;
11501             else if (DECL_CONSTRUCTOR_P (decl))
11502               {
11503                 /* The constructor can be called with exactly one
11504                    parameter if there is at least one parameter, and
11505                    any subsequent parameters have default arguments.
11506                    We don't look at the first parameter, which is
11507                    really just the `this' parameter for the new
11508                    object.  */
11509                 tree arg_types =
11510                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11511
11512                 /* Skip the `in_chrg' argument too, if present.  */
11513                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11514                   arg_types = TREE_CHAIN (arg_types);
11515
11516                 if (arg_types == void_list_node
11517                     || (arg_types
11518                         && TREE_CHAIN (arg_types)
11519                         && TREE_CHAIN (arg_types) != void_list_node
11520                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11521                   DECL_NONCONVERTING_P (decl) = 1;
11522               }
11523           }
11524         else if (TREE_CODE (type) == METHOD_TYPE)
11525           {
11526             /* We only get here for friend declarations of
11527                members of other classes.  */
11528             /* All method decls are public, so tell grokfndecl to set
11529                TREE_PUBLIC, also.  */
11530             decl = grokfndecl (ctype, type, declarator, declarator,
11531                                virtualp, flags, quals, raises,
11532                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11533                                template_count, in_namespace);
11534             if (decl == NULL_TREE)
11535               return NULL_TREE;
11536           }
11537         else if (!staticp && ! processing_template_decl
11538                  && !COMPLETE_TYPE_P (complete_type (type))
11539                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11540           {
11541             if (declarator)
11542               cp_error ("field `%D' has incomplete type", declarator);
11543             else
11544               cp_error ("name `%T' has incomplete type", type);
11545
11546             /* If we're instantiating a template, tell them which
11547                instantiation made the field's type be incomplete.  */
11548             if (current_class_type
11549                 && TYPE_NAME (current_class_type)
11550                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11551                 && declspecs && TREE_VALUE (declspecs)
11552                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11553               cp_error ("  in instantiation of template `%T'",
11554                         current_class_type);
11555
11556             type = error_mark_node;
11557             decl = NULL_TREE;
11558           }
11559         else
11560           {
11561             if (friendp)
11562               {
11563                 error ("`%s' is neither function nor member function; cannot be declared friend",
11564                        IDENTIFIER_POINTER (declarator));
11565                 friendp = 0;
11566               }
11567             decl = NULL_TREE;
11568           }
11569
11570         if (friendp)
11571           {
11572             /* Friends are treated specially.  */
11573             if (ctype == current_class_type)
11574               warning ("member functions are implicitly friends of their class");
11575             else
11576               {
11577                 tree t = NULL_TREE;
11578                 if (decl && DECL_NAME (decl))
11579                   {
11580                     if (template_class_depth (current_class_type) == 0)
11581                       {
11582                         decl
11583                           = check_explicit_specialization
11584                           (declarator, decl,
11585                            template_count, 2 * (funcdef_flag != 0) + 4);
11586                         if (decl == error_mark_node)
11587                           return error_mark_node;
11588                       }
11589
11590                     t = do_friend (ctype, declarator, decl,
11591                                    last_function_parms, attrlist, flags, quals,
11592                                    funcdef_flag);
11593                   }
11594                 if (t && funcdef_flag)
11595                   return t;
11596
11597                 return void_type_node;
11598               }
11599           }
11600
11601         /* Structure field.  It may not be a function, except for C++ */
11602
11603         if (decl == NULL_TREE)
11604           {
11605             if (initialized)
11606               {
11607                 if (!staticp)
11608                   {
11609                     /* An attempt is being made to initialize a non-static
11610                        member.  But, from [class.mem]:
11611
11612                        4 A member-declarator can contain a
11613                        constant-initializer only if it declares a static
11614                        member (_class.static_) of integral or enumeration
11615                        type, see _class.static.data_.
11616
11617                        This used to be relatively common practice, but
11618                        the rest of the compiler does not correctly
11619                        handle the initialization unless the member is
11620                        static so we make it static below.  */
11621                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11622                                 declarator);
11623                     cp_pedwarn ("making `%D' static", declarator);
11624                     staticp = 1;
11625                   }
11626
11627                 if (uses_template_parms (type))
11628                   /* We'll check at instantiation time.  */
11629                   ;
11630                 else if (check_static_variable_definition (declarator,
11631                                                            type))
11632                   /* If we just return the declaration, crashes
11633                      will sometimes occur.  We therefore return
11634                      void_type_node, as if this was a friend
11635                      declaration, to cause callers to completely
11636                      ignore this declaration.  */
11637                   return void_type_node;
11638               }
11639
11640             /* 9.2p13 [class.mem] */
11641             if (declarator == constructor_name (current_class_type)
11642                 /* The standard does not allow non-static data members
11643                    here either, but we agreed at the 10/99 meeting
11644                    to change that in TC 1 so that they are allowed in
11645                    classes with no user-defined constructors.  */
11646                 && staticp)
11647               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11648                           declarator);
11649
11650             if (staticp)
11651               {
11652                 /* C++ allows static class members.  All other work
11653                    for this is done by grokfield.  */
11654                 decl = build_lang_decl (VAR_DECL, declarator, type);
11655                 TREE_STATIC (decl) = 1;
11656                 /* In class context, 'static' means public access.  */
11657                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11658               }
11659             else
11660               {
11661                 decl = build_decl (FIELD_DECL, declarator, type);
11662                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11663                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11664                   {
11665                     DECL_MUTABLE_P (decl) = 1;
11666                     RIDBIT_RESET (RID_MUTABLE, specbits);
11667                   }
11668               }
11669
11670             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11671                             inlinep, friendp, raises != NULL_TREE);
11672           }
11673       }
11674     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11675       {
11676         tree original_name;
11677         int publicp = 0;
11678
11679         if (! declarator)
11680           return NULL_TREE;
11681
11682         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11683           original_name = dname;
11684         else
11685           original_name = declarator;
11686
11687         if (RIDBIT_SETP (RID_AUTO, specbits))
11688           error ("storage class `auto' invalid for function `%s'", name);
11689         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11690           error ("storage class `register' invalid for function `%s'", name);
11691
11692         /* Function declaration not at top level.
11693            Storage classes other than `extern' are not allowed
11694            and `extern' makes no difference.  */
11695         if (! toplevel_bindings_p ()
11696             && (RIDBIT_SETP (RID_STATIC, specbits)
11697                 || RIDBIT_SETP (RID_INLINE, specbits))
11698             && pedantic)
11699           {
11700             if (RIDBIT_SETP (RID_STATIC, specbits))
11701               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11702             else
11703               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11704           }
11705
11706         if (ctype == NULL_TREE)
11707           {
11708             if (virtualp)
11709               {
11710                 error ("virtual non-class function `%s'", name);
11711                 virtualp = 0;
11712               }
11713           }
11714         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11715           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11716                                           TYPE_ARG_TYPES (type));
11717
11718         /* Record presence of `static'.  */
11719         publicp = (ctype != NULL_TREE
11720                    || RIDBIT_SETP (RID_EXTERN, specbits)
11721                    || !RIDBIT_SETP (RID_STATIC, specbits));
11722
11723         decl = grokfndecl (ctype, type, original_name, declarator,
11724                            virtualp, flags, quals, raises,
11725                            1, friendp,
11726                            publicp, inlinep, funcdef_flag,
11727                            template_count, in_namespace);
11728         if (decl == NULL_TREE)
11729           return NULL_TREE;
11730
11731         if (staticp == 1)
11732           {
11733             int illegal_static = 0;
11734
11735             /* Don't allow a static member function in a class, and forbid
11736                declaring main to be static.  */
11737             if (TREE_CODE (type) == METHOD_TYPE)
11738               {
11739                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11740                 illegal_static = 1;
11741               }
11742             else if (current_function_decl)
11743               {
11744                 /* FIXME need arm citation */
11745                 error ("cannot declare static function inside another function");
11746                 illegal_static = 1;
11747               }
11748
11749             if (illegal_static)
11750               {
11751                 staticp = 0;
11752                 RIDBIT_RESET (RID_STATIC, specbits);
11753               }
11754           }
11755       }
11756     else
11757       {
11758         /* It's a variable.  */
11759
11760         /* An uninitialized decl with `extern' is a reference.  */
11761         decl = grokvardecl (type, declarator, &specbits,
11762                             initialized,
11763                             (type_quals & TYPE_QUAL_CONST) != 0,
11764                             in_namespace);
11765         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11766                         inlinep, friendp, raises != NULL_TREE);
11767
11768         if (ctype)
11769           {
11770             DECL_CONTEXT (decl) = ctype;
11771             if (staticp == 1)
11772               {
11773                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11774                 staticp = 0;
11775                 RIDBIT_RESET (RID_STATIC, specbits);
11776               }
11777             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11778               {
11779                 cp_error ("static member `%D' declared `register'", decl);
11780                 RIDBIT_RESET (RID_REGISTER, specbits);
11781               }
11782             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11783               {
11784                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11785                             decl);
11786                 RIDBIT_RESET (RID_EXTERN, specbits);
11787               }
11788           }
11789       }
11790
11791     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11792
11793     /* Record `register' declaration for warnings on &
11794        and in case doing stupid register allocation.  */
11795
11796     if (RIDBIT_SETP (RID_REGISTER, specbits))
11797       DECL_REGISTER (decl) = 1;
11798
11799     if (RIDBIT_SETP (RID_EXTERN, specbits))
11800       DECL_THIS_EXTERN (decl) = 1;
11801
11802     if (RIDBIT_SETP (RID_STATIC, specbits))
11803       DECL_THIS_STATIC (decl) = 1;
11804
11805     /* Record constancy and volatility.  There's no need to do this
11806        when processing a template; we'll do this for the instantiated
11807        declaration based on the type of DECL.  */
11808     if (!processing_template_decl)
11809       c_apply_type_quals_to_decl (type_quals, decl);
11810
11811     return decl;
11812   }
11813 }
11814 \f
11815 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11816    An empty exprlist is a parmlist.  An exprlist which
11817    contains only identifiers at the global level
11818    is a parmlist.  Otherwise, it is an exprlist.  */
11819
11820 int
11821 parmlist_is_exprlist (exprs)
11822      tree exprs;
11823 {
11824   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11825     return 0;
11826
11827   if (toplevel_bindings_p ())
11828     {
11829       /* At the global level, if these are all identifiers,
11830          then it is a parmlist.  */
11831       while (exprs)
11832         {
11833           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11834             return 1;
11835           exprs = TREE_CHAIN (exprs);
11836         }
11837       return 0;
11838     }
11839   return 1;
11840 }
11841
11842 /* Subroutine of start_function.  Ensure that each of the parameter
11843    types (as listed in PARMS) is complete, as is required for a
11844    function definition.  */
11845
11846 static void
11847 require_complete_types_for_parms (parms)
11848      tree parms;
11849 {
11850   for (; parms; parms = TREE_CHAIN (parms))
11851     {
11852       tree type = TREE_TYPE (parms);
11853
11854       /* Try to complete the TYPE.  */
11855       type = complete_type (type);
11856
11857       if (type == error_mark_node)
11858         continue;
11859
11860       if (!COMPLETE_TYPE_P (type))
11861         {
11862           if (DECL_NAME (parms))
11863             error ("parameter `%s' has incomplete type",
11864                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11865           else
11866             error ("parameter has incomplete type");
11867           TREE_TYPE (parms) = error_mark_node;
11868         }
11869       else
11870         layout_decl (parms, 0);
11871     }
11872 }
11873
11874 /* Returns non-zero if T is a local variable.  */
11875
11876 int
11877 local_variable_p (t)
11878      tree t;
11879 {
11880   if ((TREE_CODE (t) == VAR_DECL
11881        /* A VAR_DECL with a context that is a _TYPE is a static data
11882           member.  */
11883        && !TYPE_P (CP_DECL_CONTEXT (t))
11884        /* Any other non-local variable must be at namespace scope.  */
11885        && !DECL_NAMESPACE_SCOPE_P (t))
11886       || (TREE_CODE (t) == PARM_DECL))
11887     return 1;
11888
11889   return 0;
11890 }
11891
11892 /* Returns non-zero if T is an automatic local variable or a label.
11893    (These are the declarations that need to be remapped when the code
11894    containing them is duplicated.)  */
11895
11896 int
11897 nonstatic_local_decl_p (t)
11898      tree t;
11899 {
11900   return ((local_variable_p (t) && !TREE_STATIC (t))
11901           || TREE_CODE (t) == LABEL_DECL
11902           || TREE_CODE (t) == RESULT_DECL);
11903 }
11904
11905 /* Like local_variable_p, but suitable for use as a tree-walking
11906    function.  */
11907
11908 static tree
11909 local_variable_p_walkfn (tp, walk_subtrees, data)
11910      tree *tp;
11911      int *walk_subtrees ATTRIBUTE_UNUSED;
11912      void *data ATTRIBUTE_UNUSED;
11913 {
11914   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11915           ? *tp : NULL_TREE);
11916 }
11917
11918 /* Check that ARG, which is a default-argument expression for a
11919    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11920    something goes wrong.  DECL may also be a _TYPE node, rather than a
11921    DECL, if there is no DECL available.  */
11922
11923 tree
11924 check_default_argument (decl, arg)
11925      tree decl;
11926      tree arg;
11927 {
11928   tree var;
11929   tree decl_type;
11930
11931   if (TREE_CODE (arg) == DEFAULT_ARG)
11932     /* We get a DEFAULT_ARG when looking at an in-class declaration
11933        with a default argument.  Ignore the argument for now; we'll
11934        deal with it after the class is complete.  */
11935     return arg;
11936
11937   if (processing_template_decl || uses_template_parms (arg))
11938     /* We don't do anything checking until instantiation-time.  Note
11939        that there may be uninstantiated arguments even for an
11940        instantiated function, since default arguments are not
11941        instantiated until they are needed.  */
11942     return arg;
11943
11944   if (TYPE_P (decl))
11945     {
11946       decl_type = decl;
11947       decl = NULL_TREE;
11948     }
11949   else
11950     decl_type = TREE_TYPE (decl);
11951
11952   if (arg == error_mark_node
11953       || decl == error_mark_node
11954       || TREE_TYPE (arg) == error_mark_node
11955       || decl_type == error_mark_node)
11956     /* Something already went wrong.  There's no need to check
11957        further.  */
11958     return error_mark_node;
11959
11960   /* [dcl.fct.default]
11961
11962      A default argument expression is implicitly converted to the
11963      parameter type.  */
11964   if (!TREE_TYPE (arg)
11965       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11966     {
11967       if (decl)
11968         cp_error ("default argument for `%#D' has type `%T'",
11969                   decl, TREE_TYPE (arg));
11970       else
11971         cp_error ("default argument for parameter of type `%T' has type `%T'",
11972                   decl_type, TREE_TYPE (arg));
11973
11974       return error_mark_node;
11975     }
11976
11977   /* [dcl.fct.default]
11978
11979      Local variables shall not be used in default argument
11980      expressions.
11981
11982      The keyword `this' shall not be used in a default argument of a
11983      member function.  */
11984   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11985                                       NULL);
11986   if (var)
11987     {
11988       cp_error ("default argument `%E' uses local variable `%D'",
11989                 arg, var);
11990       return error_mark_node;
11991     }
11992
11993   /* All is well.  */
11994   return arg;
11995 }
11996
11997 /* Decode the list of parameter types for a function type.
11998    Given the list of things declared inside the parens,
11999    return a list of types.
12000
12001    The list we receive can have three kinds of elements:
12002    an IDENTIFIER_NODE for names given without types,
12003    a TREE_LIST node for arguments given as typespecs or names with typespecs,
12004    or void_type_node, to mark the end of an argument list
12005    when additional arguments are not permitted (... was not used).
12006
12007    FUNCDEF_FLAG is nonzero for a function definition, 0 for
12008    a mere declaration.  A nonempty identifier-list gets an error message
12009    when FUNCDEF_FLAG is zero.
12010    If FUNCDEF_FLAG is 1, then parameter types must be complete.
12011    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
12012
12013    If all elements of the input list contain types,
12014    we return a list of the types.
12015    If all elements contain no type (except perhaps a void_type_node
12016    at the end), we return a null list.
12017    If some have types and some do not, it is an error, and we
12018    return a null list.
12019
12020    Also set last_function_parms to either
12021    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12022    A list of names is converted to a chain of PARM_DECLs
12023    by store_parm_decls so that ultimately it is always a chain of decls.
12024
12025    Note that in C++, parameters can take default values.  These default
12026    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12027    an error to specify default values which are followed by parameters
12028    that have no default values, or an ELLIPSES.  For simplicities sake,
12029    only parameters which are specified with their types can take on
12030    default values.  */
12031
12032 static tree
12033 grokparms (first_parm, funcdef_flag)
12034      tree first_parm;
12035      int funcdef_flag;
12036 {
12037   tree result = NULL_TREE;
12038   tree decls = NULL_TREE;
12039
12040   if (first_parm != NULL_TREE
12041       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12042     {
12043       if (! funcdef_flag)
12044         pedwarn ("parameter names (without types) in function declaration");
12045       last_function_parms = first_parm;
12046       return NULL_TREE;
12047     }
12048   else if (first_parm != NULL_TREE
12049            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12050            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12051     my_friendly_abort (145);
12052   else
12053     {
12054       /* Types were specified.  This is a list of declarators
12055          each represented as a TREE_LIST node.  */
12056       register tree parm, chain;
12057       int any_init = 0, any_error = 0;
12058
12059       if (first_parm != NULL_TREE)
12060         {
12061           tree last_result = NULL_TREE;
12062           tree last_decl = NULL_TREE;
12063
12064           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12065             {
12066               tree type = NULL_TREE, list_node = parm;
12067               register tree decl = TREE_VALUE (parm);
12068               tree init = TREE_PURPOSE (parm);
12069
12070               chain = TREE_CHAIN (parm);
12071               /* @@ weak defense against parse errors.  */
12072               if (TREE_CODE (decl) != VOID_TYPE
12073                   && TREE_CODE (decl) != TREE_LIST)
12074                 {
12075                   /* Give various messages as the need arises.  */
12076                   if (TREE_CODE (decl) == STRING_CST)
12077                     cp_error ("invalid string constant `%E'", decl);
12078                   else if (TREE_CODE (decl) == INTEGER_CST)
12079                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12080                   continue;
12081                 }
12082
12083               if (TREE_CODE (decl) != VOID_TYPE)
12084                 {
12085                   decl = grokdeclarator (TREE_VALUE (decl),
12086                                          TREE_PURPOSE (decl),
12087                                          PARM, init != NULL_TREE,
12088                                          NULL_TREE);
12089                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12090                     continue;
12091
12092                   /* Top-level qualifiers on the parameters are
12093                      ignored for function types.  */
12094                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12095
12096                   if (TREE_CODE (type) == VOID_TYPE)
12097                     decl = void_type_node;
12098                   else if (TREE_CODE (type) == METHOD_TYPE)
12099                     {
12100                       if (DECL_NAME (decl))
12101                         /* Cannot use the decl here because
12102                            we don't have DECL_CONTEXT set up yet.  */
12103                         cp_error ("parameter `%D' invalidly declared method type",
12104                                   DECL_NAME (decl));
12105                       else
12106                         error ("parameter invalidly declared method type");
12107                       type = build_pointer_type (type);
12108                       TREE_TYPE (decl) = type;
12109                     }
12110                   else if (TREE_CODE (type) == OFFSET_TYPE)
12111                     {
12112                       if (DECL_NAME (decl))
12113                         cp_error ("parameter `%D' invalidly declared offset type",
12114                                   DECL_NAME (decl));
12115                       else
12116                         error ("parameter invalidly declared offset type");
12117                       type = build_pointer_type (type);
12118                       TREE_TYPE (decl) = type;
12119                     }
12120                   else if (abstract_virtuals_error (decl, type))
12121                     any_error = 1;  /* Seems like a good idea. */
12122                   else if (POINTER_TYPE_P (type))
12123                     {
12124                       tree t = type;
12125                       while (POINTER_TYPE_P (t)
12126                              || (TREE_CODE (t) == ARRAY_TYPE
12127                                  && TYPE_DOMAIN (t) != NULL_TREE))
12128                         t = TREE_TYPE (t);
12129                       if (TREE_CODE (t) == ARRAY_TYPE)
12130                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12131                                   type,
12132                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12133                     }
12134                 }
12135
12136               if (TREE_CODE (decl) == VOID_TYPE)
12137                 {
12138                   if (result == NULL_TREE)
12139                     {
12140                       result = void_list_node;
12141                       last_result = result;
12142                     }
12143                   else
12144                     {
12145                       TREE_CHAIN (last_result) = void_list_node;
12146                       last_result = void_list_node;
12147                     }
12148                   if (chain
12149                       && (chain != void_list_node || TREE_CHAIN (chain)))
12150                     error ("`void' in parameter list must be entire list");
12151                   break;
12152                 }
12153
12154               /* Since there is a prototype, args are passed in their own types.  */
12155               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12156               if (PROMOTE_PROTOTYPES
12157                   && (TREE_CODE (type) == INTEGER_TYPE
12158                       || TREE_CODE (type) == ENUMERAL_TYPE)
12159                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12160                 DECL_ARG_TYPE (decl) = integer_type_node;
12161               if (!any_error && init)
12162                 {
12163                   any_init++;
12164                   init = check_default_argument (decl, init);
12165                 }
12166               else
12167                 init = NULL_TREE;
12168
12169               if (decls == NULL_TREE)
12170                 {
12171                   decls = decl;
12172                   last_decl = decls;
12173                 }
12174               else
12175                 {
12176                   TREE_CHAIN (last_decl) = decl;
12177                   last_decl = decl;
12178                 }
12179               list_node = tree_cons (init, type, NULL_TREE);
12180               if (result == NULL_TREE)
12181                 {
12182                   result = list_node;
12183                   last_result = result;
12184                 }
12185               else
12186                 {
12187                   TREE_CHAIN (last_result) = list_node;
12188                   last_result = list_node;
12189                 }
12190             }
12191           if (last_result)
12192             TREE_CHAIN (last_result) = NULL_TREE;
12193           /* If there are no parameters, and the function does not end
12194              with `...', then last_decl will be NULL_TREE.  */
12195           if (last_decl != NULL_TREE)
12196             TREE_CHAIN (last_decl) = NULL_TREE;
12197         }
12198     }
12199
12200   last_function_parms = decls;
12201
12202   return result;
12203 }
12204
12205 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12206    FUNCTION_TYPE with the newly parsed version of its default argument, which
12207    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12208
12209 void
12210 replace_defarg (arg, init)
12211      tree arg, init;
12212 {
12213   if (! processing_template_decl
12214       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12215     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12216                 TREE_TYPE (init), TREE_VALUE (arg));
12217   TREE_PURPOSE (arg) = init;
12218 }
12219 \f
12220 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12221    D's arguments allow it to be a copy constructor, or copy assignment
12222    operator.  */
12223
12224 int
12225 copy_args_p (d)
12226      tree d;
12227 {
12228   tree t;
12229
12230   if (!DECL_FUNCTION_MEMBER_P (d))
12231     return 0;
12232
12233   t = FUNCTION_ARG_CHAIN (d);
12234   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12235     t = TREE_CHAIN (t);
12236   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12237       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12238           == DECL_CONTEXT (d))
12239       && (TREE_CHAIN (t) == NULL_TREE
12240           || TREE_CHAIN (t) == void_list_node
12241           || TREE_PURPOSE (TREE_CHAIN (t))))
12242     return 1;
12243   return 0;
12244 }
12245
12246 /* These memoizing functions keep track of special properties which
12247    a class may have.  `grok_ctor_properties' notices whether a class
12248    has a constructor of the form X(X&), and also complains
12249    if the class has a constructor of the form X(X).
12250    `grok_op_properties' takes notice of the various forms of
12251    operator= which are defined, as well as what sorts of type conversion
12252    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12253
12254 int
12255 grok_ctor_properties (ctype, decl)
12256      tree ctype, decl;
12257 {
12258   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12259   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12260
12261   /* When a type has virtual baseclasses, a magical first int argument is
12262      added to any ctor so we can tell if the class has been initialized
12263      yet.  This could screw things up in this function, so we deliberately
12264      ignore the leading int if we're in that situation.  */
12265   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12266     {
12267       my_friendly_assert (parmtypes
12268                           && TREE_VALUE (parmtypes) == integer_type_node,
12269                           980529);
12270       parmtypes = TREE_CHAIN (parmtypes);
12271       parmtype = TREE_VALUE (parmtypes);
12272     }
12273
12274   /* [class.copy]
12275
12276      A non-template constructor for class X is a copy constructor if
12277      its first parameter is of type X&, const X&, volatile X& or const
12278      volatile X&, and either there are no other parameters or else all
12279      other parameters have default arguments.  */
12280   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12281       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12282       && (TREE_CHAIN (parmtypes) == NULL_TREE
12283           || TREE_CHAIN (parmtypes) == void_list_node
12284           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12285       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12286            && is_member_template (DECL_TI_TEMPLATE (decl))))
12287     {
12288       TYPE_HAS_INIT_REF (ctype) = 1;
12289       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12290         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12291     }
12292   /* [class.copy]
12293
12294      A declaration of a constructor for a class X is ill-formed if its
12295      first parameter is of type (optionally cv-qualified) X and either
12296      there are no other parameters or else all other parameters have
12297      default arguments.
12298
12299      We *don't* complain about member template instantiations that
12300      have this form, though; they can occur as we try to decide what
12301      constructor to use during overload resolution.  Since overload
12302      resolution will never prefer such a constructor to the
12303      non-template copy constructor (which is either explicitly or
12304      implicitly defined), there's no need to worry about their
12305      existence.  Theoretically, they should never even be
12306      instantiated, but that's hard to forestall.  */
12307   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12308            && (TREE_CHAIN (parmtypes) == NULL_TREE
12309                || TREE_CHAIN (parmtypes) == void_list_node
12310                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12311            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12312                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12313     {
12314       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12315                 ctype, ctype);
12316       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12317       return 0;
12318     }
12319   else if (TREE_CODE (parmtype) == VOID_TYPE
12320            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12321     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12322
12323   return 1;
12324 }
12325
12326 /* An operator with this code is unary, but can also be binary.  */
12327
12328 static int
12329 ambi_op_p (code)
12330      enum tree_code code;
12331 {
12332   return (code == INDIRECT_REF
12333           || code == ADDR_EXPR
12334           || code == CONVERT_EXPR
12335           || code == NEGATE_EXPR
12336           || code == PREINCREMENT_EXPR
12337           || code == PREDECREMENT_EXPR);
12338 }
12339
12340 /* An operator with this name can only be unary.  */
12341
12342 static int
12343 unary_op_p (code)
12344      enum tree_code code;
12345 {
12346   return (code == TRUTH_NOT_EXPR
12347           || code == BIT_NOT_EXPR
12348           || code == COMPONENT_REF
12349           || code == TYPE_EXPR);
12350 }
12351
12352 /* Do a little sanity-checking on how they declared their operator.  */
12353
12354 void
12355 grok_op_properties (decl, virtualp, friendp)
12356      tree decl;
12357      int virtualp, friendp;
12358 {
12359   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12360   tree argtype;
12361   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12362   tree name = DECL_NAME (decl);
12363   enum tree_code operator_code;
12364   int arity;
12365
12366   /* Count the number of arguments.  */
12367   for (argtype = argtypes, arity = 0;
12368        argtype && argtype != void_list_node;
12369        argtype = TREE_CHAIN (argtype))
12370     ++arity;
12371
12372   if (current_class_type == NULL_TREE)
12373     friendp = 1;
12374
12375   if (DECL_CONV_FN_P (decl))
12376     operator_code = TYPE_EXPR;
12377   else
12378     do
12379       {
12380 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12381         if (ansi_opname (CODE) == name)                                     \
12382           {                                                                 \
12383             operator_code = CODE;                                           \
12384             break;                                                          \
12385           }                                                                 \
12386         else if (ansi_assopname (CODE) == name)                             \
12387           {                                                                 \
12388             operator_code = CODE;                                           \
12389             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12390             break;                                                          \
12391           }
12392
12393 #include "operators.def"
12394 #undef DEF_OPERATOR
12395
12396         my_friendly_abort (20000527);
12397       }
12398     while (0);
12399   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12400   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12401
12402   if (! friendp)
12403     {
12404       switch (operator_code)
12405         {
12406         case CALL_EXPR:
12407           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12408           break;
12409
12410         case ARRAY_REF:
12411           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12412           break;
12413
12414         case COMPONENT_REF:
12415         case MEMBER_REF:
12416           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12417           break;
12418
12419         case NEW_EXPR:
12420           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12421           break;
12422
12423         case DELETE_EXPR:
12424           TYPE_GETS_DELETE (current_class_type) |= 1;
12425           break;
12426
12427         case VEC_NEW_EXPR:
12428           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12429           break;
12430
12431         case VEC_DELETE_EXPR:
12432           TYPE_GETS_DELETE (current_class_type) |= 2;
12433           break;
12434
12435         default:
12436           break;
12437         }
12438     }
12439
12440   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12441     {
12442       /* When the compiler encounters the definition of A::operator new, it
12443          doesn't look at the class declaration to find out if it's static.  */
12444       if (methodp)
12445         revert_static_member_fn (decl);
12446
12447       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12448     }
12449   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12450     {
12451       if (methodp)
12452         revert_static_member_fn (decl);
12453
12454       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12455     }
12456   else
12457     {
12458       /* An operator function must either be a non-static member function
12459          or have at least one parameter of a class, a reference to a class,
12460          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12461       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12462         {
12463           if (operator_code == TYPE_EXPR
12464               || operator_code == CALL_EXPR
12465               || operator_code == COMPONENT_REF
12466               || operator_code == ARRAY_REF
12467               || operator_code == NOP_EXPR)
12468             cp_error ("`%D' must be a nonstatic member function", decl);
12469           else
12470             {
12471               tree p = argtypes;
12472
12473               if (DECL_STATIC_FUNCTION_P (decl))
12474                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12475
12476               if (p)
12477                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12478                   {
12479                     tree arg = TREE_VALUE (p);
12480                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12481                       arg = TREE_TYPE (arg);
12482
12483                     /* This lets bad template code slip through.  */
12484                     if (IS_AGGR_TYPE (arg)
12485                         || TREE_CODE (arg) == ENUMERAL_TYPE
12486                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12487                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12488                       goto foundaggr;
12489                   }
12490               cp_error
12491                 ("`%D' must have an argument of class or enumerated type",
12492                  decl);
12493             foundaggr:
12494               ;
12495             }
12496         }
12497
12498       if (operator_code == CALL_EXPR)
12499         return;                 /* No restrictions on args. */
12500
12501       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12502         {
12503           tree t = TREE_TYPE (name);
12504           if (! friendp)
12505             {
12506               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12507               const char *what = 0;
12508
12509               if (ref)
12510                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12511
12512               if (TREE_CODE (t) == VOID_TYPE)
12513                 what = "void";
12514               else if (t == current_class_type)
12515                 what = "the same type";
12516               /* Don't force t to be complete here.  */
12517               else if (IS_AGGR_TYPE (t)
12518                        && COMPLETE_TYPE_P (t)
12519                        && DERIVED_FROM_P (t, current_class_type))
12520                 what = "a base class";
12521
12522               if (what)
12523                 warning ("conversion to %s%s will never use a type conversion operator",
12524                          ref ? "a reference to " : "", what);
12525             }
12526         }
12527
12528       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12529           && operator_code == NOP_EXPR)
12530         {
12531           tree parmtype;
12532
12533           if (arity != 2 && methodp)
12534             {
12535               cp_error ("`%D' must take exactly one argument", decl);
12536               return;
12537             }
12538           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12539
12540           /* [class.copy]
12541
12542              A user-declared copy assignment operator X::operator= is
12543              a non-static non-template member function of class X with
12544              exactly one parameter of type X, X&, const X&, volatile
12545              X& or const volatile X&.  */
12546           if (copy_assignment_arg_p (parmtype, virtualp)
12547               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12548                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12549               && ! friendp)
12550             {
12551               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12552               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12553                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12554                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12555             }
12556         }
12557       else if (operator_code == COND_EXPR)
12558         {
12559           /* 13.4.0.3 */
12560           cp_error ("ISO C++ prohibits overloading operator ?:");
12561         }
12562       else if (ambi_op_p (operator_code))
12563         {
12564           if (arity == 1)
12565             /* We pick the one-argument operator codes by default, so
12566                we don't have to change anything.  */
12567             ;
12568           else if (arity == 2)
12569             {
12570               /* If we thought this was a unary operator, we now know
12571                  it to be a binary operator.  */
12572               switch (operator_code)
12573                 {
12574                 case INDIRECT_REF:
12575                   operator_code = MULT_EXPR;
12576                   break;
12577
12578                 case ADDR_EXPR:
12579                   operator_code = BIT_AND_EXPR;
12580                   break;
12581
12582                 case CONVERT_EXPR:
12583                   operator_code = PLUS_EXPR;
12584                   break;
12585
12586                 case NEGATE_EXPR:
12587                   operator_code = MINUS_EXPR;
12588                   break;
12589
12590                 case PREINCREMENT_EXPR:
12591                   operator_code = POSTINCREMENT_EXPR;
12592                   break;
12593
12594                 case PREDECREMENT_EXPR:
12595                   operator_code = POSTDECREMENT_EXPR;
12596                   break;
12597
12598                 default:
12599                   my_friendly_abort (20000527);
12600                 }
12601
12602               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12603
12604               if ((operator_code == POSTINCREMENT_EXPR
12605                    || operator_code == POSTDECREMENT_EXPR)
12606                   && ! processing_template_decl
12607                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12608                 {
12609                   if (methodp)
12610                     cp_error ("postfix `%D' must take `int' as its argument",
12611                               decl);
12612                   else
12613                     cp_error
12614                       ("postfix `%D' must take `int' as its second argument",
12615                        decl);
12616                 }
12617             }
12618           else
12619             {
12620               if (methodp)
12621                 cp_error ("`%D' must take either zero or one argument", decl);
12622               else
12623                 cp_error ("`%D' must take either one or two arguments", decl);
12624             }
12625
12626           /* More Effective C++ rule 6.  */
12627           if (warn_ecpp
12628               && (operator_code == POSTINCREMENT_EXPR
12629                   || operator_code == POSTDECREMENT_EXPR
12630                   || operator_code == PREINCREMENT_EXPR
12631                   || operator_code == PREDECREMENT_EXPR))
12632             {
12633               tree arg = TREE_VALUE (argtypes);
12634               tree ret = TREE_TYPE (TREE_TYPE (decl));
12635               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12636                 arg = TREE_TYPE (arg);
12637               arg = TYPE_MAIN_VARIANT (arg);
12638               if (operator_code == PREINCREMENT_EXPR
12639                   || operator_code == PREDECREMENT_EXPR)
12640                 {
12641                   if (TREE_CODE (ret) != REFERENCE_TYPE
12642                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12643                                        arg))
12644                     cp_warning ("prefix `%D' should return `%T'", decl,
12645                                 build_reference_type (arg));
12646                 }
12647               else
12648                 {
12649                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12650                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12651                 }
12652             }
12653         }
12654       else if (unary_op_p (operator_code))
12655         {
12656           if (arity != 1)
12657             {
12658               if (methodp)
12659                 cp_error ("`%D' must take `void'", decl);
12660               else
12661                 cp_error ("`%D' must take exactly one argument", decl);
12662             }
12663         }
12664       else /* if (binary_op_p (operator_code)) */
12665         {
12666           if (arity != 2)
12667             {
12668               if (methodp)
12669                 cp_error ("`%D' must take exactly one argument", decl);
12670               else
12671                 cp_error ("`%D' must take exactly two arguments", decl);
12672             }
12673
12674           /* More Effective C++ rule 7.  */
12675           if (warn_ecpp
12676               && (operator_code == TRUTH_ANDIF_EXPR
12677                   || operator_code == TRUTH_ORIF_EXPR
12678                   || operator_code == COMPOUND_EXPR))
12679             cp_warning ("user-defined `%D' always evaluates both arguments",
12680                         decl);
12681         }
12682
12683       /* Effective C++ rule 23.  */
12684       if (warn_ecpp
12685           && arity == 2
12686           && (operator_code == PLUS_EXPR
12687               || operator_code == MINUS_EXPR
12688               || operator_code == TRUNC_DIV_EXPR
12689               || operator_code == MULT_EXPR)
12690           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12691         cp_warning ("`%D' should return by value", decl);
12692
12693       /* 13.4.0.8 */
12694       for (; argtypes && argtypes != void_list_node;
12695           argtypes = TREE_CHAIN (argtypes))
12696         if (TREE_PURPOSE (argtypes))
12697           {
12698             TREE_PURPOSE (argtypes) = NULL_TREE;
12699             if (operator_code == POSTINCREMENT_EXPR
12700                 || operator_code == POSTDECREMENT_EXPR)
12701               {
12702                 if (pedantic)
12703                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12704               }
12705             else
12706               cp_error ("`%D' cannot have default arguments", decl);
12707           }
12708
12709     }
12710 }
12711 \f
12712 static const char *
12713 tag_name (code)
12714      enum tag_types code;
12715 {
12716   switch (code)
12717     {
12718     case record_type:
12719       return "struct";
12720     case class_type:
12721       return "class";
12722     case union_type:
12723       return "union ";
12724     case enum_type:
12725       return "enum";
12726     default:
12727       my_friendly_abort (981122);
12728     }
12729 }
12730
12731 /* Get the struct, enum or union (CODE says which) with tag NAME.
12732    Define the tag as a forward-reference if it is not defined.
12733
12734    C++: If a class derivation is given, process it here, and report
12735    an error if multiple derivation declarations are not identical.
12736
12737    If this is a definition, come in through xref_tag and only look in
12738    the current frame for the name (since C++ allows new names in any
12739    scope.)  */
12740
12741 tree
12742 xref_tag (code_type_node, name, globalize)
12743      tree code_type_node;
12744      tree name;
12745      int globalize;
12746 {
12747   enum tag_types tag_code;
12748   enum tree_code code;
12749   register tree ref, t;
12750   struct binding_level *b = current_binding_level;
12751   int got_type = 0;
12752   tree attributes = NULL_TREE;
12753   tree context = NULL_TREE;
12754
12755   /* If we are called from the parser, code_type_node will sometimes be a
12756      TREE_LIST.  This indicates that the user wrote
12757      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12758      use them later.  */
12759   if (TREE_CODE (code_type_node) == TREE_LIST)
12760     {
12761       attributes = TREE_PURPOSE (code_type_node);
12762       code_type_node = TREE_VALUE (code_type_node);
12763     }
12764
12765   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12766   switch (tag_code)
12767     {
12768     case record_type:
12769     case class_type:
12770       code = RECORD_TYPE;
12771       break;
12772     case union_type:
12773       code = UNION_TYPE;
12774       break;
12775     case enum_type:
12776       code = ENUMERAL_TYPE;
12777       break;
12778     default:
12779       my_friendly_abort (18);
12780     }
12781
12782   /* If a cross reference is requested, look up the type
12783      already defined for this tag and return it.  */
12784   if (TYPE_P (name))
12785     {
12786       t = name;
12787       name = TYPE_IDENTIFIER (t);
12788       got_type = 1;
12789     }
12790   else
12791     t = IDENTIFIER_TYPE_VALUE (name);
12792
12793   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12794   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12795     {
12796       static int explained;
12797
12798       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12799 to refer to the inherited type, say `%s %T::%T'%s",
12800                   tag_name (tag_code), name, tag_name (tag_code),
12801                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12802                   (!explained ? "\n\
12803 (names from dependent base classes are not visible to unqualified name lookup)"
12804                    : ""));
12805
12806       explained = 1;
12807     }
12808
12809   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12810       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12811     t = NULL_TREE;
12812
12813   if (! globalize)
12814     {
12815       /* If we know we are defining this tag, only look it up in
12816          this scope and don't try to find it as a type.  */
12817       ref = lookup_tag (code, name, b, 1);
12818     }
12819   else
12820     {
12821       if (t)
12822         {
12823           /* [dcl.type.elab] If the identifier resolves to a
12824              typedef-name or a template type-parameter, the
12825              elaborated-type-specifier is ill-formed.  */
12826           if (t != TYPE_MAIN_VARIANT (t)
12827               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12828             cp_pedwarn ("using typedef-name `%D' after `%s'",
12829                         TYPE_NAME (t), tag_name (tag_code));
12830           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12831             cp_error ("using template type parameter `%T' after `%s'",
12832                       t, tag_name (tag_code));
12833
12834           ref = t;
12835         }
12836       else
12837         ref = lookup_tag (code, name, b, 0);
12838
12839       if (! ref)
12840         {
12841           /* Try finding it as a type declaration.  If that wins,
12842              use it.  */
12843           ref = lookup_name (name, 1);
12844
12845           if (ref != NULL_TREE
12846               && processing_template_decl
12847               && DECL_CLASS_TEMPLATE_P (ref)
12848               && template_class_depth (current_class_type) == 0)
12849             /* Since GLOBALIZE is true, we're declaring a global
12850                template, so we want this type.  */
12851             ref = DECL_TEMPLATE_RESULT (ref);
12852
12853           if (ref && TREE_CODE (ref) == TYPE_DECL
12854               && TREE_CODE (TREE_TYPE (ref)) == code)
12855             ref = TREE_TYPE (ref);
12856           else
12857             ref = NULL_TREE;
12858         }
12859
12860       if (ref && current_class_type
12861           && template_class_depth (current_class_type)
12862           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12863         {
12864           /* Since GLOBALIZE is non-zero, we are not looking at a
12865              definition of this tag.  Since, in addition, we are currently
12866              processing a (member) template declaration of a template
12867              class, we must be very careful; consider:
12868
12869                template <class X>
12870                struct S1
12871
12872                template <class U>
12873                struct S2
12874                { template <class V>
12875                friend struct S1; };
12876
12877              Here, the S2::S1 declaration should not be confused with the
12878              outer declaration.  In particular, the inner version should
12879              have a template parameter of level 2, not level 1.  This
12880              would be particularly important if the member declaration
12881              were instead:
12882
12883                template <class V = U> friend struct S1;
12884
12885              say, when we should tsubst into `U' when instantiating
12886              S2.  On the other hand, when presented with:
12887
12888                  template <class T>
12889                  struct S1 {
12890                    template <class U>
12891                    struct S2 {};
12892                    template <class U>
12893                    friend struct S2;
12894                  };
12895
12896               we must find the inner binding eventually.  We
12897               accomplish this by making sure that the new type we
12898               create to represent this declaration has the right
12899               TYPE_CONTEXT.  */
12900           context = TYPE_CONTEXT (ref);
12901           ref = NULL_TREE;
12902         }
12903     }
12904
12905   if (! ref)
12906     {
12907       /* If no such tag is yet defined, create a forward-reference node
12908          and record it as the "definition".
12909          When a real declaration of this type is found,
12910          the forward-reference will be altered into a real type.  */
12911       if (code == ENUMERAL_TYPE)
12912         {
12913           cp_error ("use of enum `%#D' without previous declaration", name);
12914
12915           ref = make_node (ENUMERAL_TYPE);
12916
12917           /* Give the type a default layout like unsigned int
12918              to avoid crashing if it does not get defined.  */
12919           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12920           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12921           TYPE_USER_ALIGN (ref) = 0;
12922           TREE_UNSIGNED (ref) = 1;
12923           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12924           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12925           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12926
12927           /* Enable us to recognize when a type is created in class context.
12928              To do nested classes correctly, this should probably be cleared
12929              out when we leave this classes scope.  Currently this in only
12930              done in `start_enum'.  */
12931
12932           pushtag (name, ref, globalize);
12933         }
12934       else
12935         {
12936           struct binding_level *old_b = class_binding_level;
12937
12938           ref = make_aggr_type (code);
12939           TYPE_CONTEXT (ref) = context;
12940
12941 #ifdef NONNESTED_CLASSES
12942           /* Class types don't nest the way enums do.  */
12943           class_binding_level = (struct binding_level *)0;
12944 #endif
12945           pushtag (name, ref, globalize);
12946           class_binding_level = old_b;
12947         }
12948     }
12949   else
12950     {
12951       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12952         redeclare_class_template (ref, current_template_parms);
12953     }
12954
12955   /* Until the type is defined, tentatively accept whatever
12956      structure tag the user hands us.  */
12957   if (!COMPLETE_TYPE_P (ref)
12958       && ref != current_class_type
12959       /* Have to check this, in case we have contradictory tag info.  */
12960       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12961     {
12962       if (tag_code == class_type)
12963         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12964       else if (tag_code == record_type)
12965         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12966     }
12967
12968   TREE_TYPE (ref) = attributes;
12969
12970   return ref;
12971 }
12972
12973 tree
12974 xref_tag_from_type (old, id, globalize)
12975      tree old, id;
12976      int globalize;
12977 {
12978   tree code_type_node;
12979
12980   if (TREE_CODE (old) == RECORD_TYPE)
12981     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12982                       ? class_type_node : record_type_node);
12983   else
12984     code_type_node = union_type_node;
12985
12986   if (id == NULL_TREE)
12987     id = TYPE_IDENTIFIER (old);
12988
12989   return xref_tag (code_type_node, id, globalize);
12990 }
12991
12992 /* REF is a type (named NAME), for which we have just seen some
12993    baseclasses.  BINFO is a list of those baseclasses; the
12994    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12995    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12996    struct, or union.  */
12997
12998 void
12999 xref_basetypes (code_type_node, name, ref, binfo)
13000      tree code_type_node;
13001      tree name, ref;
13002      tree binfo;
13003 {
13004   /* In the declaration `A : X, Y, ... Z' we mark all the types
13005      (A, X, Y, ..., Z) so we can check for duplicates.  */
13006   tree binfos;
13007   tree base;
13008
13009   int i, len;
13010   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13011
13012   if (tag_code == union_type)
13013     {
13014       cp_error ("derived union `%T' invalid", ref);
13015       return;
13016     }
13017
13018   len = list_length (binfo);
13019
13020   /* First, make sure that any templates in base-classes are
13021      instantiated.  This ensures that if we call ourselves recursively
13022      we do not get confused about which classes are marked and which
13023      are not.  */
13024   for (base = binfo; base; base = TREE_CHAIN (base))
13025     complete_type (TREE_VALUE (base));
13026
13027   SET_CLASSTYPE_MARKED (ref);
13028   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13029
13030   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13031     {
13032       /* The base of a derived struct is public by default.  */
13033       int via_public
13034         = (TREE_PURPOSE (binfo) == access_public_node
13035            || TREE_PURPOSE (binfo) == access_public_virtual_node
13036            || (tag_code != class_type
13037                && (TREE_PURPOSE (binfo) == access_default_node
13038                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13039       int via_protected
13040         = (TREE_PURPOSE (binfo) == access_protected_node
13041            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13042       int via_virtual
13043         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13044            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13045            || TREE_PURPOSE (binfo) == access_public_virtual_node
13046            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13047       tree basetype = TREE_VALUE (binfo);
13048       tree base_binfo;
13049
13050       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13051         basetype = TREE_TYPE (basetype);
13052       if (!basetype
13053           || (TREE_CODE (basetype) != RECORD_TYPE
13054               && TREE_CODE (basetype) != TYPENAME_TYPE
13055               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13056               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13057         {
13058           cp_error ("base type `%T' fails to be a struct or class type",
13059                     TREE_VALUE (binfo));
13060           continue;
13061         }
13062
13063       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13064
13065       /* This code replaces similar code in layout_basetypes.
13066          We put the complete_type first for implicit `typename'.  */
13067       if (!COMPLETE_TYPE_P (basetype)
13068           && ! (current_template_parms && uses_template_parms (basetype)))
13069         {
13070           cp_error ("base class `%T' has incomplete type", basetype);
13071           continue;
13072         }
13073       else
13074         {
13075           if (CLASSTYPE_MARKED (basetype))
13076             {
13077               if (basetype == ref)
13078                 cp_error ("recursive type `%T' undefined", basetype);
13079               else
13080                 cp_error ("duplicate base type `%T' invalid", basetype);
13081               continue;
13082             }
13083
13084           if (TYPE_FOR_JAVA (basetype)
13085               && (current_lang_stack
13086                   == &VARRAY_TREE (current_lang_base, 0)))
13087             TYPE_FOR_JAVA (ref) = 1;
13088
13089           /* Note that the BINFO records which describe individual
13090              inheritances are *not* shared in the lattice!  They
13091              cannot be shared because a given baseclass may be
13092              inherited with different `accessibility' by different
13093              derived classes.  (Each BINFO record describing an
13094              individual inheritance contains flags which say what
13095              the `accessibility' of that particular inheritance is.)  */
13096
13097           base_binfo
13098             = make_binfo (size_zero_node, basetype,
13099                           CLASS_TYPE_P (basetype)
13100                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13101                           CLASS_TYPE_P (basetype)
13102                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13103
13104           TREE_VEC_ELT (binfos, i) = base_binfo;
13105           TREE_VIA_PUBLIC (base_binfo) = via_public;
13106           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13107           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13108           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13109
13110           /* We need to unshare the binfos now so that lookups during class
13111              definition work.  */
13112           unshare_base_binfos (base_binfo);
13113
13114           SET_CLASSTYPE_MARKED (basetype);
13115
13116           /* We are free to modify these bits because they are meaningless
13117              at top level, and BASETYPE is a top-level type.  */
13118           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13119             {
13120               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13121               /* Converting to a virtual base class requires looking
13122                  up the offset of the virtual base.  */
13123               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13124             }
13125
13126           if (CLASS_TYPE_P (basetype))
13127             {
13128               TYPE_HAS_NEW_OPERATOR (ref)
13129                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13130               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13131                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13132               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13133               /* If the base-class uses multiple inheritance, so do we.  */
13134               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13135                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13136               /* Likewise, if converting to a base of the base may require
13137                  code, then we may need to generate code to convert to a
13138                  base as well.  */
13139               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13140                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13141             }
13142
13143           i += 1;
13144         }
13145     }
13146   if (i)
13147     TREE_VEC_LENGTH (binfos) = i;
13148   else
13149     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13150
13151   if (i > 1)
13152     {
13153       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13154       /* If there is more than one non-empty they cannot be at the same
13155          address.  */
13156       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13157     }
13158
13159   /* Unmark all the types.  */
13160   while (--i >= 0)
13161     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13162   CLEAR_CLASSTYPE_MARKED (ref);
13163
13164   /* Now that we know all the base-classes, set up the list of virtual
13165      bases.  */
13166   get_vbase_types (ref);
13167 }
13168
13169 \f
13170 /* Begin compiling the definition of an enumeration type.
13171    NAME is its name (or null if anonymous).
13172    Returns the type object, as yet incomplete.
13173    Also records info about it so that build_enumerator
13174    may be used to declare the individual values as they are read.  */
13175
13176 tree
13177 start_enum (name)
13178      tree name;
13179 {
13180   register tree enumtype = NULL_TREE;
13181   struct binding_level *b = current_binding_level;
13182
13183   /* If this is the real definition for a previous forward reference,
13184      fill in the contents in the same object that used to be the
13185      forward reference.  */
13186
13187   if (name != NULL_TREE)
13188     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13189
13190   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13191     {
13192       cp_error ("multiple definition of `%#T'", enumtype);
13193       cp_error_at ("previous definition here", enumtype);
13194       /* Clear out TYPE_VALUES, and start again.  */
13195       TYPE_VALUES (enumtype) = NULL_TREE;
13196     }
13197   else
13198     {
13199       enumtype = make_node (ENUMERAL_TYPE);
13200       pushtag (name, enumtype, 0);
13201     }
13202
13203   if (current_class_type)
13204     TREE_ADDRESSABLE (b->tags) = 1;
13205
13206   GNU_xref_decl (current_function_decl, enumtype);
13207   return enumtype;
13208 }
13209
13210 /* After processing and defining all the values of an enumeration type,
13211    install their decls in the enumeration type and finish it off.
13212    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13213    Returns ENUMTYPE.  */
13214
13215 tree
13216 finish_enum (enumtype)
13217      tree enumtype;
13218 {
13219   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13220   /* Calculate the maximum value of any enumerator in this type.  */
13221
13222   tree values = TYPE_VALUES (enumtype);
13223   if (values)
13224     {
13225       tree pair;
13226
13227       for (pair = values; pair; pair = TREE_CHAIN (pair))
13228         {
13229           tree decl;
13230           tree value;
13231
13232           /* The TREE_VALUE is a CONST_DECL for this enumeration
13233              constant.  */
13234           decl = TREE_VALUE (pair);
13235
13236           /* [dcl.enum]
13237
13238              Following the closing brace of an enum-specifier, each
13239              enumerator has the type of its enumeration.  Prior to the
13240              closing brace, the type of each enumerator is the type of
13241              its initializing value.  */
13242           TREE_TYPE (decl) = enumtype;
13243
13244           /* The DECL_INITIAL will be NULL if we are processing a
13245              template declaration and this enumeration constant had no
13246              explicit initializer.  */
13247           value = DECL_INITIAL (decl);
13248           if (value && !processing_template_decl)
13249             {
13250               /* Set the TREE_TYPE for the VALUE as well.  That's so
13251                  that when we call decl_constant_value we get an
13252                  entity of the right type (but with the constant
13253                  value).  Since we shouldn't ever call
13254                  decl_constant_value on a template type, there's no
13255                  reason to do that when processing_template_decl.
13256                  And, if the expression is something like a
13257                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13258                  wreak havoc on the intended type of the expression.
13259
13260                  Of course, there's also no point in trying to compute
13261                  minimum or maximum values if we're in a template.  */
13262               TREE_TYPE (value) = enumtype;
13263
13264               if (!minnode)
13265                 minnode = maxnode = value;
13266               else if (tree_int_cst_lt (maxnode, value))
13267                 maxnode = value;
13268               else if (tree_int_cst_lt (value, minnode))
13269                 minnode = value;
13270             }
13271
13272           if (processing_template_decl)
13273             /* If this is just a template, leave the CONST_DECL
13274                alone.  That way tsubst_copy will find CONST_DECLs for
13275                CONST_DECLs, and not INTEGER_CSTs.  */
13276             ;
13277           else
13278             /* In the list we're building up, we want the enumeration
13279                values, not the CONST_DECLs.  */
13280             TREE_VALUE (pair) = value;
13281         }
13282     }
13283   else
13284     maxnode = minnode = integer_zero_node;
13285
13286   TYPE_VALUES (enumtype) = nreverse (values);
13287
13288   if (processing_template_decl)
13289     {
13290       tree scope = current_scope ();
13291       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13292         add_stmt (build_min (TAG_DEFN, enumtype));
13293     }
13294   else
13295     {
13296       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13297       int lowprec = min_precision (minnode, unsignedp);
13298       int highprec = min_precision (maxnode, unsignedp);
13299       int precision = MAX (lowprec, highprec);
13300       tree tem;
13301
13302       TYPE_SIZE (enumtype) = NULL_TREE;
13303
13304       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13305
13306       TYPE_PRECISION (enumtype) = precision;
13307       if (unsignedp)
13308         fixup_unsigned_type (enumtype);
13309       else
13310         fixup_signed_type (enumtype);
13311
13312       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13313         /* Use the width of the narrowest normal C type which is wide
13314            enough.  */
13315         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13316                                                     (precision, 1));
13317       else
13318         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13319
13320       TYPE_SIZE (enumtype) = 0;
13321       layout_type (enumtype);
13322
13323       /* Fix up all variant types of this enum type.  */
13324       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13325            tem = TYPE_NEXT_VARIANT (tem))
13326         {
13327           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13328           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13329           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13330           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13331           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13332           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13333           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13334           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13335           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13336           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13337         }
13338
13339       /* Finish debugging output for this type.  */
13340       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13341     }
13342
13343   return enumtype;
13344 }
13345
13346 /* Build and install a CONST_DECL for an enumeration constant of the
13347    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13348    Assignment of sequential values by default is handled here.  */
13349
13350 void
13351 build_enumerator (name, value, enumtype)
13352      tree name;
13353      tree value;
13354      tree enumtype;
13355 {
13356   tree decl;
13357   tree context;
13358   tree type;
13359   tree values;
13360
13361   /* Remove no-op casts from the value.  */
13362   if (value)
13363     STRIP_TYPE_NOPS (value);
13364
13365   if (! processing_template_decl)
13366     {
13367       /* Validate and default VALUE.  */
13368       if (value != NULL_TREE)
13369         {
13370           value = decl_constant_value (value);
13371
13372           if (TREE_CODE (value) == INTEGER_CST)
13373             {
13374               value = default_conversion (value);
13375               constant_expression_warning (value);
13376             }
13377           else
13378             {
13379               cp_error ("enumerator value for `%D' not integer constant", name);
13380               value = NULL_TREE;
13381             }
13382         }
13383
13384       /* Default based on previous value.  */
13385       if (value == NULL_TREE && ! processing_template_decl)
13386         {
13387           tree prev_value;
13388
13389           if (TYPE_VALUES (enumtype))
13390             {
13391               /* The next value is the previous value ... */
13392               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13393               /* ... plus one.  */
13394               value = cp_build_binary_op (PLUS_EXPR,
13395                                           prev_value,
13396                                           integer_one_node);
13397
13398               if (tree_int_cst_lt (value, prev_value))
13399                 cp_error ("overflow in enumeration values at `%D'", name);
13400             }
13401           else
13402             value = integer_zero_node;
13403         }
13404
13405       /* Remove no-op casts from the value.  */
13406       if (value)
13407         STRIP_TYPE_NOPS (value);
13408 #if 0
13409       /* To fix MAX_VAL enum consts. (bkoz)  */
13410       TREE_TYPE (value) = integer_type_node;
13411 #endif
13412     }
13413
13414   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13415      Even in other cases, we will later (in finish_enum) be setting
13416      the type of VALUE.  But, we don't need to make a copy if this
13417      VALUE is one of the enumeration constants for this same
13418      enumeration type.  */
13419   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13420     if (TREE_VALUE (values) == value)
13421       break;
13422   /* If we didn't break out of the loop, then we do need a copy.  */
13423   if (!values && value)
13424     value = copy_node (value);
13425
13426   /* C++ associates enums with global, function, or class declarations.  */
13427   context = current_scope ();
13428
13429   /* Build the actual enumeration constant.  Note that the enumeration
13430     constants have the type of their initializers until the
13431     enumeration is complete:
13432
13433       [ dcl.enum ]
13434
13435       Following the closing brace of an enum-specifier, each enumer-
13436       ator has the type of its enumeration.  Prior to the closing
13437       brace, the type of each enumerator is the type of its
13438       initializing value.
13439
13440     In finish_enum we will reset the type.  Of course, if we're
13441     processing a template, there may be no value.   */
13442   type = value ? TREE_TYPE (value) : NULL_TREE;
13443
13444   if (context && context == current_class_type)
13445     /* This enum declaration is local to the class.  We need the full
13446        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13447     decl = build_lang_decl (CONST_DECL, name, type);
13448   else
13449     /* It's a global enum, or it's local to a function.  (Note local to
13450       a function could mean local to a class method.  */
13451     decl = build_decl (CONST_DECL, name, type);
13452
13453   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13454   DECL_INITIAL (decl) = value;
13455   TREE_READONLY (decl) = 1;
13456
13457   if (context && context == current_class_type)
13458     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13459       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13460       things like `S::i' later.)  */
13461     finish_member_declaration (decl);
13462   else
13463     {
13464       pushdecl (decl);
13465       GNU_xref_decl (current_function_decl, decl);
13466     }
13467
13468   /* Add this enumeration constant to the list for this type.  */
13469   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13470 }
13471
13472 \f
13473 /* We're defining DECL.  Make sure that it's type is OK.  */
13474
13475 static void
13476 check_function_type (decl, current_function_parms)
13477      tree decl;
13478      tree current_function_parms;
13479 {
13480   tree fntype = TREE_TYPE (decl);
13481   tree return_type = complete_type (TREE_TYPE (fntype));
13482
13483   /* In a function definition, arg types must be complete.  */
13484   require_complete_types_for_parms (current_function_parms);
13485
13486   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13487     {
13488       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13489
13490       /* Make it return void instead, but don't change the
13491          type of the DECL_RESULT, in case we have a named return value.  */
13492       if (TREE_CODE (fntype) == METHOD_TYPE)
13493         {
13494           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13495           TREE_TYPE (decl)
13496             = build_cplus_method_type (ctype,
13497                                        void_type_node,
13498                                        FUNCTION_ARG_CHAIN (decl));
13499         }
13500       else
13501         TREE_TYPE (decl)
13502           = build_function_type (void_type_node,
13503                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13504       TREE_TYPE (decl)
13505         = build_exception_variant (fntype,
13506                                    TYPE_RAISES_EXCEPTIONS (fntype));
13507     }
13508   else
13509     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13510 }
13511
13512 /* Create the FUNCTION_DECL for a function definition.
13513    DECLSPECS and DECLARATOR are the parts of the declaration;
13514    they describe the function's name and the type it returns,
13515    but twisted together in a fashion that parallels the syntax of C.
13516
13517    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13518    DECLARATOR is really the DECL for the function we are about to
13519    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13520    indicating that the function is an inline defined in-class.
13521
13522    This function creates a binding context for the function body
13523    as well as setting up the FUNCTION_DECL in current_function_decl.
13524
13525    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13526    (it defines a datum instead), we return 0, which tells
13527    yyparse to report a parse error.
13528
13529    For C++, we must first check whether that datum makes any sense.
13530    For example, "class A local_a(1,2);" means that variable local_a
13531    is an aggregate of type A, which should have a constructor
13532    applied to it with the argument list [1, 2].  */
13533
13534 int
13535 start_function (declspecs, declarator, attrs, flags)
13536      tree declspecs, declarator, attrs;
13537      int flags;
13538 {
13539   tree decl1;
13540   tree ctype = NULL_TREE;
13541   tree fntype;
13542   tree restype;
13543   extern int have_extern_spec;
13544   extern int used_extern_spec;
13545   int doing_friend = 0;
13546   struct binding_level *bl;
13547   tree current_function_parms;
13548
13549   /* Sanity check.  */
13550   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13551   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13552
13553   /* This should only be done once on the top most decl.  */
13554   if (have_extern_spec && !used_extern_spec)
13555     {
13556       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13557       used_extern_spec = 1;
13558     }
13559
13560   if (flags & SF_PRE_PARSED)
13561     {
13562       decl1 = declarator;
13563
13564       fntype = TREE_TYPE (decl1);
13565       if (TREE_CODE (fntype) == METHOD_TYPE)
13566         ctype = TYPE_METHOD_BASETYPE (fntype);
13567
13568       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13569          the (lexical) scope of the class in which it is defined.  */
13570       if (!ctype && DECL_FRIEND_P (decl1))
13571         {
13572           ctype = DECL_FRIEND_CONTEXT (decl1);
13573
13574           /* CTYPE could be null here if we're dealing with a template;
13575              for example, `inline friend float foo()' inside a template
13576              will have no CTYPE set.  */
13577           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13578             ctype = NULL_TREE;
13579           else
13580             doing_friend = 1;
13581         }
13582
13583       last_function_parms = DECL_ARGUMENTS (decl1);
13584       last_function_parm_tags = NULL_TREE;
13585     }
13586   else
13587     {
13588       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13589       /* If the declarator is not suitable for a function definition,
13590          cause a syntax error.  */
13591       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13592
13593       fntype = TREE_TYPE (decl1);
13594
13595       restype = TREE_TYPE (fntype);
13596       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13597         {
13598           cp_error ("semicolon missing after declaration of `%#T'", restype);
13599           shadow_tag (build_tree_list (NULL_TREE, restype));
13600           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13601           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13602             fntype = build_function_type (integer_type_node,
13603                                           TYPE_ARG_TYPES (fntype));
13604           else
13605             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13606                                               integer_type_node,
13607                                               TYPE_ARG_TYPES (fntype));
13608           TREE_TYPE (decl1) = fntype;
13609         }
13610
13611       if (TREE_CODE (fntype) == METHOD_TYPE)
13612         ctype = TYPE_METHOD_BASETYPE (fntype);
13613       else if (DECL_MAIN_P (decl1))
13614         {
13615           /* If this doesn't return integer_type, complain.  */
13616           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13617             {
13618               if (pedantic || warn_return_type)
13619                 pedwarn ("return type for `main' changed to `int'");
13620               TREE_TYPE (decl1) = fntype = default_function_type;
13621             }
13622         }
13623     }
13624
13625   /* Sometimes we don't notice that a function is a static member, and
13626      build a METHOD_TYPE for it.  Fix that up now.  */
13627   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13628       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13629     {
13630       revert_static_member_fn (decl1);
13631       last_function_parms = TREE_CHAIN (last_function_parms);
13632       ctype = NULL_TREE;
13633     }
13634
13635   /* Warn if function was previously implicitly declared
13636      (but not if we warned then).  */
13637   if (! warn_implicit
13638       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13639     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13640
13641   /* Set up current_class_type, and enter the scope of the class, if
13642      appropriate.  */
13643   if (ctype)
13644     push_nested_class (ctype, 1);
13645   else if (DECL_STATIC_FUNCTION_P (decl1))
13646     push_nested_class (DECL_CONTEXT (decl1), 2);
13647
13648   /* Now that we have entered the scope of the class, we must restore
13649      the bindings for any template parameters surrounding DECL1, if it
13650      is an inline member template.  (Order is important; consider the
13651      case where a template parameter has the same name as a field of
13652      the class.)  It is not until after this point that
13653      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13654   if (flags & SF_INCLASS_INLINE)
13655     maybe_begin_member_template_processing (decl1);
13656
13657   /* Effective C++ rule 15.  */
13658   if (warn_ecpp
13659       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13660       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13661     cp_warning ("`operator=' should return a reference to `*this'");
13662
13663   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13664      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13665   if (!DECL_INITIAL (decl1))
13666     DECL_INITIAL (decl1) = error_mark_node;
13667
13668 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13669   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13670 #endif
13671
13672   /* This function exists in static storage.
13673      (This does not mean `static' in the C sense!)  */
13674   TREE_STATIC (decl1) = 1;
13675
13676   /* We must call push_template_decl after current_class_type is set
13677      up.  (If we are processing inline definitions after exiting a
13678      class scope, current_class_type will be NULL_TREE until set above
13679      by push_nested_class.)  */
13680   if (processing_template_decl)
13681     decl1 = push_template_decl (decl1);
13682
13683   /* We are now in the scope of the function being defined.  */
13684   current_function_decl = decl1;
13685
13686   /* Save the parm names or decls from this function's declarator
13687      where store_parm_decls will find them.  */
13688   current_function_parms = last_function_parms;
13689   current_function_parm_tags = last_function_parm_tags;
13690
13691   /* Make sure the parameter and return types are reasonable.  When
13692      you declare a function, these types can be incomplete, but they
13693      must be complete when you define the function.  */
13694   if (! processing_template_decl)
13695     check_function_type (decl1, current_function_parms);
13696
13697   /* Build the return declaration for the function.  */
13698   restype = TREE_TYPE (fntype);
13699   if (!processing_template_decl)
13700     {
13701       if (!DECL_RESULT (decl1))
13702         {
13703           DECL_RESULT (decl1)
13704             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13705           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13706                                       DECL_RESULT (decl1));
13707         }
13708     }
13709   else
13710     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13711     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13712
13713   /* Initialize RTL machinery.  We cannot do this until
13714      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13715      even when processing a template; this is how we get
13716      CFUN set up, and our per-function variables initialized.  */
13717   bl = current_binding_level;
13718   init_function_start (decl1, input_filename, lineno);
13719   current_binding_level = bl;
13720
13721   /* Even though we're inside a function body, we still don't want to
13722      call expand_expr to calculate the size of a variable-sized array.
13723      We haven't necessarily assigned RTL to all variables yet, so it's
13724      not safe to try to expand expressions involving them.  */
13725   immediate_size_expand = 0;
13726   cfun->x_dont_save_pending_sizes_p = 1;
13727
13728   /* Start the statement-tree, start the tree now.  */
13729   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13730
13731   /* Let the user know we're compiling this function.  */
13732   announce_function (decl1);
13733
13734   /* Record the decl so that the function name is defined.
13735      If we already have a decl for this name, and it is a FUNCTION_DECL,
13736      use the old decl.  */
13737   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13738     {
13739       /* A specialization is not used to guide overload resolution.  */
13740       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13741           && ! DECL_FUNCTION_MEMBER_P (decl1))
13742         decl1 = pushdecl (decl1);
13743       else
13744         {
13745           /* We need to set the DECL_CONTEXT. */
13746           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13747             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13748           /* And make sure we have enough default args.  */
13749           check_default_args (decl1);
13750         }
13751       fntype = TREE_TYPE (decl1);
13752     }
13753
13754   /* Reset these in case the call to pushdecl changed them.  */
13755   current_function_decl = decl1;
13756   cfun->decl = decl1;
13757
13758   /* If we are (erroneously) defining a function that we have already
13759      defined before, wipe out what we knew before.  */
13760   if (!DECL_PENDING_INLINE_P (decl1)
13761       && DECL_SAVED_FUNCTION_DATA (decl1))
13762     {
13763       free (DECL_SAVED_FUNCTION_DATA (decl1));
13764       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13765     }
13766
13767   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13768     {
13769       /* We know that this was set up by `grokclassfn'.  We do not
13770          wait until `store_parm_decls', since evil parse errors may
13771          never get us to that point.  Here we keep the consistency
13772          between `current_class_type' and `current_class_ptr'.  */
13773       tree t = DECL_ARGUMENTS (decl1);
13774
13775       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13776                           162);
13777       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13778                           19990811);
13779
13780       cp_function_chain->x_current_class_ref
13781         = build_indirect_ref (t, NULL_PTR);
13782       cp_function_chain->x_current_class_ptr = t;
13783
13784       /* Constructors and destructors need to know whether they're "in
13785          charge" of initializing virtual base classes.  */
13786       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13787         current_in_charge_parm = TREE_CHAIN (t);
13788     }
13789
13790   if (DECL_INTERFACE_KNOWN (decl1))
13791     {
13792       tree ctx = decl_function_context (decl1);
13793
13794       if (DECL_NOT_REALLY_EXTERN (decl1))
13795         DECL_EXTERNAL (decl1) = 0;
13796
13797       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13798           && TREE_PUBLIC (ctx))
13799         /* This is a function in a local class in an extern inline
13800            function.  */
13801         comdat_linkage (decl1);
13802     }
13803   /* If this function belongs to an interface, it is public.
13804      If it belongs to someone else's interface, it is also external.
13805      This only affects inlines and template instantiations.  */
13806   else if (interface_unknown == 0
13807            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13808                || flag_alt_external_templates))
13809     {
13810       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13811           || processing_template_decl)
13812         {
13813           DECL_EXTERNAL (decl1)
13814             = (interface_only
13815                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13816                    && !DECL_VINDEX (decl1)));
13817
13818           /* For WIN32 we also want to put these in linkonce sections.  */
13819           maybe_make_one_only (decl1);
13820         }
13821       else
13822         DECL_EXTERNAL (decl1) = 0;
13823       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13824       DECL_INTERFACE_KNOWN (decl1) = 1;
13825     }
13826   else if (interface_unknown && interface_only
13827            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13828                || flag_alt_external_templates))
13829     {
13830       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13831          interface, we will have interface_only set but not
13832          interface_known.  In that case, we don't want to use the normal
13833          heuristics because someone will supply a #pragma implementation
13834          elsewhere, and deducing it here would produce a conflict.  */
13835       comdat_linkage (decl1);
13836       DECL_EXTERNAL (decl1) = 0;
13837       DECL_INTERFACE_KNOWN (decl1) = 1;
13838       DECL_DEFER_OUTPUT (decl1) = 1;
13839     }
13840   else
13841     {
13842       /* This is a definition, not a reference.
13843          So clear DECL_EXTERNAL.  */
13844       DECL_EXTERNAL (decl1) = 0;
13845
13846       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13847           && ! DECL_INTERFACE_KNOWN (decl1)
13848           /* Don't try to defer nested functions for now.  */
13849           && ! decl_function_context (decl1))
13850         DECL_DEFER_OUTPUT (decl1) = 1;
13851       else
13852         DECL_INTERFACE_KNOWN (decl1) = 1;
13853     }
13854
13855   pushlevel (0);
13856   current_binding_level->parm_flag = 1;
13857
13858   if (attrs)
13859     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13860
13861   /* We need to do this even if we aren't expanding yet so that
13862      assemble_external works.  */
13863   make_function_rtl (decl1);
13864
13865   /* Promote the value to int before returning it.  */
13866   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13867     restype = type_promotes_to (restype);
13868
13869   /* If this fcn was already referenced via a block-scope `extern' decl
13870      (or an implicit decl), propagate certain information about the usage.  */
13871   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13872     TREE_ADDRESSABLE (decl1) = 1;
13873
13874   if (DECL_RESULT (decl1) == NULL_TREE)
13875     {
13876       DECL_RESULT (decl1)
13877         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13878       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13879       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13880     }
13881
13882   ++function_depth;
13883
13884   if (DECL_DESTRUCTOR_P (decl1))
13885     {
13886       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13887       DECL_CONTEXT (dtor_label) = current_function_decl;
13888     }
13889   /* Under the old ABI we return `this' from constructors, so we make
13890      ordinary `return' statements in constructors jump to CTOR_LABEL;
13891      from there we return `this'.  Under the new ABI, we don't bother
13892      with any of this.  By not setting CTOR_LABEL the remainder of the
13893      machinery is automatically disabled.  */
13894   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13895     {
13896       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13897       DECL_CONTEXT (ctor_label) = current_function_decl;
13898     }
13899
13900   store_parm_decls (current_function_parms);
13901
13902   return 1;
13903 }
13904 \f
13905 /* Store the parameter declarations into the current function declaration.
13906    This is called after parsing the parameter declarations, before
13907    digesting the body of the function.
13908
13909    Also install to binding contour return value identifier, if any.  */
13910
13911 static void
13912 store_parm_decls (current_function_parms)
13913      tree current_function_parms;
13914 {
13915   register tree fndecl = current_function_decl;
13916   register tree parm;
13917   int parms_have_cleanups = 0;
13918   tree cleanups = NULL_TREE;
13919
13920   /* This is a list of types declared among parms in a prototype.  */
13921   tree parmtags = current_function_parm_tags;
13922
13923   /* This is a chain of any other decls that came in among the parm
13924      declarations.  If a parm is declared with  enum {foo, bar} x;
13925      then CONST_DECLs for foo and bar are put here.  */
13926   tree nonparms = NULL_TREE;
13927
13928   if (current_function_parms)
13929     {
13930       /* This case is when the function was defined with an ANSI prototype.
13931          The parms already have decls, so we need not do anything here
13932          except record them as in effect
13933          and complain if any redundant old-style parm decls were written.  */
13934
13935       tree specparms = current_function_parms;
13936       tree next;
13937
13938       /* Must clear this because it might contain TYPE_DECLs declared
13939              at class level.  */
13940       storedecls (NULL_TREE);
13941
13942       /* If we're doing semantic analysis, then we'll call pushdecl
13943              for each of these.  We must do them in reverse order so that
13944              they end in the correct forward order.  */
13945       specparms = nreverse (specparms);
13946
13947       for (parm = specparms; parm; parm = next)
13948         {
13949           next = TREE_CHAIN (parm);
13950           if (TREE_CODE (parm) == PARM_DECL)
13951             {
13952               tree cleanup;
13953
13954               if (DECL_NAME (parm) == NULL_TREE
13955                   || TREE_CODE (parm) != VOID_TYPE)
13956                 pushdecl (parm);
13957               else
13958                 cp_error ("parameter `%D' declared void", parm);
13959
13960               cleanup = (processing_template_decl
13961                          ? NULL_TREE
13962                          : maybe_build_cleanup (parm));
13963
13964               if (cleanup)
13965                 cleanups = tree_cons (parm, cleanup, cleanups);
13966             }
13967           else
13968             {
13969               /* If we find an enum constant or a type tag,
13970                  put it aside for the moment.  */
13971               TREE_CHAIN (parm) = NULL_TREE;
13972               nonparms = chainon (nonparms, parm);
13973             }
13974         }
13975
13976       /* Get the decls in their original chain order and record in the
13977          function.  This is all and only the PARM_DECLs that were
13978          pushed into scope by the loop above.  */
13979       DECL_ARGUMENTS (fndecl) = getdecls ();
13980       storetags (chainon (parmtags, gettags ()));
13981     }
13982   else
13983     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13984
13985   /* Now store the final chain of decls for the arguments
13986      as the decl-chain of the current lexical scope.
13987      Put the enumerators in as well, at the front so that
13988      DECL_ARGUMENTS is not modified.  */
13989   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13990
13991   /* Now that we have initialized the parms, we can start their
13992      cleanups.  We cannot do this before, since expand_decl_cleanup
13993      should not be called before the parm can be used.  */
13994   while (cleanups)
13995     {
13996       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13997                            TREE_VALUE (cleanups));
13998       cleanups = TREE_CHAIN (cleanups);
13999     }
14000
14001   /* Create a binding contour which can be used to catch
14002      cleanup-generated temporaries.  */
14003   if (parms_have_cleanups)
14004     pushlevel (0);
14005
14006   /* Do the starting of the exception specifications, if we have any.  */
14007   if (flag_exceptions && !processing_template_decl
14008       && flag_enforce_eh_specs
14009       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14010     current_eh_spec_try_block = expand_start_eh_spec ();
14011 }
14012
14013 \f
14014 /* We have finished doing semantic analysis on DECL, but have not yet
14015    generated RTL for its body.  Save away our current state, so that
14016    when we want to generate RTL later we know what to do.  */
14017
14018 static void
14019 save_function_data (decl)
14020      tree decl;
14021 {
14022   struct cp_language_function *f;
14023
14024   /* Save the language-specific per-function data so that we can
14025      get it back when we really expand this function.  */
14026   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14027                       19990908);
14028
14029   /* Make a copy.  */
14030   f = ((struct cp_language_function *)
14031        xmalloc (sizeof (struct cp_language_function)));
14032   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
14033   DECL_SAVED_FUNCTION_DATA (decl) = f;
14034
14035   /* Clear out the bits we don't need.  */
14036   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14037   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14038   f->x_named_label_uses = NULL;
14039   f->bindings = NULL;
14040
14041   /* When we get back here again, we will be expanding.  */
14042   f->x_expanding_p = 1;
14043
14044   /* If we've already decided that we cannot inline this function, we
14045      must remember that fact when we actually go to expand the
14046      function.  */
14047   f->cannot_inline = current_function_cannot_inline;
14048 }
14049
14050 /* At the end of every constructor we generate to code to return
14051    `this'.  Do that now.  */
14052
14053 static void
14054 finish_constructor_body ()
14055 {
14056   /* Any return from a constructor will end up here.  */
14057   if (ctor_label)
14058     add_stmt (build_stmt (LABEL_STMT, ctor_label));
14059
14060   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14061      generate the return, rather than a goto to CTOR_LABEL.  */
14062   ctor_label = NULL_TREE;
14063   /* In check_return_expr we translate an empty return from a
14064      constructor to a return of `this'.  */
14065   finish_return_stmt (NULL_TREE);
14066   /* Mark the end of the constructor.  */
14067   add_stmt (build_stmt (CTOR_STMT));
14068 }
14069
14070 /* At the end of every destructor we generate code to restore virtual
14071    function tables to the values desired by base classes and to call
14072    to base class destructors.  Do that now.  */
14073
14074 static void
14075 finish_destructor_body ()
14076 {
14077   tree compound_stmt;
14078   tree virtual_size;
14079   tree exprstmt;
14080   tree if_stmt;
14081
14082   /* Create a block to contain all the extra code.  */
14083   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14084
14085   /* Any return from a destructor will end up here.  */
14086   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14087
14088   /* Generate the code to call destructor on base class.  If this
14089      destructor belongs to a class with virtual functions, then set
14090      the virtual function table pointer to represent the type of our
14091      base class.  */
14092
14093   /* This side-effect makes call to `build_delete' generate the code
14094      we have to have at the end of this destructor.  `build_delete'
14095      will set the flag again.  */
14096   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14097
14098   exprstmt = build_delete (current_class_type,
14099                            current_class_ref,
14100                            sfk_base_destructor,
14101                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14102                            0);
14103
14104   if (exprstmt != error_mark_node
14105       && (TREE_CODE (exprstmt) != NOP_EXPR
14106           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14107           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14108     {
14109       if (exprstmt != void_zero_node)
14110         /* Don't call `expand_expr_stmt' if we're not going to do
14111            anything, since -Wall will give a diagnostic.  */
14112         finish_expr_stmt (exprstmt);
14113
14114       /* Run destructors for all virtual baseclasses.  */
14115       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14116         {
14117           tree vbases;
14118           tree if_stmt;
14119
14120           if_stmt = begin_if_stmt ();
14121           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14122                                       current_in_charge_parm,
14123                                       integer_two_node),
14124                                if_stmt);
14125
14126           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14127           /* The CLASSTYPE_VBASECLASSES list is in initialization
14128              order, so we have to march through it in reverse order.  */
14129           for (vbases = nreverse (copy_list (vbases));
14130                vbases;
14131                vbases = TREE_CHAIN (vbases))
14132             {
14133               tree vbase = TREE_VALUE (vbases);
14134
14135               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14136                 {
14137                   tree vb = get_vbase
14138                     (BINFO_TYPE (vbase),
14139                      TYPE_BINFO (current_class_type));
14140                   finish_expr_stmt
14141                     (build_scoped_method_call
14142                      (current_class_ref, vb, base_dtor_identifier,
14143                       NULL_TREE));
14144                 }
14145             }
14146
14147           finish_then_clause (if_stmt);
14148           finish_if_stmt ();
14149         }
14150     }
14151
14152   virtual_size = c_sizeof (current_class_type);
14153
14154   /* At the end, call delete if that's what's requested.  */
14155
14156   /* FDIS sez: At the point of definition of a virtual destructor
14157      (including an implicit definition), non-placement operator delete
14158      shall be looked up in the scope of the destructor's class and if
14159      found shall be accessible and unambiguous.
14160
14161      This is somewhat unclear, but I take it to mean that if the class
14162      only defines placement deletes we don't do anything here.  So we
14163      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14164      they ever try to delete one of these.  */
14165   exprstmt = build_op_delete_call
14166     (DELETE_EXPR, current_class_ptr, virtual_size,
14167      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14168
14169   if_stmt = begin_if_stmt ();
14170   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14171                               current_in_charge_parm,
14172                               integer_one_node),
14173                        if_stmt);
14174   finish_expr_stmt (exprstmt);
14175   finish_then_clause (if_stmt);
14176   finish_if_stmt ();
14177
14178   /* Close the block we started above.  */
14179   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14180 }
14181
14182 /* Finish up a function declaration and compile that function
14183    all the way to assembler language output.  The free the storage
14184    for the function definition.
14185
14186    FLAGS is a bitwise or of the following values:
14187      1 - CALL_POPLEVEL
14188        An extra call to poplevel (and expand_end_bindings) must be
14189        made to take care of the binding contour for the base
14190        initializers.  This is only relevant for constructors.
14191      2 - INCLASS_INLINE
14192        We just finished processing the body of an in-class inline
14193        function definition.  (This processing will have taken place
14194        after the class definition is complete.)  */
14195
14196 tree
14197 finish_function (flags)
14198      int flags;
14199 {
14200   register tree fndecl = current_function_decl;
14201   tree fntype, ctype = NULL_TREE;
14202   int call_poplevel = (flags & 1) != 0;
14203   int inclass_inline = (flags & 2) != 0;
14204   int nested;
14205
14206   /* When we get some parse errors, we can end up without a
14207      current_function_decl, so cope.  */
14208   if (fndecl == NULL_TREE)
14209     return error_mark_node;
14210
14211   nested = function_depth > 1;
14212   fntype = TREE_TYPE (fndecl);
14213
14214   /*  TREE_READONLY (fndecl) = 1;
14215       This caused &foo to be of type ptr-to-const-function
14216       which then got a warning when stored in a ptr-to-function variable.  */
14217
14218   my_friendly_assert (building_stmt_tree (), 20000911);
14219
14220   /* For a cloned function, we've already got all the code we need;
14221      there's no need to add any extra bits.  */
14222   if (!DECL_CLONED_FUNCTION_P (fndecl))
14223     {
14224       if (DECL_CONSTRUCTOR_P (fndecl))
14225         {
14226           finish_constructor_body ();
14227           if (call_poplevel)
14228             do_poplevel ();
14229         }
14230       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14231         finish_destructor_body ();
14232       else if (DECL_MAIN_P (fndecl))
14233         {
14234           /* Make it so that `main' always returns 0 by default.  */
14235 #ifdef VMS
14236           finish_return_stmt (integer_one_node);
14237 #else
14238           finish_return_stmt (integer_zero_node);
14239 #endif
14240         }
14241
14242       /* Finish dealing with exception specifiers.  */
14243       if (flag_exceptions && !processing_template_decl
14244           && flag_enforce_eh_specs
14245           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14246         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14247                             (TREE_TYPE (current_function_decl)),
14248                             current_eh_spec_try_block);
14249     }
14250
14251   /* If we're saving up tree structure, tie off the function now.  */
14252   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14253
14254   /* This must come after expand_function_end because cleanups might
14255      have declarations (from inline functions) that need to go into
14256      this function's blocks.  */
14257   if (current_binding_level->parm_flag != 1)
14258     my_friendly_abort (122);
14259   poplevel (1, 0, 1);
14260
14261   /* Remember that we were in class scope.  */
14262   if (current_class_name)
14263     ctype = current_class_type;
14264
14265   /* Must mark the RESULT_DECL as being in this function.  */
14266   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14267
14268   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14269      to the FUNCTION_DECL node itself.  */
14270   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14271
14272   /* Save away current state, if appropriate.  */
14273   if (!processing_template_decl)
14274     save_function_data (fndecl);
14275
14276   /* If this function calls `setjmp' it cannot be inlined.  When
14277      `longjmp' is called it is not guaranteed to restore the value of
14278      local variables that have been modified since the call to
14279      `setjmp'.  So, if were to inline this function into some caller
14280      `c', then when we `longjmp', we might not restore all variables
14281      in `c'.  (It might seem, at first blush, that there's no way for
14282      this function to modify local variables in `c', but their
14283      addresses may have been stored somewhere accessible to this
14284      function.)  */
14285   if (!processing_template_decl && calls_setjmp_p (fndecl))
14286     DECL_UNINLINABLE (fndecl) = 1;
14287
14288   /* Clear out memory we no longer need.  */
14289   free_after_parsing (cfun);
14290   /* Since we never call rest_of_compilation, we never clear
14291      CFUN.  Do so explicitly.  */
14292   free_after_compilation (cfun);
14293   cfun = NULL;
14294
14295   /* If this is a in-class inline definition, we may have to pop the
14296      bindings for the template parameters that we added in
14297      maybe_begin_member_template_processing when start_function was
14298      called.  */
14299   if (inclass_inline)
14300     maybe_end_member_template_processing ();
14301
14302   /* Leave the scope of the class.  */
14303   if (ctype)
14304     pop_nested_class ();
14305
14306   --function_depth;
14307
14308   /* Clean up.  */
14309   if (! nested)
14310     /* Let the error reporting routines know that we're outside a
14311        function.  For a nested function, this value is used in
14312        pop_cp_function_context and then reset via pop_function_context.  */
14313     current_function_decl = NULL_TREE;
14314
14315   return fndecl;
14316 }
14317 \f
14318 /* Create the FUNCTION_DECL for a function definition.
14319    DECLSPECS and DECLARATOR are the parts of the declaration;
14320    they describe the return type and the name of the function,
14321    but twisted together in a fashion that parallels the syntax of C.
14322
14323    This function creates a binding context for the function body
14324    as well as setting up the FUNCTION_DECL in current_function_decl.
14325
14326    Returns a FUNCTION_DECL on success.
14327
14328    If the DECLARATOR is not suitable for a function (it defines a datum
14329    instead), we return 0, which tells yyparse to report a parse error.
14330
14331    May return void_type_node indicating that this method is actually
14332    a friend.  See grokfield for more details.
14333
14334    Came here with a `.pushlevel' .
14335
14336    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14337    CHANGES TO CODE IN `grokfield'.  */
14338
14339 tree
14340 start_method (declspecs, declarator, attrlist)
14341      tree declarator, declspecs, attrlist;
14342 {
14343   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14344                                 attrlist);
14345
14346   /* Something too ugly to handle.  */
14347   if (fndecl == NULL_TREE)
14348     return NULL_TREE;
14349
14350   /* Pass friends other than inline friend functions back.  */
14351   if (fndecl == void_type_node)
14352     return fndecl;
14353
14354   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14355     /* Not a function, tell parser to report parse error.  */
14356     return NULL_TREE;
14357
14358   if (DECL_IN_AGGR_P (fndecl))
14359     {
14360       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14361         {
14362           if (DECL_CONTEXT (fndecl)
14363               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14364             cp_error ("`%D' is already defined in class `%T'", fndecl,
14365                       DECL_CONTEXT (fndecl));
14366         }
14367       return void_type_node;
14368     }
14369
14370   check_template_shadow (fndecl);
14371
14372   DECL_THIS_INLINE (fndecl) = 1;
14373
14374   if (flag_default_inline)
14375     DECL_INLINE (fndecl) = 1;
14376
14377   /* We process method specializations in finish_struct_1.  */
14378   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14379     fndecl = push_template_decl (fndecl);
14380
14381   if (! DECL_FRIEND_P (fndecl))
14382     {
14383       if (TREE_CHAIN (fndecl))
14384         {
14385           fndecl = copy_node (fndecl);
14386           TREE_CHAIN (fndecl) = NULL_TREE;
14387         }
14388
14389       if (DECL_CONSTRUCTOR_P (fndecl))
14390         {
14391           if (! grok_ctor_properties (current_class_type, fndecl))
14392             return void_type_node;
14393         }
14394       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14395         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14396     }
14397
14398   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14399
14400   /* Make a place for the parms */
14401   pushlevel (0);
14402   current_binding_level->parm_flag = 1;
14403
14404   DECL_IN_AGGR_P (fndecl) = 1;
14405   return fndecl;
14406 }
14407
14408 /* Go through the motions of finishing a function definition.
14409    We don't compile this method until after the whole class has
14410    been processed.
14411
14412    FINISH_METHOD must return something that looks as though it
14413    came from GROKFIELD (since we are defining a method, after all).
14414
14415    This is called after parsing the body of the function definition.
14416    STMTS is the chain of statements that makes up the function body.
14417
14418    DECL is the ..._DECL that `start_method' provided.  */
14419
14420 tree
14421 finish_method (decl)
14422      tree decl;
14423 {
14424   register tree fndecl = decl;
14425   tree old_initial;
14426
14427   register tree link;
14428
14429   if (decl == void_type_node)
14430     return decl;
14431
14432   old_initial = DECL_INITIAL (fndecl);
14433
14434   /* Undo the level for the parms (from start_method).
14435      This is like poplevel, but it causes nothing to be
14436      saved.  Saving information here confuses symbol-table
14437      output routines.  Besides, this information will
14438      be correctly output when this method is actually
14439      compiled.  */
14440
14441   /* Clear out the meanings of the local variables of this level;
14442      also record in each decl which block it belongs to.  */
14443
14444   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14445     {
14446       if (DECL_NAME (link) != NULL_TREE)
14447         pop_binding (DECL_NAME (link), link);
14448       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14449       DECL_CONTEXT (link) = NULL_TREE;
14450     }
14451
14452   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14453                       (HOST_WIDE_INT) current_binding_level->level_chain,
14454                       current_binding_level->parm_flag,
14455                       current_binding_level->keep);
14456
14457   poplevel (0, 0, 0);
14458
14459   DECL_INITIAL (fndecl) = old_initial;
14460
14461   /* We used to check if the context of FNDECL was different from
14462      current_class_type as another way to get inside here.  This didn't work
14463      for String.cc in libg++.  */
14464   if (DECL_FRIEND_P (fndecl))
14465     {
14466       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14467         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14468       decl = void_type_node;
14469     }
14470
14471   return decl;
14472 }
14473 \f
14474 /* Called when a new struct TYPE is defined.
14475    If this structure or union completes the type of any previous
14476    variable declaration, lay it out and output its rtl.  */
14477
14478 void
14479 hack_incomplete_structures (type)
14480      tree type;
14481 {
14482   tree *list;
14483   struct binding_level *level;
14484
14485   if (!type) /* Don't do this for class templates.  */
14486     return;
14487
14488   if (namespace_bindings_p ())
14489     {
14490       level = 0;
14491       list = &namespace_scope_incomplete;
14492     }
14493   else
14494     {
14495       level = innermost_nonclass_level ();
14496       list = &level->incomplete;
14497     }
14498
14499   while (1)
14500     {
14501       while (*list)
14502         {
14503           tree decl = TREE_VALUE (*list);
14504           if ((decl && TREE_TYPE (decl) == type)
14505               || (TREE_TYPE (decl)
14506                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14507                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14508             {
14509               int toplevel = toplevel_bindings_p ();
14510               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14511                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14512                 layout_type (TREE_TYPE (decl));
14513               layout_decl (decl, 0);
14514               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14515               if (! toplevel)
14516                 {
14517                   tree cleanup;
14518                   expand_decl (decl);
14519                   cleanup = maybe_build_cleanup (decl);
14520                   expand_decl_init (decl);
14521                   if (! expand_decl_cleanup (decl, cleanup))
14522                     cp_error ("parser lost in parsing declaration of `%D'",
14523                               decl);
14524                 }
14525               *list = TREE_CHAIN (*list);
14526             }
14527           else
14528             list = &TREE_CHAIN (*list);
14529         }
14530
14531       /* Keep looking through artificial binding levels generated
14532          for local variables.  */
14533       if (level && level->keep == 2)
14534         {
14535           level = level->level_chain;
14536           list = &level->incomplete;
14537         }
14538       else
14539         break;
14540     }
14541 }
14542
14543 /* If DECL is of a type which needs a cleanup, build that cleanup
14544    here.  */
14545
14546 tree
14547 maybe_build_cleanup (decl)
14548      tree decl;
14549 {
14550   tree type = TREE_TYPE (decl);
14551
14552   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14553     {
14554       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14555       tree rval;
14556
14557       if (TREE_CODE (type) == ARRAY_TYPE)
14558         rval = decl;
14559       else
14560         {
14561           mark_addressable (decl);
14562           rval = build_unary_op (ADDR_EXPR, decl, 0);
14563         }
14564
14565       /* Optimize for space over speed here.  */
14566       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14567           || flag_expensive_optimizations)
14568         flags |= LOOKUP_NONVIRTUAL;
14569
14570       rval = build_delete (TREE_TYPE (rval), rval,
14571                            sfk_complete_destructor, flags, 0);
14572
14573       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14574           && ! TYPE_HAS_DESTRUCTOR (type))
14575         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14576                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14577
14578       return rval;
14579     }
14580   return 0;
14581 }
14582 \f
14583 /* When a stmt has been parsed, this function is called.  */
14584
14585 void
14586 finish_stmt ()
14587 {
14588   /* Always assume this statement was not an expression statement.  If
14589      it actually was an expression statement, its our callers
14590      responsibility to fix this up.  */
14591   last_expr_type = NULL_TREE;
14592 }
14593
14594 /* DECL was originally constructed as a non-static member function,
14595    but turned out to be static.  Update it accordingly.  */
14596
14597 void
14598 revert_static_member_fn (decl)
14599      tree decl;
14600 {
14601   tree tmp;
14602   tree function = TREE_TYPE (decl);
14603   tree args = TYPE_ARG_TYPES (function);
14604
14605   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14606       != TYPE_UNQUALIFIED)
14607     cp_error ("static member function `%#D' declared with type qualifiers",
14608               decl);
14609
14610   args = TREE_CHAIN (args);
14611   tmp = build_function_type (TREE_TYPE (function), args);
14612   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14613   tmp = build_exception_variant (tmp,
14614                                  TYPE_RAISES_EXCEPTIONS (function));
14615   TREE_TYPE (decl) = tmp;
14616   if (DECL_ARGUMENTS (decl))
14617     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14618   DECL_STATIC_FUNCTION_P (decl) = 1;
14619 }
14620
14621 /* Initialize the variables used during compilation of a C++
14622    function.  */
14623
14624 static void
14625 push_cp_function_context (f)
14626      struct function *f;
14627 {
14628   struct cp_language_function *p
14629     = ((struct cp_language_function *)
14630        xcalloc (1, sizeof (struct cp_language_function)));
14631   f->language = (struct language_function *) p;
14632
14633   /* It takes an explicit call to expand_body to generate RTL for a
14634      function.  */
14635   expanding_p = 0;
14636
14637   /* Whenever we start a new function, we destroy temporaries in the
14638      usual way.  */
14639   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14640 }
14641
14642 /* Free the language-specific parts of F, now that we've finished
14643    compiling the function.  */
14644
14645 static void
14646 pop_cp_function_context (f)
14647      struct function *f;
14648 {
14649   if (f->language)
14650     free (f->language);
14651   f->language = 0;
14652 }
14653
14654 /* Mark P for GC.  */
14655
14656 static void
14657 mark_lang_function (p)
14658      struct cp_language_function *p;
14659 {
14660   if (!p)
14661     return;
14662
14663   mark_c_language_function (&p->base);
14664
14665   ggc_mark_tree (p->x_ctor_label);
14666   ggc_mark_tree (p->x_dtor_label);
14667   ggc_mark_tree (p->x_current_class_ptr);
14668   ggc_mark_tree (p->x_current_class_ref);
14669   ggc_mark_tree (p->x_eh_spec_try_block);
14670
14671   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14672   mark_binding_level (&p->bindings);
14673 }
14674
14675 /* Mark the language-specific data in F for GC.  */
14676
14677 static void
14678 mark_cp_function_context (f)
14679      struct function *f;
14680 {
14681   mark_lang_function ((struct cp_language_function *) f->language);
14682 }
14683
14684 void
14685 lang_mark_tree (t)
14686      tree t;
14687 {
14688   enum tree_code code = TREE_CODE (t);
14689   if (code == IDENTIFIER_NODE)
14690     {
14691       struct lang_identifier *li = (struct lang_identifier *) t;
14692       struct lang_id2 *li2 = li->x;
14693       ggc_mark_tree (li->namespace_bindings);
14694       ggc_mark_tree (li->bindings);
14695       ggc_mark_tree (li->class_value);
14696       ggc_mark_tree (li->class_template_info);
14697
14698       if (li2)
14699         {
14700           ggc_mark_tree (li2->label_value);
14701           ggc_mark_tree (li2->implicit_decl);
14702           ggc_mark_tree (li2->error_locus);
14703         }
14704     }
14705   else if (code == CPLUS_BINDING)
14706     {
14707       if (BINDING_HAS_LEVEL_P (t))
14708         mark_binding_level (&BINDING_LEVEL (t));
14709       else
14710         ggc_mark_tree (BINDING_SCOPE (t));
14711       ggc_mark_tree (BINDING_VALUE (t));
14712     }
14713   else if (code == OVERLOAD)
14714     ggc_mark_tree (OVL_FUNCTION (t));
14715   else if (code == TEMPLATE_PARM_INDEX)
14716     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14717   else if (TREE_CODE_CLASS (code) == 'd')
14718     {
14719       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14720
14721       if (ld)
14722         {
14723           ggc_mark (ld);
14724           c_mark_lang_decl (&ld->decl_flags.base);
14725           if (!DECL_GLOBAL_CTOR_P (t)
14726               && !DECL_GLOBAL_DTOR_P (t)
14727               && !DECL_THUNK_P (t))
14728             ggc_mark_tree (ld->decl_flags.u2.access);
14729           else if (DECL_THUNK_P (t))
14730             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14731           if (TREE_CODE (t) != NAMESPACE_DECL)
14732             ggc_mark_tree (ld->decl_flags.u.template_info);
14733           else
14734             mark_binding_level (&NAMESPACE_LEVEL (t));
14735           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14736             {
14737               ggc_mark_tree (ld->befriending_classes);
14738               ggc_mark_tree (ld->context);
14739               ggc_mark_tree (ld->cloned_function);
14740               if (!DECL_OVERLOADED_OPERATOR_P (t))
14741                 ggc_mark_tree (ld->u2.vtt_parm);
14742               if (TREE_CODE (t) == TYPE_DECL)
14743                 ggc_mark_tree (ld->u.sorted_fields);
14744               else if (TREE_CODE (t) == FUNCTION_DECL
14745                        && !DECL_PENDING_INLINE_P (t))
14746                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14747             }
14748         }
14749     }
14750   else if (TREE_CODE_CLASS (code) == 't')
14751     {
14752       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14753
14754       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14755                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14756         {
14757           ggc_mark (lt);
14758           ggc_mark_tree (lt->primary_base);
14759           ggc_mark_tree (lt->vfields);
14760           ggc_mark_tree (lt->vbases);
14761           ggc_mark_tree (lt->tags);
14762           ggc_mark_tree (lt->size);
14763           ggc_mark_tree (lt->pure_virtuals);
14764           ggc_mark_tree (lt->friend_classes);
14765           ggc_mark_tree (lt->rtti);
14766           ggc_mark_tree (lt->methods);
14767           ggc_mark_tree (lt->template_info);
14768           ggc_mark_tree (lt->befriending_classes);
14769         }
14770       else if (lt)
14771         /* In the case of pointer-to-member function types, the
14772            TYPE_LANG_SPECIFIC is really just a tree.  */
14773         ggc_mark_tree ((tree) lt);
14774     }
14775 }