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 "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 133 static void check_for_uninitialized_const_var PARAMS ((tree));
 134 static unsigned long typename_hash PARAMS ((hash_table_key));
 135 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 136 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 137 static int add_binding PARAMS ((tree, tree));
 138 static void pop_binding PARAMS ((tree, tree));
 139 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 140 static tree find_binding PARAMS ((tree, tree));
 141 static tree select_decl PARAMS ((tree, int));
 142 static int lookup_flags PARAMS ((int, int));
 143 static tree qualify_lookup PARAMS ((tree, int));
 144 static tree record_builtin_java_type PARAMS ((const char *, int));
 145 static const char *tag_name PARAMS ((enum tag_types code));
 146 static void find_class_binding_level PARAMS ((void));
 147 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 148 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 149 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 150 static int walk_globals_r PARAMS ((tree, void *));
 151 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 152 static tree make_label_decl PARAMS ((tree, int));
 153 static void use_label PARAMS ((tree));
 154 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 155                                            const char *, int));
 156 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 157 static void check_switch_goto PARAMS ((struct binding_level *));
 158 static void check_previous_gotos PARAMS ((tree));
 159 static void pop_label PARAMS ((tree, tree));
 160 static void pop_labels PARAMS ((tree));
 161 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 162 static void layout_var_decl PARAMS ((tree));
 163 static void maybe_commonize_var PARAMS ((tree));
 164 static tree check_initializer PARAMS ((tree, tree));
 165 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 166 static void push_cp_function_context PARAMS ((struct function *));
 167 static void pop_cp_function_context PARAMS ((struct function *));
 168 static void mark_binding_level PARAMS ((void *));
 169 static void mark_named_label_lists PARAMS ((void *, void *));
 170 static void mark_cp_function_context PARAMS ((struct function *));
 171 static void mark_saved_scope PARAMS ((void *));
 172 static void mark_lang_function PARAMS ((struct language_function *));
 173 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 174 static void save_function_data PARAMS ((tree));
 175 static void check_function_type PARAMS ((tree));
 176 static void destroy_local_var PARAMS ((tree));
 177 static void finish_constructor_body PARAMS ((void));
 178 static void finish_destructor_body PARAMS ((void));
 179 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 180 static tree get_atexit_node PARAMS ((void));
 181 static tree get_dso_handle_node PARAMS ((void));
 182 static tree start_cleanup_fn PARAMS ((void));
 183 static void end_cleanup_fn PARAMS ((void));
 184 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 185 static void initialize_predefined_identifiers PARAMS ((void));
 186 static tree check_special_function_return_type
 187   PARAMS ((special_function_kind, tree, tree, tree));
 188 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 189 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 190
 191 #if defined (DEBUG_CP_BINDING_LEVELS)
 192 static void indent PARAMS ((void));
 193 #endif
 194
 195 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 196 tree error_mark_list;
 197
 198 /* The following symbols are subsumed in the cp_global_trees array, and
 199    listed here individually for documentation purposes.
 200
 201    C++ extensions
 202         tree wchar_decl_node;
 203         tree void_zero_node;
 204
 205         tree vtable_entry_type;
 206         tree delta_type_node;
 207 #if 0
 208    Old rtti stuff.
 209         tree __baselist_desc_type_node;
 210         tree __i_desc_type_node, __m_desc_type_node;
 211         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 212 #endif
 213         tree __t_desc_type_node;
 214 #if 0
 215         tree __tp_desc_type_node;
 216 #endif
 217         tree ti_desc_type_node;
 218         tree bltn_desc_type_node, ptr_desc_type_node;
 219         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 220         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 221         tree ptm_desc_type_node;
 222         tree base_desc_type_node;
 223 #if 0
 224    Not needed yet?  May be needed one day?
 225         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 226         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 227         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 228 #endif
 229
 230         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 231         tree unknown_type_node;
 232
 233    Array type `vtable_entry_type[]'
 234
 235         tree vtbl_type_node;
 236         tree vtbl_ptr_type_node;
 237
 238    Namespaces,
 239
 240         tree std_node;
 241         tree abi_node;
 242
 243    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 244    one that the user will declare, but sufficient to be called
 245    by routines that want to abort the program.
 246
 247         tree abort_fndecl;
 248
 249    The FUNCTION_DECL for the default `::operator delete'.
 250
 251         tree global_delete_fndecl;
 252
 253    Used by RTTI
 254         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 255         tree tinfo_var_id;
 256
 257 */
 258
 259 tree cp_global_trees[CPTI_MAX];
 260
 261 /* Indicates that there is a type value in some namespace, although
 262    that is not necessarily in scope at the moment.  */
 263
 264 static tree global_type_node;
 265
 266 /* Namespace std.  */
 267 int in_std;
 268
 269 /* Expect only namespace names now. */
 270 static int only_namespace_names;
 271
 272 /* If original DECL_RESULT of current function was a register,
 273    but due to being an addressable named return value, would up
 274    on the stack, this variable holds the named return value's
 275    original location.  */
 276
 277 #define original_result_rtx cp_function_chain->x_result_rtx
 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 means don't recognize any builtin functions.  */
 361
 362 extern int flag_no_builtin;
 363
 364 /* Nonzero means don't recognize the non-ANSI builtin functions.
 365    -ansi sets this.  */
 366
 367 extern int flag_no_nonansi_builtin;
 368
 369 /* Nonzero if we want to conserve space in the .o files.  We do this
 370    by putting uninitialized data and runtime initialized data into
 371    .common instead of .data at the expense of not flagging multiple
 372    definitions.  */
 373 extern int flag_conserve_space;
 374 \f
 375 /* C and C++ flags are in decl2.c.  */
 376
 377 /* Flag used when debugging spew.c */
 378
 379 extern int spew_debug;
 380
 381 /* A expression of value 0 with the same precision as a sizetype
 382    node, but signed.  */
 383 tree signed_size_zero_node;
 384
 385 /* The name of the anonymous namespace, throughout this translation
 386    unit.  */
 387 tree anonymous_namespace_name;
 388
 389 /* The number of function bodies which we are currently processing.
 390    (Zero if we are at namespace scope, one inside the body of a
 391    function, two inside the body of a function in a local class, etc.)  */
 392 int function_depth;
 393 \f
 394 /* For each binding contour we allocate a binding_level structure
 395    which records the names defined in that contour.
 396    Contours include:
 397     0) the global one
 398     1) one for each function definition,
 399        where internal declarations of the parameters appear.
 400     2) one for each compound statement,
 401        to record its declarations.
 402
 403    The current meaning of a name can be found by searching the levels
 404    from the current one out to the global one.
 405
 406    Off to the side, may be the class_binding_level.  This exists only
 407    to catch class-local declarations.  It is otherwise nonexistent.
 408
 409    Also there may be binding levels that catch cleanups that must be
 410    run when exceptions occur.  Thus, to see whether a name is bound in
 411    the current scope, it is not enough to look in the
 412    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 413    instead.  */
 414
 415 /* Note that the information in the `names' component of the global contour
 416    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 417
 418 struct binding_level
 419   {
 420     /* A chain of _DECL nodes for all variables, constants, functions,
 421        and typedef types.  These are in the reverse of the order
 422        supplied.  There may be OVERLOADs on this list, too, but they
 423        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 424     tree names;
 425
 426     /* A list of structure, union and enum definitions, for looking up
 427        tag names.
 428        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 429        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 430        or ENUMERAL_TYPE node.
 431
 432        C++: the TREE_VALUE nodes can be simple types for
 433        component_bindings.  */
 434     tree tags;
 435
 436     /* A list of USING_DECL nodes. */
 437     tree usings;
 438
 439     /* A list of used namespaces. PURPOSE is the namespace,
 440        VALUE the common ancestor with this binding_level's namespace. */
 441     tree using_directives;
 442
 443     /* If this binding level is the binding level for a class, then
 444        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 445        is the name of an entity bound in the class; the TREE_VALUE is
 446        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 447        when leaving class scope, we can restore the
 448        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 449        the DECL bound by this name in the class.  */
 450     tree class_shadowed;
 451
 452     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 453        is used for all binding levels.  */
 454     tree type_shadowed;
 455
 456     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 457        label in this scope.  The TREE_PURPOSE is the previous value of
 458        the IDENTIFIER_LABEL VALUE.  */
 459     tree shadowed_labels;
 460
 461     /* For each level (except not the global one),
 462        a chain of BLOCK nodes for all the levels
 463        that were entered and exited one level down.  */
 464     tree blocks;
 465
 466     /* The BLOCK node for this level, if one has been preallocated.
 467        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 468     tree this_block;
 469
 470     /* The _TYPE node for this level, if parm_flag == 2.  */
 471     tree this_class;
 472
 473     /* The binding level which this one is contained in (inherits from).  */
 474     struct binding_level *level_chain;
 475
 476     /* List of decls in `names' that have incomplete
 477        structure or union types.  */
 478     tree incomplete;
 479
 480     /* List of VAR_DECLS saved from a previous for statement.
 481        These would be dead in ISO-conforming code, but might
 482        be referenced in ARM-era code.  These are stored in a
 483        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 484     tree dead_vars_from_for;
 485
 486     /* 1 for the level that holds the parameters of a function.
 487        2 for the level that holds a class declaration.  */
 488     unsigned parm_flag : 2;
 489
 490     /* 1 means make a BLOCK for this level regardless of all else.
 491        2 for temporary binding contours created by the compiler.  */
 492     unsigned keep : 2;
 493
 494     /* Nonzero if this level "doesn't exist" for tags.  */
 495     unsigned tag_transparent : 1;
 496
 497     /* Nonzero if this level can safely have additional
 498        cleanup-needing variables added to it.  */
 499     unsigned more_cleanups_ok : 1;
 500     unsigned have_cleanups : 1;
 501
 502     /* Nonzero if this scope is for storing the decls for template
 503        parameters and generic decls; these decls will be discarded and
 504        replaced with a TEMPLATE_DECL.  */
 505     unsigned template_parms_p : 1;
 506
 507     /* Nonzero if this scope corresponds to the `<>' in a
 508        `template <>' clause.  Whenever this flag is set,
 509        TEMPLATE_PARMS_P will be set as well.  */
 510     unsigned template_spec_p : 1;
 511
 512     /* This is set for a namespace binding level.  */
 513     unsigned namespace_p : 1;
 514
 515     /* True if this level is that of a for-statement where we need to
 516        worry about ambiguous (ARM or ISO) scope rules.  */
 517     unsigned is_for_scope : 1;
 518
 519     /* True if this level corresponds to an EH region, as for a try block.
 520        Currently this information is only available while building the
 521        tree structure.  */
 522     unsigned eh_region : 1;
 523
 524     /* Four bits left for this word.  */
 525
 526 #if defined(DEBUG_CP_BINDING_LEVELS)
 527     /* Binding depth at which this level began.  */
 528     unsigned binding_depth;
 529 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 530   };
 531
 532 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 533
 534 /* The binding level currently in effect.  */
 535
 536 #define current_binding_level                   \
 537   (cfun                                         \
 538    ? cp_function_chain->bindings                \
 539    : scope_chain->bindings)
 540
 541 /* The binding level of the current class, if any.  */
 542
 543 #define class_binding_level scope_chain->class_bindings
 544
 545 /* A chain of binding_level structures awaiting reuse.  */
 546
 547 static struct binding_level *free_binding_level;
 548
 549 /* The outermost binding level, for names of file scope.
 550    This is created when the compiler is started and exists
 551    through the entire run.  */
 552
 553 static struct binding_level *global_binding_level;
 554
 555 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 556
 557 static int keep_next_level_flag;
 558
 559 #if defined(DEBUG_CP_BINDING_LEVELS)
 560 static int binding_depth = 0;
 561 static int is_class_level = 0;
 562
 563 static void
 564 indent ()
 565 {
 566   register unsigned i;
 567
 568   for (i = 0; i < binding_depth*2; i++)
 569     putc (' ', stderr);
 570 }
 571 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 572
 573 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 574
 575 static void
 576 push_binding_level (newlevel, tag_transparent, keep)
 577      struct binding_level *newlevel;
 578      int tag_transparent, keep;
 579 {
 580   /* Add this level to the front of the chain (stack) of levels that
 581      are active.  */
 582   bzero ((char*) newlevel, sizeof (struct binding_level));
 583   newlevel->level_chain = current_binding_level;
 584   current_binding_level = newlevel;
 585   newlevel->tag_transparent = tag_transparent;
 586   newlevel->more_cleanups_ok = 1;
 587
 588   newlevel->keep = keep;
 589 #if defined(DEBUG_CP_BINDING_LEVELS)
 590   newlevel->binding_depth = binding_depth;
 591   indent ();
 592   fprintf (stderr, "push %s level 0x%08x line %d\n",
 593            (is_class_level) ? "class" : "block", newlevel, lineno);
 594   is_class_level = 0;
 595   binding_depth++;
 596 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 597 }
 598
 599 /* Find the innermost enclosing class scope, and reset
 600    CLASS_BINDING_LEVEL appropriately.  */
 601
 602 static void
 603 find_class_binding_level ()
 604 {
 605   struct binding_level *level = current_binding_level;
 606
 607   while (level && level->parm_flag != 2)
 608     level = level->level_chain;
 609   if (level && level->parm_flag == 2)
 610     class_binding_level = level;
 611   else
 612     class_binding_level = 0;
 613 }
 614
 615 static void
 616 pop_binding_level ()
 617 {
 618   if (global_binding_level)
 619     {
 620       /* Cannot pop a level, if there are none left to pop.  */
 621       if (current_binding_level == global_binding_level)
 622         my_friendly_abort (123);
 623     }
 624   /* Pop the current level, and free the structure for reuse.  */
 625 #if defined(DEBUG_CP_BINDING_LEVELS)
 626   binding_depth--;
 627   indent ();
 628   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 629           (is_class_level) ? "class" : "block",
 630           current_binding_level, lineno);
 631   if (is_class_level != (current_binding_level == class_binding_level))
 632     {
 633       indent ();
 634       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 635     }
 636   is_class_level = 0;
 637 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 638   {
 639     register struct binding_level *level = current_binding_level;
 640     current_binding_level = current_binding_level->level_chain;
 641     level->level_chain = free_binding_level;
 642 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 643     if (level->binding_depth != binding_depth)
 644       abort ();
 645 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 646     free_binding_level = level;
 647     find_class_binding_level ();
 648   }
 649 }
 650
 651 static void
 652 suspend_binding_level ()
 653 {
 654   if (class_binding_level)
 655     current_binding_level = class_binding_level;
 656
 657   if (global_binding_level)
 658     {
 659       /* Cannot suspend a level, if there are none left to suspend.  */
 660       if (current_binding_level == global_binding_level)
 661         my_friendly_abort (123);
 662     }
 663   /* Suspend the current level.  */
 664 #if defined(DEBUG_CP_BINDING_LEVELS)
 665   binding_depth--;
 666   indent ();
 667   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 668           (is_class_level) ? "class" : "block",
 669           current_binding_level, lineno);
 670   if (is_class_level != (current_binding_level == class_binding_level))
 671     {
 672       indent ();
 673       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 674     }
 675   is_class_level = 0;
 676 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 677   current_binding_level = current_binding_level->level_chain;
 678   find_class_binding_level ();
 679 }
 680
 681 static void
 682 resume_binding_level (b)
 683      struct binding_level *b;
 684 {
 685   /* Resuming binding levels is meant only for namespaces,
 686      and those cannot nest into classes. */
 687   my_friendly_assert(!class_binding_level, 386);
 688   /* Also, resuming a non-directly nested namespace is a no-no.  */
 689   my_friendly_assert(b->level_chain == current_binding_level, 386);
 690   current_binding_level = b;
 691 #if defined(DEBUG_CP_BINDING_LEVELS)
 692   b->binding_depth = binding_depth;
 693   indent ();
 694   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 695            (is_class_level) ? "class" : "block", b, lineno);
 696   is_class_level = 0;
 697   binding_depth++;
 698 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 699 }
 700 \f
 701 /* Create a new `struct binding_level'.  */
 702
 703 static
 704 struct binding_level *
 705 make_binding_level ()
 706 {
 707   /* NOSTRICT */
 708   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 709 }
 710
 711 /* Nonzero if we are currently in the global binding level.  */
 712
 713 int
 714 global_bindings_p ()
 715 {
 716   return current_binding_level == global_binding_level;
 717 }
 718
 719 /* Return the innermost binding level that is not for a class scope.  */
 720
 721 static struct binding_level *
 722 innermost_nonclass_level ()
 723 {
 724   struct binding_level *b;
 725
 726   b = current_binding_level;
 727   while (b->parm_flag == 2)
 728     b = b->level_chain;
 729
 730   return b;
 731 }
 732
 733 /* Nonzero if we are currently in a toplevel binding level.  This
 734    means either the global binding level or a namespace in a toplevel
 735    binding level.  Since there are no non-toplevel namespace levels,
 736    this really means any namespace or template parameter level.  We
 737    also include a class whose context is toplevel.  */
 738
 739 int
 740 toplevel_bindings_p ()
 741 {
 742   struct binding_level *b = innermost_nonclass_level ();
 743
 744   return b->namespace_p || b->template_parms_p;
 745 }
 746
 747 /* Nonzero if this is a namespace scope, or if we are defining a class
 748    which is itself at namespace scope, or whose enclosing class is
 749    such a class, etc.  */
 750
 751 int
 752 namespace_bindings_p ()
 753 {
 754   struct binding_level *b = innermost_nonclass_level ();
 755
 756   return b->namespace_p;
 757 }
 758
 759 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 760    unconditionally.  Otherwise, use the normal logic to decide whether
 761    or not to create a BLOCK.  */
 762
 763 void
 764 keep_next_level (keep)
 765      int keep;
 766 {
 767   keep_next_level_flag = keep;
 768 }
 769
 770 /* Nonzero if the current level needs to have a BLOCK made.  */
 771
 772 int
 773 kept_level_p ()
 774 {
 775   return (current_binding_level->blocks != NULL_TREE
 776           || current_binding_level->keep
 777           || current_binding_level->names != NULL_TREE
 778           || (current_binding_level->tags != NULL_TREE
 779               && !current_binding_level->tag_transparent));
 780 }
 781
 782 static void
 783 declare_namespace_level ()
 784 {
 785   current_binding_level->namespace_p = 1;
 786 }
 787
 788 /* Returns non-zero if this scope was created to store template
 789    parameters.  */
 790
 791 int
 792 template_parm_scope_p ()
 793 {
 794   return current_binding_level->template_parms_p;
 795 }
 796
 797 /* Returns the kind of template specialization we are currently
 798    processing, given that it's declaration contained N_CLASS_SCOPES
 799    explicit scope qualifications.  */
 800
 801 tmpl_spec_kind
 802 current_tmpl_spec_kind (n_class_scopes)
 803      int n_class_scopes;
 804 {
 805   int n_template_parm_scopes = 0;
 806   int seen_specialization_p = 0;
 807   int innermost_specialization_p = 0;
 808   struct binding_level *b;
 809
 810   /* Scan through the template parameter scopes.  */
 811   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 812     {
 813       /* If we see a specialization scope inside a parameter scope,
 814          then something is wrong.  That corresponds to a declaration
 815          like:
 816
 817             template <class T> template <> ...
 818
 819          which is always illegal since [temp.expl.spec] forbids the
 820          specialization of a class member template if the enclosing
 821          class templates are not explicitly specialized as well.  */
 822       if (b->template_spec_p)
 823         {
 824           if (n_template_parm_scopes == 0)
 825             innermost_specialization_p = 1;
 826           else
 827             seen_specialization_p = 1;
 828         }
 829       else if (seen_specialization_p == 1)
 830         return tsk_invalid_member_spec;
 831
 832       ++n_template_parm_scopes;
 833     }
 834
 835   /* Handle explicit instantiations.  */
 836   if (processing_explicit_instantiation)
 837     {
 838       if (n_template_parm_scopes != 0)
 839         /* We've seen a template parameter list during an explicit
 840            instantiation.  For example:
 841
 842              template <class T> template void f(int);
 843
 844            This is erroneous.  */
 845         return tsk_invalid_expl_inst;
 846       else
 847         return tsk_expl_inst;
 848     }
 849
 850   if (n_template_parm_scopes < n_class_scopes)
 851     /* We've not seen enough template headers to match all the
 852        specialized classes present.  For example:
 853
 854          template <class T> void R<T>::S<T>::f(int);
 855
 856        This is illegal; there needs to be one set of template
 857        parameters for each class.  */
 858     return tsk_insufficient_parms;
 859   else if (n_template_parm_scopes == n_class_scopes)
 860     /* We're processing a non-template declaration (even though it may
 861        be a member of a template class.)  For example:
 862
 863          template <class T> void S<T>::f(int);
 864
 865        The `class T' maches the `S<T>', leaving no template headers
 866        corresponding to the `f'.  */
 867     return tsk_none;
 868   else if (n_template_parm_scopes > n_class_scopes + 1)
 869     /* We've got too many template headers.  For example:
 870
 871          template <> template <class T> void f (T);
 872
 873        There need to be more enclosing classes.  */
 874     return tsk_excessive_parms;
 875   else
 876     /* This must be a template.  It's of the form:
 877
 878          template <class T> template <class U> void S<T>::f(U);
 879
 880        This is a specialization if the innermost level was a
 881        specialization; otherwise it's just a definition of the
 882        template.  */
 883     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 884 }
 885
 886 void
 887 set_class_shadows (shadows)
 888      tree shadows;
 889 {
 890   class_binding_level->class_shadowed = shadows;
 891 }
 892
 893 /* Enter a new binding level.
 894    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 895    not for that of tags.  */
 896
 897 void
 898 pushlevel (tag_transparent)
 899      int tag_transparent;
 900 {
 901   struct binding_level *newlevel;
 902
 903   if (cfun && !doing_semantic_analysis_p ())
 904     return;
 905
 906   /* Reuse or create a struct for this binding level.  */
 907 #if defined(DEBUG_CP_BINDING_LEVELS)
 908   if (0)
 909 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 910   if (free_binding_level)
 911 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 912     {
 913       newlevel = free_binding_level;
 914       free_binding_level = free_binding_level->level_chain;
 915     }
 916   else
 917     newlevel = make_binding_level ();
 918
 919   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 920   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 921   keep_next_level_flag = 0;
 922 }
 923
 924 /* Enter a new scope.  The KIND indicates what kind of scope is being
 925    created.  */
 926
 927 void
 928 begin_scope (sk)
 929      scope_kind sk;
 930 {
 931   pushlevel (0);
 932
 933   switch (sk)
 934     {
 935     case sk_template_spec:
 936       current_binding_level->template_spec_p = 1;
 937       /* Fall through.  */
 938
 939     case sk_template_parms:
 940       current_binding_level->template_parms_p = 1;
 941       break;
 942
 943     default:
 944       my_friendly_abort (20000309);
 945     }
 946 }
 947
 948 /* Exit the current scope.  */
 949
 950 void
 951 finish_scope ()
 952 {
 953   poplevel (0, 0, 0);
 954 }
 955
 956 void
 957 note_level_for_for ()
 958 {
 959   current_binding_level->is_for_scope = 1;
 960 }
 961
 962 /* Record that the current binding level represents a try block.  */
 963
 964 void
 965 note_level_for_eh ()
 966 {
 967   current_binding_level->eh_region = 1;
 968 }
 969
 970 /* For a binding between a name and an entity at a block scope,
 971    this is the `struct binding_level' for the block.  */
 972 #define BINDING_LEVEL(NODE) \
 973    (((struct tree_binding*)NODE)->scope.level)
 974
 975 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 976    level at which this declaration is being bound.  */
 977
 978 static void
 979 push_binding (id, decl, level)
 980      tree id;
 981      tree decl;
 982      struct binding_level* level;
 983 {
 984   tree binding;
 985
 986   binding = make_node (CPLUS_BINDING);
 987
 988   /* Now, fill in the binding information.  */
 989   BINDING_VALUE (binding) = decl;
 990   BINDING_TYPE (binding) = NULL_TREE;
 991   BINDING_LEVEL (binding) = level;
 992   INHERITED_VALUE_BINDING_P (binding) = 0;
 993   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 994   BINDING_HAS_LEVEL_P (binding) = 1;
 995
 996   /* And put it on the front of the list of bindings for ID.  */
 997   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 998   IDENTIFIER_BINDING (id) = binding;
 999 }
1000
1001 /* ID is already bound in the current scope.  But, DECL is an
1002    additional binding for ID in the same scope.  This is the `struct
1003    stat' hack whereby a non-typedef class-name or enum-name can be
1004    bound at the same level as some other kind of entity.  It's the
1005    responsibility of the caller to check that inserting this name is
1006    legal here.  Returns nonzero if the new binding was successful.  */
1007 static int
1008 add_binding (id, decl)
1009      tree id;
1010      tree decl;
1011 {
1012   tree binding = IDENTIFIER_BINDING (id);
1013   int ok = 1;
1014
1015   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1016     /* The new name is the type name.  */
1017     BINDING_TYPE (binding) = decl;
1018   else if (!BINDING_VALUE (binding))
1019     /* This situation arises when push_class_level_binding moves an
1020        inherited type-binding out of the way to make room for a new
1021        value binding.  */
1022     BINDING_VALUE (binding) = decl;
1023   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1024            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1025     {
1026       /* The old binding was a type name.  It was placed in
1027          BINDING_VALUE because it was thought, at the point it was
1028          declared, to be the only entity with such a name.  Move the
1029          type name into the type slot; it is now hidden by the new
1030          binding.  */
1031       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1032       BINDING_VALUE (binding) = decl;
1033       INHERITED_VALUE_BINDING_P (binding) = 0;
1034     }
1035   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1036            && TREE_CODE (decl) == TYPE_DECL
1037            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1038            && same_type_p (TREE_TYPE (decl),
1039                            TREE_TYPE (BINDING_VALUE (binding))))
1040     /* We have two typedef-names, both naming the same type to have
1041        the same name.  This is OK because of:
1042
1043          [dcl.typedef]
1044
1045          In a given scope, a typedef specifier can be used to redefine
1046          the name of any type declared in that scope to refer to the
1047          type to which it already refers.  */
1048     ok = 0;
1049   /* There can be two block-scope declarations of the same variable,
1050      so long as they are `extern' declarations.  */
1051   else if (TREE_CODE (decl) == VAR_DECL
1052            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1053            && DECL_EXTERNAL (decl)
1054            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1055     {
1056       duplicate_decls (decl, BINDING_VALUE (binding));
1057       ok = 0;
1058     }
1059   else
1060     {
1061       cp_error ("declaration of `%#D'", decl);
1062       cp_error_at ("conflicts with previous declaration `%#D'",
1063                    BINDING_VALUE (binding));
1064       ok = 0;
1065     }
1066
1067   return ok;
1068 }
1069
1070 /* Add DECL to the list of things declared in B.  */
1071
1072 static void
1073 add_decl_to_level (decl, b)
1074      tree decl;
1075      struct binding_level *b;
1076 {
1077   /* We build up the list in reverse order, and reverse it later if
1078      necessary.  */
1079   TREE_CHAIN (decl) = b->names;
1080   b->names = decl;
1081 }
1082
1083 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1084    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1085    doesn't really belong to this binding level, that it got here
1086    through a using-declaration.  */
1087
1088 void
1089 push_local_binding (id, decl, flags)
1090      tree id;
1091      tree decl;
1092      int flags;
1093 {
1094   struct binding_level *b;
1095
1096   /* Skip over any local classes.  This makes sense if we call
1097      push_local_binding with a friend decl of a local class.  */
1098   b = current_binding_level;
1099   while (b->parm_flag == 2)
1100     b = b->level_chain;
1101
1102   if (lookup_name_current_level (id))
1103     {
1104       /* Supplement the existing binding.  */
1105       if (!add_binding (id, decl))
1106         /* It didn't work.  Something else must be bound at this
1107            level.  Do not add DECL to the list of things to pop
1108            later.  */
1109         return;
1110     }
1111   else
1112     /* Create a new binding.  */
1113     push_binding (id, decl, b);
1114
1115   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1116     /* We must put the OVERLOAD into a TREE_LIST since the
1117        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1118        decls that got here through a using-declaration.  */
1119     decl = build_tree_list (NULL_TREE, decl);
1120
1121   /* And put DECL on the list of things declared by the current
1122      binding level.  */
1123   add_decl_to_level (decl, b);
1124 }
1125
1126 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1127    binding was successful.  */
1128
1129 int
1130 push_class_binding (id, decl)
1131      tree id;
1132      tree decl;
1133 {
1134   int result = 1;
1135   tree binding = IDENTIFIER_BINDING (id);
1136   tree context;
1137
1138   /* Note that we declared this value so that we can issue an error if
1139      this an illegal redeclaration of a name already used for some
1140      other purpose.  */
1141   note_name_declared_in_class (id, decl);
1142
1143   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1144     /* Supplement the existing binding.  */
1145     result = add_binding (id, decl);
1146   else
1147     /* Create a new binding.  */
1148     push_binding (id, decl, class_binding_level);
1149
1150   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1151      class-level declaration.  Note that we do not use DECL here
1152      because of the possibility of the `struct stat' hack; if DECL is
1153      a class-name or enum-name we might prefer a field-name, or some
1154      such.  */
1155   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1156
1157   /* If this is a binding from a base class, mark it as such.  */
1158   binding = IDENTIFIER_BINDING (id);
1159   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1160     {
1161       /* Any implicit typename must be from a base-class.  The
1162          context for an implicit typename declaration is always
1163          the derived class in which the lookup was done, so the checks
1164          based on the context of DECL below will not trigger.  */
1165       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1166         INHERITED_VALUE_BINDING_P (binding) = 1;
1167       else
1168         {
1169           if (TREE_CODE (decl) == OVERLOAD)
1170             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1171           else
1172             {
1173               my_friendly_assert (DECL_P (decl), 0);
1174               context = CP_DECL_CONTEXT (decl);
1175             }
1176
1177           if (is_properly_derived_from (current_class_type, context))
1178             INHERITED_VALUE_BINDING_P (binding) = 1;
1179           else
1180             INHERITED_VALUE_BINDING_P (binding) = 0;
1181         }
1182     }
1183   else if (BINDING_VALUE (binding) == decl)
1184     /* We only encounter a TREE_LIST when push_class_decls detects an
1185        ambiguity.  Such an ambiguity can be overridden by a definition
1186        in this class.  */
1187     INHERITED_VALUE_BINDING_P (binding) = 1;
1188
1189   return result;
1190 }
1191
1192 /* Remove the binding for DECL which should be the innermost binding
1193    for ID.  */
1194
1195 static void
1196 pop_binding (id, decl)
1197      tree id;
1198      tree decl;
1199 {
1200   tree binding;
1201
1202   if (id == NULL_TREE)
1203     /* It's easiest to write the loops that call this function without
1204        checking whether or not the entities involved have names.  We
1205        get here for such an entity.  */
1206     return;
1207
1208   /* Get the innermost binding for ID.  */
1209   binding = IDENTIFIER_BINDING (id);
1210
1211   /* The name should be bound.  */
1212   my_friendly_assert (binding != NULL_TREE, 0);
1213
1214   /* The DECL will be either the ordinary binding or the type
1215      binding for this identifier.  Remove that binding.  */
1216   if (BINDING_VALUE (binding) == decl)
1217     BINDING_VALUE (binding) = NULL_TREE;
1218   else if (BINDING_TYPE (binding) == decl)
1219     BINDING_TYPE (binding) = NULL_TREE;
1220   else
1221     my_friendly_abort (0);
1222
1223   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1224     /* We're completely done with the innermost binding for this
1225        identifier.  Unhook it from the list of bindings.  */
1226     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1227 }
1228
1229 /* When a label goes out of scope, check to see if that label was used
1230    in a valid manner, and issue any appropriate warnings or errors.  */
1231
1232 static void
1233 pop_label (label, old_value)
1234      tree label;
1235      tree old_value;
1236 {
1237   if (!processing_template_decl && doing_semantic_analysis_p ())
1238     {
1239       if (DECL_INITIAL (label) == NULL_TREE)
1240         {
1241           cp_error_at ("label `%D' used but not defined", label);
1242           /* Avoid crashing later.  */
1243           define_label (input_filename, 1, DECL_NAME (label));
1244         }
1245       else if (warn_unused_label && !TREE_USED (label))
1246         cp_warning_at ("label `%D' defined but not used", label);
1247     }
1248
1249   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1250 }
1251
1252 /* At the end of a function, all labels declared within the function
1253    go out of scope.  BLOCK is the top-level block for the
1254    function.  */
1255
1256 static void
1257 pop_labels (block)
1258      tree block;
1259 {
1260   struct named_label_list *link;
1261
1262   /* Clear out the definitions of all label names, since their scopes
1263      end here.  */
1264   for (link = named_labels; link; link = link->next)
1265     {
1266       pop_label (link->label_decl, link->old_value);
1267       /* Put the labels into the "variables" of the top-level block,
1268          so debugger can see them.  */
1269       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1270       BLOCK_VARS (block) = link->label_decl;
1271     }
1272
1273   named_labels = NULL;
1274 }
1275
1276 /* Exit a binding level.
1277    Pop the level off, and restore the state of the identifier-decl mappings
1278    that were in effect when this level was entered.
1279
1280    If KEEP == 1, this level had explicit declarations, so
1281    and create a "block" (a BLOCK node) for the level
1282    to record its declarations and subblocks for symbol table output.
1283
1284    If FUNCTIONBODY is nonzero, this level is the body of a function,
1285    so create a block as if KEEP were set and also clear out all
1286    label names.
1287
1288    If REVERSE is nonzero, reverse the order of decls before putting
1289    them into the BLOCK.  */
1290
1291 tree
1292 poplevel (keep, reverse, functionbody)
1293      int keep;
1294      int reverse;
1295      int functionbody;
1296 {
1297   register tree link;
1298   /* The chain of decls was accumulated in reverse order.
1299      Put it into forward order, just for cleanliness.  */
1300   tree decls;
1301   int tmp = functionbody;
1302   int real_functionbody;
1303   tree tags;
1304   tree subblocks;
1305   tree block = NULL_TREE;
1306   tree decl;
1307   int block_previously_created;
1308   int leaving_for_scope;
1309
1310   if (cfun && !doing_semantic_analysis_p ())
1311     return NULL_TREE;
1312
1313   my_friendly_assert (current_binding_level->parm_flag != 2,
1314                       19990916);
1315
1316   real_functionbody = (current_binding_level->keep == 2
1317                        ? ((functionbody = 0), tmp) : functionbody);
1318   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1319   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1320
1321   my_friendly_assert (!current_binding_level->class_shadowed,
1322                       19990414);
1323
1324   /* We used to use KEEP == 2 to indicate that the new block should go
1325      at the beginning of the list of blocks at this binding level,
1326      rather than the end.  This hack is no longer used.  */
1327   my_friendly_assert (keep == 0 || keep == 1, 0);
1328
1329   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1330                       (HOST_WIDE_INT) current_binding_level->level_chain,
1331                       current_binding_level->parm_flag,
1332                       current_binding_level->keep);
1333
1334   if (current_binding_level->keep == 1)
1335     keep = 1;
1336
1337   /* Any uses of undefined labels, and any defined labels, now operate
1338      under constraints of next binding contour.  */
1339   if (cfun && !functionbody)
1340     {
1341       struct binding_level *level_chain;
1342       level_chain = current_binding_level->level_chain;
1343       if (level_chain)
1344         {
1345           struct named_label_use_list *uses;
1346           struct named_label_list *labels;
1347           for (labels = named_labels; labels; labels = labels->next)
1348             if (labels->binding_level == current_binding_level)
1349               {
1350                 tree decl;
1351                 if (current_binding_level->eh_region)
1352                   labels->eh_region = 1;
1353                 for (decl = labels->names_in_scope; decl;
1354                      decl = TREE_CHAIN (decl))
1355                   if (decl_jump_unsafe (decl))
1356                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1357                                                    labels->bad_decls);
1358                 labels->binding_level = level_chain;
1359                 labels->names_in_scope = level_chain->names;
1360               }
1361
1362           for (uses = named_label_uses; uses; uses = uses->next)
1363             if (uses->binding_level == current_binding_level)
1364               {
1365                 uses->binding_level = level_chain;
1366                 uses->names_in_scope = level_chain->names;
1367               }
1368         }
1369     }
1370
1371   /* Get the decls in the order they were written.
1372      Usually current_binding_level->names is in reverse order.
1373      But parameter decls were previously put in forward order.  */
1374
1375   if (reverse)
1376     current_binding_level->names
1377       = decls = nreverse (current_binding_level->names);
1378   else
1379     decls = current_binding_level->names;
1380
1381   /* Output any nested inline functions within this block
1382      if they weren't already output.  */
1383   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1384     if (TREE_CODE (decl) == FUNCTION_DECL
1385         && ! TREE_ASM_WRITTEN (decl)
1386         && DECL_INITIAL (decl) != NULL_TREE
1387         && TREE_ADDRESSABLE (decl)
1388         && decl_function_context (decl) == current_function_decl)
1389       {
1390         /* If this decl was copied from a file-scope decl
1391            on account of a block-scope extern decl,
1392            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1393         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1394           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1395         else
1396           {
1397             push_function_context ();
1398             output_inline_function (decl);
1399             pop_function_context ();
1400           }
1401       }
1402
1403   /* When not in function-at-a-time mode, expand_end_bindings will
1404      warn about unused variables.  But, in function-at-a-time mode
1405      expand_end_bindings is not passed the list of variables in the
1406      current scope, and therefore no warning is emitted.  So, we
1407      explicitly warn here.  */
1408   if (!processing_template_decl)
1409     warn_about_unused_variables (getdecls ());
1410
1411   /* If there were any declarations or structure tags in that level,
1412      or if this level is a function body,
1413      create a BLOCK to record them for the life of this function.  */
1414   block = NULL_TREE;
1415   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1416   if (block_previously_created)
1417     block = current_binding_level->this_block;
1418   else if (keep == 1 || functionbody)
1419     block = make_node (BLOCK);
1420   if (block != NULL_TREE)
1421     {
1422       if (block_previously_created)
1423         {
1424           if (decls || tags || subblocks)
1425             {
1426               if (BLOCK_VARS (block))
1427                 warning ("internal compiler error: debugging info corrupted");
1428
1429               BLOCK_VARS (block) = decls;
1430
1431               /* We can have previous subblocks and new subblocks when
1432                  doing fixup_gotos with complex cleanups.  We chain the new
1433                  subblocks onto the end of any pre-existing subblocks.  */
1434               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1435                                                  subblocks);
1436             }
1437         }
1438       else
1439         {
1440           BLOCK_VARS (block) = decls;
1441           BLOCK_SUBBLOCKS (block) = subblocks;
1442         }
1443     }
1444
1445   /* In each subblock, record that this is its superior.  */
1446   if (keep >= 0)
1447     for (link = subblocks; link; link = TREE_CHAIN (link))
1448       BLOCK_SUPERCONTEXT (link) = block;
1449
1450   /* We still support the old for-scope rules, whereby the variables
1451      in a for-init statement were in scope after the for-statement
1452      ended.  We only use the new rules in flag_new_for_scope is
1453      nonzero.  */
1454   leaving_for_scope
1455     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1456
1457   /* Remove declarations for all the DECLs in this level.  */
1458   for (link = decls; link; link = TREE_CHAIN (link))
1459     {
1460       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1461           && DECL_NAME (link))
1462         {
1463           tree outer_binding
1464             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1465           tree ns_binding;
1466
1467           if (!outer_binding)
1468             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1469           else
1470             ns_binding = NULL_TREE;
1471
1472           if (outer_binding
1473               && (BINDING_LEVEL (outer_binding)
1474                   == current_binding_level->level_chain))
1475             /* We have something like:
1476
1477                  int i;
1478                  for (int i; ;);
1479
1480                and we are leaving the `for' scope.  There's no reason to
1481                keep the binding of the inner `i' in this case.  */
1482             pop_binding (DECL_NAME (link), link);
1483           else if ((outer_binding
1484                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1485                         == TYPE_DECL))
1486                    || (ns_binding
1487                        && TREE_CODE (ns_binding) == TYPE_DECL))
1488             /* Here, we have something like:
1489
1490                  typedef int I;
1491
1492                  void f () {
1493                    for (int I; ;);
1494                  }
1495
1496                We must pop the for-scope binding so we know what's a
1497                type and what isn't.  */
1498             pop_binding (DECL_NAME (link), link);
1499           else
1500             {
1501               /* Mark this VAR_DECL as dead so that we can tell we left it
1502                  there only for backward compatibility.  */
1503               DECL_DEAD_FOR_LOCAL (link) = 1;
1504
1505               /* Keep track of what should of have happenned when we
1506                  popped the binding.  */
1507               if (outer_binding && BINDING_VALUE (outer_binding))
1508                 DECL_SHADOWED_FOR_VAR (link)
1509                   = BINDING_VALUE (outer_binding);
1510
1511               /* Add it to the list of dead variables in the next
1512                  outermost binding to that we can remove these when we
1513                  leave that binding.  */
1514               current_binding_level->level_chain->dead_vars_from_for
1515                 = tree_cons (NULL_TREE, link,
1516                              current_binding_level->level_chain->
1517                              dead_vars_from_for);
1518
1519               /* Although we don't pop the CPLUS_BINDING, we do clear
1520                  its BINDING_LEVEL since the level is going away now.  */
1521               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1522                 = 0;
1523             }
1524         }
1525       else
1526         {
1527           /* Remove the binding.  */
1528           decl = link;
1529           if (TREE_CODE (decl) == TREE_LIST)
1530             decl = TREE_VALUE (decl);
1531           if (DECL_P (decl))
1532             pop_binding (DECL_NAME (decl), decl);
1533           else if (TREE_CODE (decl) == OVERLOAD)
1534             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1535           else
1536             my_friendly_abort (0);
1537         }
1538     }
1539
1540   /* Remove declarations for any `for' variables from inner scopes
1541      that we kept around.  */
1542   for (link = current_binding_level->dead_vars_from_for;
1543        link; link = TREE_CHAIN (link))
1544     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1545
1546   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1547   for (link = current_binding_level->type_shadowed;
1548        link; link = TREE_CHAIN (link))
1549     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1550
1551   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1552   for (link = current_binding_level->shadowed_labels;
1553        link;
1554        link = TREE_CHAIN (link))
1555     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1556
1557   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1558      list if a `using' declaration put them there.  The debugging
1559      back-ends won't understand OVERLOAD, so we remove them here.
1560      Because the BLOCK_VARS are (temporarily) shared with
1561      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1562      popped all the bindings.  */
1563   if (block)
1564     {
1565       tree* d;
1566
1567       for (d = &BLOCK_VARS (block); *d; )
1568         {
1569           if (TREE_CODE (*d) == TREE_LIST)
1570             *d = TREE_CHAIN (*d);
1571           else
1572             d = &TREE_CHAIN (*d);
1573         }
1574     }
1575
1576   /* If the level being exited is the top level of a function,
1577      check over all the labels.  */
1578   if (functionbody)
1579     {
1580       /* Since this is the top level block of a function, the vars are
1581          the function's parameters.  Don't leave them in the BLOCK
1582          because they are found in the FUNCTION_DECL instead.  */
1583       BLOCK_VARS (block) = 0;
1584       pop_labels (block);
1585     }
1586
1587   tmp = current_binding_level->keep;
1588
1589   pop_binding_level ();
1590   if (functionbody)
1591     DECL_INITIAL (current_function_decl) = block;
1592   else if (block)
1593     {
1594       if (!block_previously_created)
1595         current_binding_level->blocks
1596           = chainon (current_binding_level->blocks, block);
1597     }
1598   /* If we did not make a block for the level just exited,
1599      any blocks made for inner levels
1600      (since they cannot be recorded as subblocks in that level)
1601      must be carried forward so they will later become subblocks
1602      of something else.  */
1603   else if (subblocks)
1604     current_binding_level->blocks
1605       = chainon (current_binding_level->blocks, subblocks);
1606
1607   /* Each and every BLOCK node created here in `poplevel' is important
1608      (e.g. for proper debugging information) so if we created one
1609      earlier, mark it as "used".  */
1610   if (block)
1611     TREE_USED (block) = 1;
1612
1613   /* Take care of compiler's internal binding structures.  */
1614   if (tmp == 2)
1615     {
1616       tree scope_stmts;
1617
1618       scope_stmts
1619         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1620       if (block)
1621         {
1622           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1623           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1624         }
1625
1626       block = poplevel (keep, reverse, functionbody);
1627     }
1628
1629   return block;
1630 }
1631
1632 /* Delete the node BLOCK from the current binding level.
1633    This is used for the block inside a stmt expr ({...})
1634    so that the block can be reinserted where appropriate.  */
1635
1636 void
1637 delete_block (block)
1638      tree block;
1639 {
1640   tree t;
1641   if (current_binding_level->blocks == block)
1642     current_binding_level->blocks = TREE_CHAIN (block);
1643   for (t = current_binding_level->blocks; t;)
1644     {
1645       if (TREE_CHAIN (t) == block)
1646         TREE_CHAIN (t) = TREE_CHAIN (block);
1647       else
1648         t = TREE_CHAIN (t);
1649     }
1650   TREE_CHAIN (block) = NULL_TREE;
1651   /* Clear TREE_USED which is always set by poplevel.
1652      The flag is set again if insert_block is called.  */
1653   TREE_USED (block) = 0;
1654 }
1655
1656 /* Insert BLOCK at the end of the list of subblocks of the
1657    current binding level.  This is used when a BIND_EXPR is expanded,
1658    to handle the BLOCK node inside the BIND_EXPR.  */
1659
1660 void
1661 insert_block (block)
1662      tree block;
1663 {
1664   TREE_USED (block) = 1;
1665   current_binding_level->blocks
1666     = chainon (current_binding_level->blocks, block);
1667 }
1668
1669 /* Set the BLOCK node for the innermost scope
1670    (the one we are currently in).  */
1671
1672 void
1673 set_block (block)
1674     register tree block;
1675 {
1676   current_binding_level->this_block = block;
1677 }
1678
1679 /* Do a pushlevel for class declarations.  */
1680
1681 void
1682 pushlevel_class ()
1683 {
1684   register struct binding_level *newlevel;
1685
1686   /* Reuse or create a struct for this binding level.  */
1687 #if defined(DEBUG_CP_BINDING_LEVELS)
1688   if (0)
1689 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1690   if (free_binding_level)
1691 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1692     {
1693       newlevel = free_binding_level;
1694       free_binding_level = free_binding_level->level_chain;
1695     }
1696   else
1697     newlevel = make_binding_level ();
1698
1699 #if defined(DEBUG_CP_BINDING_LEVELS)
1700   is_class_level = 1;
1701 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1702
1703   push_binding_level (newlevel, 0, 0);
1704
1705   class_binding_level = current_binding_level;
1706   class_binding_level->parm_flag = 2;
1707   class_binding_level->this_class = current_class_type;
1708 }
1709
1710 /* ...and a poplevel for class declarations.  */
1711
1712 void
1713 poplevel_class ()
1714 {
1715   register struct binding_level *level = class_binding_level;
1716   tree shadowed;
1717
1718   my_friendly_assert (level != 0, 354);
1719
1720   /* If we're leaving a toplevel class, don't bother to do the setting
1721      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1722      shouldn't even be used when current_class_type isn't set, and second,
1723      if we don't touch it here, we're able to use the cache effect if the
1724      next time we're entering a class scope, it is the same class.  */
1725   if (current_class_depth != 1)
1726     {
1727       struct binding_level* b;
1728
1729       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1730       for (shadowed = level->class_shadowed;
1731            shadowed;
1732            shadowed = TREE_CHAIN (shadowed))
1733         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1734
1735       /* Find the next enclosing class, and recreate
1736          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1737       b = level->level_chain;
1738       while (b && b->parm_flag != 2)
1739         b = b->level_chain;
1740
1741       if (b)
1742         for (shadowed = b->class_shadowed;
1743              shadowed;
1744              shadowed = TREE_CHAIN (shadowed))
1745           {
1746             tree t;
1747
1748             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1749             while (t && BINDING_LEVEL (t) != b)
1750               t = TREE_CHAIN (t);
1751
1752             if (t)
1753               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1754                 = BINDING_VALUE (t);
1755           }
1756     }
1757   else
1758     /* Remember to save what IDENTIFIER's were bound in this scope so we
1759        can recover from cache misses.  */
1760     {
1761       previous_class_type = current_class_type;
1762       previous_class_values = class_binding_level->class_shadowed;
1763     }
1764   for (shadowed = level->type_shadowed;
1765        shadowed;
1766        shadowed = TREE_CHAIN (shadowed))
1767     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1768
1769   /* Remove the bindings for all of the class-level declarations.  */
1770   for (shadowed = level->class_shadowed;
1771        shadowed;
1772        shadowed = TREE_CHAIN (shadowed))
1773     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1774
1775   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1776                       (HOST_WIDE_INT) class_binding_level->level_chain,
1777                       class_binding_level->parm_flag,
1778                       class_binding_level->keep);
1779
1780   /* Now, pop out of the binding level which we created up in the
1781      `pushlevel_class' routine.  */
1782 #if defined(DEBUG_CP_BINDING_LEVELS)
1783   is_class_level = 1;
1784 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1785
1786   pop_binding_level ();
1787 }
1788
1789 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1790    for any names in enclosing classes.  */
1791
1792 void
1793 clear_identifier_class_values ()
1794 {
1795   tree t;
1796
1797   if (!class_binding_level)
1798     return;
1799
1800   for (t = class_binding_level->class_shadowed;
1801        t;
1802        t = TREE_CHAIN (t))
1803     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1804 }
1805
1806 /* Returns non-zero if T is a virtual function table.  */
1807
1808 int
1809 vtable_decl_p (t, data)
1810      tree t;
1811      void *data ATTRIBUTE_UNUSED;
1812 {
1813   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1814 }
1815
1816 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1817    functions.  */
1818
1819 int
1820 vtype_decl_p (t, data)
1821      tree t;
1822      void *data ATTRIBUTE_UNUSED;
1823 {
1824   return (TREE_CODE (t) == TYPE_DECL
1825           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1826           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1827 }
1828
1829 /* Return the declarations that are members of the namespace NS.  */
1830
1831 tree
1832 cp_namespace_decls (ns)
1833      tree ns;
1834 {
1835   return NAMESPACE_LEVEL (ns)->names;
1836 }
1837
1838 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1839    itself, calling F for each.  The DATA is passed to F as well.  */
1840
1841 static int
1842 walk_namespaces_r (namespace, f, data)
1843      tree namespace;
1844      walk_namespaces_fn f;
1845      void *data;
1846 {
1847   tree current;
1848   int result = 0;
1849
1850   result |= (*f) (namespace, data);
1851
1852   for (current = cp_namespace_decls (namespace);
1853        current;
1854        current = TREE_CHAIN (current))
1855     {
1856       if (TREE_CODE (current) != NAMESPACE_DECL
1857           || DECL_NAMESPACE_ALIAS (current))
1858         continue;
1859       if (!DECL_LANG_SPECIFIC (current))
1860         {
1861           /* Hmm. std. */
1862           my_friendly_assert (current == std_node, 393);
1863           continue;
1864         }
1865
1866       /* We found a namespace.  */
1867       result |= walk_namespaces_r (current, f, data);
1868     }
1869
1870   return result;
1871 }
1872
1873 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1874    F as well.  */
1875
1876 int
1877 walk_namespaces (f, data)
1878      walk_namespaces_fn f;
1879      void *data;
1880 {
1881   return walk_namespaces_r (global_namespace, f, data);
1882 }
1883
1884 struct walk_globals_data {
1885   walk_globals_pred p;
1886   walk_globals_fn f;
1887   void *data;
1888 };
1889
1890 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1891    for which P returns non-zero, call F with its address.  If any call
1892    to F returns a non-zero value, return a non-zero value.  */
1893
1894 static int
1895 walk_globals_r (namespace, data)
1896      tree namespace;
1897      void *data;
1898 {
1899   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1900   walk_globals_pred p = wgd->p;
1901   walk_globals_fn f = wgd->f;
1902   void *d = wgd->data;
1903   tree *t;
1904   int result = 0;
1905
1906   t = &NAMESPACE_LEVEL (namespace)->names;
1907
1908   while (*t)
1909     {
1910       tree glbl = *t;
1911
1912       if ((*p) (glbl, d))
1913         result |= (*f) (t, d);
1914
1915       /* If F changed *T, then *T still points at the next item to
1916          examine.  */
1917       if (*t == glbl)
1918         t = &TREE_CHAIN (*t);
1919     }
1920
1921   return result;
1922 }
1923
1924 /* Walk the global declarations.  Whenever one is found for which P
1925    returns non-zero, call F with its address.  If any call to F
1926    returns a non-zero value, return a non-zero value.  */
1927
1928 int
1929 walk_globals (p, f, data)
1930      walk_globals_pred p;
1931      walk_globals_fn f;
1932      void *data;
1933 {
1934   struct walk_globals_data wgd;
1935   wgd.p = p;
1936   wgd.f = f;
1937   wgd.data = data;
1938
1939   return walk_namespaces (walk_globals_r, &wgd);
1940 }
1941
1942 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1943    DATA is non-NULL, this is the last time we will call
1944    wrapup_global_declarations for this NAMESPACE.  */
1945
1946 int
1947 wrapup_globals_for_namespace (namespace, data)
1948      tree namespace;
1949      void *data;
1950 {
1951   tree globals = cp_namespace_decls (namespace);
1952   int len = list_length (globals);
1953   tree *vec = (tree *) alloca (sizeof (tree) * len);
1954   int i;
1955   int result;
1956   tree decl;
1957   int last_time = (data != 0);
1958
1959   if (last_time && namespace == global_namespace)
1960     /* Let compile_file handle the global namespace.  */
1961     return 0;
1962
1963   /* Process the decls in reverse order--earliest first.
1964      Put them into VEC from back to front, then take out from front.  */
1965
1966   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1967     {
1968       /* Pretend we've output an unused static variable.  This ensures
1969          that the toplevel __FUNCTION__ etc won't be emitted, unless
1970          needed. */
1971       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1972           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1973         {
1974           TREE_ASM_WRITTEN (decl) = 1;
1975           DECL_IGNORED_P (decl) = 1;
1976         }
1977       vec[len - i - 1] = decl;
1978     }
1979
1980   if (last_time)
1981     {
1982       check_global_declarations (vec, len);
1983       return 0;
1984     }
1985
1986   /* Temporarily mark vtables as external.  That prevents
1987      wrapup_global_declarations from writing them out; we must process
1988      them ourselves in finish_vtable_vardecl.  */
1989   for (i = 0; i < len; ++i)
1990     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1991       {
1992         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1993         DECL_EXTERNAL (vec[i]) = 1;
1994       }
1995
1996   /* Write out any globals that need to be output.  */
1997   result = wrapup_global_declarations (vec, len);
1998
1999   /* Undo the hack to DECL_EXTERNAL above.  */
2000   for (i = 0; i < len; ++i)
2001     if (vtable_decl_p (vec[i], /*data=*/0)
2002         && DECL_NOT_REALLY_EXTERN (vec[i]))
2003       {
2004         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
2005         DECL_EXTERNAL (vec[i]) = 0;
2006       }
2007
2008   return result;
2009 }
2010
2011 \f
2012 /* Mark ARG (which is really a struct binding_level **) for GC.  */
2013
2014 static void
2015 mark_binding_level (arg)
2016      void *arg;
2017 {
2018   struct binding_level *lvl = *(struct binding_level **)arg;
2019
2020   for (; lvl; lvl = lvl->level_chain)
2021     {
2022       ggc_mark_tree (lvl->names);
2023       ggc_mark_tree (lvl->tags);
2024       ggc_mark_tree (lvl->usings);
2025       ggc_mark_tree (lvl->using_directives);
2026       ggc_mark_tree (lvl->class_shadowed);
2027       ggc_mark_tree (lvl->type_shadowed);
2028       ggc_mark_tree (lvl->shadowed_labels);
2029       ggc_mark_tree (lvl->blocks);
2030       ggc_mark_tree (lvl->this_block);
2031       ggc_mark_tree (lvl->this_class);
2032       ggc_mark_tree (lvl->incomplete);
2033       ggc_mark_tree (lvl->dead_vars_from_for);
2034     }
2035 }
2036
2037 static void
2038 mark_named_label_lists (labs, uses)
2039      void *labs;
2040      void *uses;
2041 {
2042   struct named_label_list *l = *(struct named_label_list **)labs;
2043   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2044
2045   for (; l; l = l->next)
2046     {
2047       ggc_mark (l);
2048       mark_binding_level (l->binding_level);
2049       ggc_mark_tree (l->old_value);
2050       ggc_mark_tree (l->label_decl);
2051       ggc_mark_tree (l->bad_decls);
2052     }
2053
2054   for (; u; u = u->next)
2055     ggc_mark (u);
2056 }
2057 \f
2058 /* For debugging.  */
2059 static int no_print_functions = 0;
2060 static int no_print_builtins = 0;
2061
2062 void
2063 print_binding_level (lvl)
2064      struct binding_level *lvl;
2065 {
2066   tree t;
2067   int i = 0, len;
2068   fprintf (stderr, " blocks=");
2069   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2070   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2071            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2072   if (lvl->tag_transparent)
2073     fprintf (stderr, " tag-transparent");
2074   if (lvl->more_cleanups_ok)
2075     fprintf (stderr, " more-cleanups-ok");
2076   if (lvl->have_cleanups)
2077     fprintf (stderr, " have-cleanups");
2078   fprintf (stderr, "\n");
2079   if (lvl->names)
2080     {
2081       fprintf (stderr, " names:\t");
2082       /* We can probably fit 3 names to a line?  */
2083       for (t = lvl->names; t; t = TREE_CHAIN (t))
2084         {
2085           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2086             continue;
2087           if (no_print_builtins
2088               && (TREE_CODE (t) == TYPE_DECL)
2089               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2090             continue;
2091
2092           /* Function decls tend to have longer names.  */
2093           if (TREE_CODE (t) == FUNCTION_DECL)
2094             len = 3;
2095           else
2096             len = 2;
2097           i += len;
2098           if (i > 6)
2099             {
2100               fprintf (stderr, "\n\t");
2101               i = len;
2102             }
2103           print_node_brief (stderr, "", t, 0);
2104           if (t == error_mark_node)
2105             break;
2106         }
2107       if (i)
2108         fprintf (stderr, "\n");
2109     }
2110   if (lvl->tags)
2111     {
2112       fprintf (stderr, " tags:\t");
2113       i = 0;
2114       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2115         {
2116           if (TREE_PURPOSE (t) == NULL_TREE)
2117             len = 3;
2118           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2119             len = 2;
2120           else
2121             len = 4;
2122           i += len;
2123           if (i > 5)
2124             {
2125               fprintf (stderr, "\n\t");
2126               i = len;
2127             }
2128           if (TREE_PURPOSE (t) == NULL_TREE)
2129             {
2130               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2131               fprintf (stderr, ">");
2132             }
2133           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2134             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2135           else
2136             {
2137               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2138               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2139               fprintf (stderr, ">");
2140             }
2141         }
2142       if (i)
2143         fprintf (stderr, "\n");
2144     }
2145   if (lvl->class_shadowed)
2146     {
2147       fprintf (stderr, " class-shadowed:");
2148       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2149         {
2150           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2151         }
2152       fprintf (stderr, "\n");
2153     }
2154   if (lvl->type_shadowed)
2155     {
2156       fprintf (stderr, " type-shadowed:");
2157       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2158         {
2159           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2160         }
2161       fprintf (stderr, "\n");
2162     }
2163 }
2164
2165 void
2166 print_other_binding_stack (stack)
2167      struct binding_level *stack;
2168 {
2169   struct binding_level *level;
2170   for (level = stack; level != global_binding_level; level = level->level_chain)
2171     {
2172       fprintf (stderr, "binding level ");
2173       fprintf (stderr, HOST_PTR_PRINTF, level);
2174       fprintf (stderr, "\n");
2175       print_binding_level (level);
2176     }
2177 }
2178
2179 void
2180 print_binding_stack ()
2181 {
2182   struct binding_level *b;
2183   fprintf (stderr, "current_binding_level=");
2184   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2185   fprintf (stderr, "\nclass_binding_level=");
2186   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2187   fprintf (stderr, "\nglobal_binding_level=");
2188   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2189   fprintf (stderr, "\n");
2190   if (class_binding_level)
2191     {
2192       for (b = class_binding_level; b; b = b->level_chain)
2193         if (b == current_binding_level)
2194           break;
2195       if (b)
2196         b = class_binding_level;
2197       else
2198         b = current_binding_level;
2199     }
2200   else
2201     b = current_binding_level;
2202   print_other_binding_stack (b);
2203   fprintf (stderr, "global:\n");
2204   print_binding_level (global_binding_level);
2205 }
2206
2207 /* Namespace binding access routines: The namespace_bindings field of
2208    the identifier is polymorphic, with three possible values:
2209    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2210    indicating the BINDING_VALUE of global_namespace. */
2211
2212 /* Check whether the a binding for the name to scope is known.
2213    Assumes that the bindings of the name are already a list
2214    of bindings. Returns the binding found, or NULL_TREE. */
2215
2216 static tree
2217 find_binding (name, scope)
2218      tree name;
2219      tree scope;
2220 {
2221   tree iter, prev = NULL_TREE;
2222
2223   scope = ORIGINAL_NAMESPACE (scope);
2224
2225   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2226        iter = TREE_CHAIN (iter))
2227     {
2228       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2229       if (BINDING_SCOPE (iter) == scope)
2230         {
2231           /* Move binding found to the front of the list, so
2232              subsequent lookups will find it faster. */
2233           if (prev)
2234             {
2235               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2236               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2237               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2238             }
2239           return iter;
2240         }
2241       prev = iter;
2242     }
2243   return NULL_TREE;
2244 }
2245
2246 /* Always returns a binding for name in scope. If the
2247    namespace_bindings is not a list, convert it to one first.
2248    If no binding is found, make a new one. */
2249
2250 tree
2251 binding_for_name (name, scope)
2252      tree name;
2253      tree scope;
2254 {
2255   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2256   tree result;
2257
2258   scope = ORIGINAL_NAMESPACE (scope);
2259
2260   if (b && TREE_CODE (b) != CPLUS_BINDING)
2261     {
2262       /* Get rid of optimization for global scope. */
2263       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2264       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2265       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2266     }
2267   if (b && (result = find_binding (name, scope)))
2268     return result;
2269   /* Not found, make a new one. */
2270   result = make_node (CPLUS_BINDING);
2271   TREE_CHAIN (result) = b;
2272   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2273   BINDING_SCOPE (result) = scope;
2274   BINDING_TYPE (result) = NULL_TREE;
2275   BINDING_VALUE (result) = NULL_TREE;
2276   return result;
2277 }
2278
2279 /* Return the binding value for name in scope, considering that
2280    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2281
2282 tree
2283 namespace_binding (name, scope)
2284      tree name;
2285      tree scope;
2286 {
2287   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2288   if (b == NULL_TREE)
2289     return NULL_TREE;
2290   if (scope == NULL_TREE)
2291     scope = global_namespace;
2292   if (TREE_CODE (b) != CPLUS_BINDING)
2293     return (scope == global_namespace) ? b : NULL_TREE;
2294   name = find_binding (name,scope);
2295   if (name == NULL_TREE)
2296     return name;
2297   return BINDING_VALUE (name);
2298 }
2299
2300 /* Set the binding value for name in scope. If modifying the binding
2301    of global_namespace is attempted, try to optimize it. */
2302
2303 void
2304 set_namespace_binding (name, scope, val)
2305      tree name;
2306      tree scope;
2307      tree val;
2308 {
2309   tree b;
2310
2311   if (scope == NULL_TREE)
2312     scope = global_namespace;
2313
2314   if (scope == global_namespace)
2315     {
2316       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2317       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2318         {
2319           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2320           return;
2321         }
2322     }
2323   b = binding_for_name (name, scope);
2324   BINDING_VALUE (b) = val;
2325 }
2326
2327 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2328    select a name that is unique to this compilation unit.  */
2329
2330 void
2331 push_namespace (name)
2332      tree name;
2333 {
2334   tree d = NULL_TREE;
2335   int need_new = 1;
2336   int implicit_use = 0;
2337   int global = 0;
2338   if (!global_namespace)
2339     {
2340       /* This must be ::. */
2341       my_friendly_assert (name == get_identifier ("::"), 377);
2342       global = 1;
2343     }
2344   else if (!name)
2345     {
2346       /* The name of anonymous namespace is unique for the translation
2347          unit.  */
2348       if (!anonymous_namespace_name)
2349         anonymous_namespace_name = get_file_function_name ('N');
2350       name = anonymous_namespace_name;
2351       d = IDENTIFIER_NAMESPACE_VALUE (name);
2352       if (d)
2353         /* Reopening anonymous namespace.  */
2354         need_new = 0;
2355       implicit_use = 1;
2356     }
2357   else if (current_namespace == global_namespace
2358            && name == DECL_NAME (std_node))
2359     {
2360       in_std++;
2361       return;
2362     }
2363   else
2364     {
2365       /* Check whether this is an extended namespace definition. */
2366       d = IDENTIFIER_NAMESPACE_VALUE (name);
2367       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2368         {
2369           need_new = 0;
2370           if (DECL_NAMESPACE_ALIAS (d))
2371             {
2372               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2373                         d, DECL_NAMESPACE_ALIAS (d));
2374               d = DECL_NAMESPACE_ALIAS (d);
2375             }
2376         }
2377     }
2378
2379   if (need_new)
2380     {
2381       /* Make a new namespace, binding the name to it. */
2382       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2383       /* The global namespace is not pushed, and the global binding
2384          level is set elsewhere.  */
2385       if (!global)
2386         {
2387           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2388           d = pushdecl (d);
2389           pushlevel (0);
2390           declare_namespace_level ();
2391           NAMESPACE_LEVEL (d) = current_binding_level;
2392         }
2393     }
2394   else
2395     resume_binding_level (NAMESPACE_LEVEL (d));
2396
2397   if (implicit_use)
2398     do_using_directive (d);
2399   /* Enter the name space. */
2400   current_namespace = d;
2401 }
2402
2403 /* Pop from the scope of the current namespace.  */
2404
2405 void
2406 pop_namespace ()
2407 {
2408   if (current_namespace == global_namespace)
2409     {
2410       my_friendly_assert (in_std>0, 980421);
2411       in_std--;
2412       return;
2413     }
2414   current_namespace = CP_DECL_CONTEXT (current_namespace);
2415   /* The binding level is not popped, as it might be re-opened later.  */
2416   suspend_binding_level ();
2417 }
2418
2419 /* Push into the scope of the namespace NS, even if it is deeply
2420    nested within another namespace.  */
2421
2422 void
2423 push_nested_namespace (ns)
2424      tree ns;
2425 {
2426   if (ns == global_namespace)
2427     push_to_top_level ();
2428   else
2429     {
2430       push_nested_namespace (CP_DECL_CONTEXT (ns));
2431       push_namespace (DECL_NAME (ns));
2432     }
2433 }
2434
2435 /* Pop back from the scope of the namespace NS, which was previously
2436    entered with push_nested_namespace.  */
2437
2438 void
2439 pop_nested_namespace (ns)
2440      tree ns;
2441 {
2442   while (ns != global_namespace)
2443     {
2444       pop_namespace ();
2445       ns = CP_DECL_CONTEXT (ns);
2446     }
2447
2448   pop_from_top_level ();
2449 }
2450
2451 \f
2452 /* Subroutines for reverting temporarily to top-level for instantiation
2453    of templates and such.  We actually need to clear out the class- and
2454    local-value slots of all identifiers, so that only the global values
2455    are at all visible.  Simply setting current_binding_level to the global
2456    scope isn't enough, because more binding levels may be pushed.  */
2457 struct saved_scope *scope_chain;
2458
2459 /* Mark ST for GC.  */
2460
2461 static void
2462 mark_stmt_tree (st)
2463      struct stmt_tree *st;
2464 {
2465   ggc_mark_tree (st->x_last_stmt);
2466   ggc_mark_tree (st->x_last_expr_type);
2467 }
2468
2469 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2470
2471 static void
2472 mark_saved_scope (arg)
2473      void *arg;
2474 {
2475   struct saved_scope *t = *(struct saved_scope **)arg;
2476   while (t)
2477     {
2478       mark_binding_level (&t->class_bindings);
2479       ggc_mark_tree (t->old_bindings);
2480       ggc_mark_tree (t->old_namespace);
2481       ggc_mark_tree (t->class_name);
2482       ggc_mark_tree (t->class_type);
2483       ggc_mark_tree (t->access_specifier);
2484       ggc_mark_tree (t->function_decl);
2485       if (t->lang_base)
2486         ggc_mark_tree_varray (t->lang_base);
2487       ggc_mark_tree (t->lang_name);
2488       ggc_mark_tree (t->x_function_parms);
2489       ggc_mark_tree (t->template_parms);
2490       ggc_mark_tree (t->x_previous_class_type);
2491       ggc_mark_tree (t->x_previous_class_values);
2492       ggc_mark_tree (t->x_saved_tree);
2493       ggc_mark_tree (t->incomplete);
2494       ggc_mark_tree (t->lookups);
2495
2496       mark_stmt_tree (&t->x_stmt_tree);
2497       mark_binding_level (&t->bindings);
2498       t = t->prev;
2499     }
2500 }
2501
2502 static tree
2503 store_bindings (names, old_bindings)
2504      tree names, old_bindings;
2505 {
2506   tree t;
2507   for (t = names; t; t = TREE_CHAIN (t))
2508     {
2509       tree binding, t1, id;
2510
2511       if (TREE_CODE (t) == TREE_LIST)
2512         id = TREE_PURPOSE (t);
2513       else
2514         id = DECL_NAME (t);
2515
2516       if (!id
2517           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2518              we have no IDENTIFIER_BINDING if we have left the class
2519              scope, but cached the class-level declarations.  */
2520           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2521         continue;
2522
2523       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2524         if (TREE_VEC_ELT (t1, 0) == id)
2525           goto skip_it;
2526
2527       binding = make_tree_vec (4);
2528
2529       if (id)
2530         {
2531           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2532           TREE_VEC_ELT (binding, 0) = id;
2533           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2534           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2535           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2536           IDENTIFIER_BINDING (id) = NULL_TREE;
2537           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2538         }
2539       TREE_CHAIN (binding) = old_bindings;
2540       old_bindings = binding;
2541     skip_it:
2542       ;
2543     }
2544   return old_bindings;
2545 }
2546
2547 void
2548 maybe_push_to_top_level (pseudo)
2549      int pseudo;
2550 {
2551   struct saved_scope *s;
2552   struct binding_level *b;
2553   tree old_bindings;
2554   int need_pop;
2555
2556   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2557
2558   b = scope_chain ? current_binding_level : 0;
2559
2560   /* If we're in the middle of some function, save our state.  */
2561   if (cfun)
2562     {
2563       need_pop = 1;
2564       push_function_context_to (NULL_TREE);
2565     }
2566   else
2567     need_pop = 0;
2568
2569   old_bindings = NULL_TREE;
2570   if (scope_chain && previous_class_type)
2571     old_bindings = store_bindings (previous_class_values, old_bindings);
2572
2573   /* Have to include global_binding_level, because class-level decls
2574      aren't listed anywhere useful.  */
2575   for (; b; b = b->level_chain)
2576     {
2577       tree t;
2578
2579       /* Template IDs are inserted into the global level. If they were
2580          inserted into namespace level, finish_file wouldn't find them
2581          when doing pending instantiations. Therefore, don't stop at
2582          namespace level, but continue until :: .  */
2583       if (b == global_binding_level || (pseudo && b->template_parms_p))
2584         break;
2585
2586       old_bindings = store_bindings (b->names, old_bindings);
2587       /* We also need to check class_shadowed to save class-level type
2588          bindings, since pushclass doesn't fill in b->names.  */
2589       if (b->parm_flag == 2)
2590         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2591
2592       /* Unwind type-value slots back to top level.  */
2593       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2594         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2595     }
2596   s->prev = scope_chain;
2597   s->old_bindings = old_bindings;
2598   s->bindings = b;
2599   s->need_pop_function_context = need_pop;
2600   s->function_decl = current_function_decl;
2601
2602   scope_chain = s;
2603   current_function_decl = NULL_TREE;
2604   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2605   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2606   current_lang_name = lang_name_cplusplus;
2607   current_namespace = global_namespace;
2608 }
2609
2610 void
2611 push_to_top_level ()
2612 {
2613   maybe_push_to_top_level (0);
2614 }
2615
2616 void
2617 pop_from_top_level ()
2618 {
2619   struct saved_scope *s = scope_chain;
2620   tree t;
2621
2622   /* Clear out class-level bindings cache.  */
2623   if (previous_class_type)
2624     invalidate_class_lookup_cache ();
2625
2626   VARRAY_FREE (current_lang_base);
2627
2628   scope_chain = s->prev;
2629   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2630     {
2631       tree id = TREE_VEC_ELT (t, 0);
2632       if (id)
2633         {
2634           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2635           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2636           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2637         }
2638     }
2639
2640   /* If we were in the middle of compiling a function, restore our
2641      state.  */
2642   if (s->need_pop_function_context)
2643     pop_function_context_from (NULL_TREE);
2644   current_function_decl = s->function_decl;
2645
2646   free (s);
2647 }
2648 \f
2649 /* Push a definition of struct, union or enum tag "name".
2650    into binding_level "b".   "type" should be the type node,
2651    We assume that the tag "name" is not already defined.
2652
2653    Note that the definition may really be just a forward reference.
2654    In that case, the TYPE_SIZE will be a NULL_TREE.
2655
2656    C++ gratuitously puts all these tags in the name space.  */
2657
2658 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2659    record the shadowed value for this binding contour.  TYPE is
2660    the type that ID maps to.  */
2661
2662 static void
2663 set_identifier_type_value_with_scope (id, type, b)
2664      tree id;
2665      tree type;
2666      struct binding_level *b;
2667 {
2668   if (!b->namespace_p)
2669     {
2670       /* Shadow the marker, not the real thing, so that the marker
2671          gets restored later. */
2672       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2673       b->type_shadowed
2674         = tree_cons (id, old_type_value, b->type_shadowed);
2675     }
2676   else
2677     {
2678       tree binding = binding_for_name (id, current_namespace);
2679       BINDING_TYPE (binding) = type;
2680       /* Store marker instead of real type. */
2681       type = global_type_node;
2682     }
2683   SET_IDENTIFIER_TYPE_VALUE (id, type);
2684 }
2685
2686 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2687
2688 void
2689 set_identifier_type_value (id, type)
2690      tree id;
2691      tree type;
2692 {
2693   set_identifier_type_value_with_scope (id, type, current_binding_level);
2694 }
2695
2696 /* Return the type associated with id. */
2697
2698 tree
2699 identifier_type_value (id)
2700      tree id;
2701 {
2702   /* There is no type with that name, anywhere. */
2703   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2704     return NULL_TREE;
2705   /* This is not the type marker, but the real thing. */
2706   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2707     return REAL_IDENTIFIER_TYPE_VALUE (id);
2708   /* Have to search for it. It must be on the global level, now.
2709      Ask lookup_name not to return non-types. */
2710   id = lookup_name_real (id, 2, 1, 0);
2711   if (id)
2712     return TREE_TYPE (id);
2713   return NULL_TREE;
2714 }
2715
2716 /* Pop off extraneous binding levels left over due to syntax errors.
2717
2718    We don't pop past namespaces, as they might be valid.  */
2719
2720 void
2721 pop_everything ()
2722 {
2723 #ifdef DEBUG_CP_BINDING_LEVELS
2724   fprintf (stderr, "XXX entering pop_everything ()\n");
2725 #endif
2726   while (!toplevel_bindings_p ())
2727     {
2728       if (current_binding_level->parm_flag == 2)
2729         pop_nested_class ();
2730       else
2731         poplevel (0, 0, 0);
2732     }
2733 #ifdef DEBUG_CP_BINDING_LEVELS
2734   fprintf (stderr, "XXX leaving pop_everything ()\n");
2735 #endif
2736 }
2737
2738 /* The type TYPE is being declared.  If it is a class template, or a
2739    specialization of a class template, do any processing required and
2740    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2741    being declared a friend.  B is the binding level at which this TYPE
2742    should be bound.
2743
2744    Returns the TYPE_DECL for TYPE, which may have been altered by this
2745    processing.  */
2746
2747 static tree
2748 maybe_process_template_type_declaration (type, globalize, b)
2749      tree type;
2750      int globalize;
2751      struct binding_level* b;
2752 {
2753   tree decl = TYPE_NAME (type);
2754
2755   if (processing_template_parmlist)
2756     /* You can't declare a new template type in a template parameter
2757        list.  But, you can declare a non-template type:
2758
2759          template <class A*> struct S;
2760
2761        is a forward-declaration of `A'.  */
2762     ;
2763   else
2764     {
2765       maybe_check_template_type (type);
2766
2767       my_friendly_assert (IS_AGGR_TYPE (type)
2768                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2769
2770
2771       if (processing_template_decl)
2772         {
2773           /* This may change after the call to
2774              push_template_decl_real, but we want the original value.  */
2775           tree name = DECL_NAME (decl);
2776
2777           decl = push_template_decl_real (decl, globalize);
2778           /* If the current binding level is the binding level for the
2779              template parameters (see the comment in
2780              begin_template_parm_list) and the enclosing level is a class
2781              scope, and we're not looking at a friend, push the
2782              declaration of the member class into the class scope.  In the
2783              friend case, push_template_decl will already have put the
2784              friend into global scope, if appropriate.  */
2785           if (TREE_CODE (type) != ENUMERAL_TYPE
2786               && !globalize && b->template_parms_p
2787               && b->level_chain->parm_flag == 2)
2788             {
2789               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2790               /* Put this tag on the list of tags for the class, since
2791                  that won't happen below because B is not the class
2792                  binding level, but is instead the pseudo-global level.  */
2793               b->level_chain->tags =
2794                 tree_cons (name, type, b->level_chain->tags);
2795               if (!COMPLETE_TYPE_P (current_class_type))
2796                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2797             }
2798         }
2799     }
2800
2801   return decl;
2802 }
2803
2804 /* In C++, you don't have to write `struct S' to refer to `S'; you
2805    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2806    if the user had written `typedef struct S S'.  Create and return
2807    the TYPE_DECL for TYPE.  */
2808
2809 tree
2810 create_implicit_typedef (name, type)
2811      tree name;
2812      tree type;
2813 {
2814   tree decl;
2815
2816   decl = build_decl (TYPE_DECL, name, type);
2817   DECL_ARTIFICIAL (decl) = 1;
2818   /* There are other implicit type declarations, like the one *within*
2819      a class that allows you to write `S::S'.  We must distinguish
2820      amongst these.  */
2821   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2822   TYPE_NAME (type) = decl;
2823
2824   return decl;
2825 }
2826
2827 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2828    Normally put it into the inner-most non-tag-transparent scope,
2829    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2830    The latter is needed for implicit declarations.  */
2831
2832 void
2833 pushtag (name, type, globalize)
2834      tree name, type;
2835      int globalize;
2836 {
2837   register struct binding_level *b;
2838
2839   b = current_binding_level;
2840   while (b->tag_transparent
2841          || (globalize && b->parm_flag == 2))
2842     b = b->level_chain;
2843
2844   b->tags = tree_cons (name, type, b->tags);
2845
2846   if (name)
2847     {
2848       /* Do C++ gratuitous typedefing.  */
2849       if (IDENTIFIER_TYPE_VALUE (name) != type)
2850         {
2851           register tree d = NULL_TREE;
2852           int in_class = 0;
2853           tree context = TYPE_CONTEXT (type);
2854
2855           if (! context)
2856             {
2857               tree cs = current_scope ();
2858
2859               if (! globalize)
2860                 context = cs;
2861               else if (cs != NULL_TREE && TYPE_P (cs))
2862                 /* When declaring a friend class of a local class, we want
2863                    to inject the newly named class into the scope
2864                    containing the local class, not the namespace scope.  */
2865                 context = decl_function_context (get_type_decl (cs));
2866             }
2867           if (!context)
2868             context = current_namespace;
2869
2870           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2871               || b->parm_flag == 2)
2872             in_class = 1;
2873
2874           if (current_lang_name == lang_name_java)
2875             TYPE_FOR_JAVA (type) = 1;
2876
2877           d = create_implicit_typedef (name, type);
2878           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2879           if (! in_class)
2880             set_identifier_type_value_with_scope (name, type, b);
2881
2882           d = maybe_process_template_type_declaration (type,
2883                                                        globalize, b);
2884
2885           if (b->parm_flag == 2)
2886             {
2887               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2888                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2889                    class.  But if it's a member template class, we
2890                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2891                    is done later.  */
2892                 finish_member_declaration (d);
2893               else
2894                 pushdecl_class_level (d);
2895             }
2896           else
2897             d = pushdecl_with_scope (d, b);
2898
2899           if (ANON_AGGRNAME_P (name))
2900             DECL_IGNORED_P (d) = 1;
2901
2902           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2903           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2904
2905           /* If this is a local class, keep track of it.  We need this
2906              information for name-mangling, and so that it is possible to find
2907              all function definitions in a translation unit in a convenient
2908              way.  (It's otherwise tricky to find a member function definition
2909              it's only pointed to from within a local class.)  */
2910           if (TYPE_CONTEXT (type)
2911               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2912               && !processing_template_decl)
2913             VARRAY_PUSH_TREE (local_classes, type);
2914
2915           if (!uses_template_parms (type))
2916             {
2917               if (flag_new_abi)
2918                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2919               else
2920                 DECL_ASSEMBLER_NAME (d)
2921                   = get_identifier (build_overload_name (type, 1, 1));
2922             }
2923         }
2924       if (b->parm_flag == 2)
2925         {
2926           if (!COMPLETE_TYPE_P (current_class_type))
2927             CLASSTYPE_TAGS (current_class_type) = b->tags;
2928         }
2929     }
2930
2931   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2932     /* Use the canonical TYPE_DECL for this node.  */
2933     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2934   else
2935     {
2936       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2937          will be the tagged type we just added to the current
2938          binding level.  This fake NULL-named TYPE_DECL node helps
2939          dwarfout.c to know when it needs to output a
2940          representation of a tagged type, and it also gives us a
2941          convenient place to record the "scope start" address for
2942          the tagged type.  */
2943
2944       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2945       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2946     }
2947 }
2948
2949 /* Counter used to create anonymous type names.  */
2950
2951 static int anon_cnt = 0;
2952
2953 /* Return an IDENTIFIER which can be used as a name for
2954    anonymous structs and unions.  */
2955
2956 tree
2957 make_anon_name ()
2958 {
2959   char buf[32];
2960
2961   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2962   return get_identifier (buf);
2963 }
2964
2965 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2966    This keeps dbxout from getting confused.  */
2967
2968 void
2969 clear_anon_tags ()
2970 {
2971   register struct binding_level *b;
2972   register tree tags;
2973   static int last_cnt = 0;
2974
2975   /* Fast out if no new anon names were declared.  */
2976   if (last_cnt == anon_cnt)
2977     return;
2978
2979   b = current_binding_level;
2980   while (b->tag_transparent)
2981     b = b->level_chain;
2982   tags = b->tags;
2983   while (tags)
2984     {
2985       /* A NULL purpose means we have already processed all tags
2986          from here to the end of the list.  */
2987       if (TREE_PURPOSE (tags) == NULL_TREE)
2988         break;
2989       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2990         TREE_PURPOSE (tags) = NULL_TREE;
2991       tags = TREE_CHAIN (tags);
2992     }
2993   last_cnt = anon_cnt;
2994 }
2995 \f
2996 /* Subroutine of duplicate_decls: return truthvalue of whether
2997    or not types of these decls match.
2998
2999    For C++, we must compare the parameter list so that `int' can match
3000    `int&' in a parameter position, but `int&' is not confused with
3001    `const int&'.  */
3002
3003 int
3004 decls_match (newdecl, olddecl)
3005      tree newdecl, olddecl;
3006 {
3007   int types_match;
3008
3009   if (newdecl == olddecl)
3010     return 1;
3011
3012   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3013     /* If the two DECLs are not even the same kind of thing, we're not
3014        interested in their types.  */
3015     return 0;
3016
3017   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3018     {
3019       tree f1 = TREE_TYPE (newdecl);
3020       tree f2 = TREE_TYPE (olddecl);
3021       tree p1 = TYPE_ARG_TYPES (f1);
3022       tree p2 = TYPE_ARG_TYPES (f2);
3023
3024       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3025           && ! (DECL_EXTERN_C_P (newdecl)
3026                 && DECL_EXTERN_C_P (olddecl)))
3027         return 0;
3028
3029       if (TREE_CODE (f1) != TREE_CODE (f2))
3030         return 0;
3031
3032       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3033         {
3034           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3035               && (DECL_BUILT_IN (olddecl)
3036 #ifndef NO_IMPLICIT_EXTERN_C
3037                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3038                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3039 #endif
3040               ))
3041             {
3042               types_match = self_promoting_args_p (p1);
3043               if (p1 == void_list_node)
3044                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3045             }
3046 #ifndef NO_IMPLICIT_EXTERN_C
3047           else if (p1 == NULL_TREE
3048                    && (DECL_EXTERN_C_P (olddecl)
3049                        && DECL_IN_SYSTEM_HEADER (olddecl)
3050                        && !DECL_CLASS_SCOPE_P (olddecl))
3051                    && (DECL_EXTERN_C_P (newdecl)
3052                        && DECL_IN_SYSTEM_HEADER (newdecl)
3053                        && !DECL_CLASS_SCOPE_P (newdecl)))
3054             {
3055               types_match = self_promoting_args_p (p2);
3056               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3057             }
3058 #endif
3059           else
3060             types_match = compparms (p1, p2);
3061         }
3062       else
3063         types_match = 0;
3064     }
3065   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3066     {
3067       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3068                                 DECL_TEMPLATE_PARMS (olddecl)))
3069         return 0;
3070
3071       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3072           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3073         return 0;
3074
3075       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3076         types_match = 1;
3077       else
3078         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3079                                    DECL_TEMPLATE_RESULT (newdecl));
3080     }
3081   else
3082     {
3083       if (TREE_TYPE (newdecl) == error_mark_node)
3084         types_match = TREE_TYPE (olddecl) == error_mark_node;
3085       else if (TREE_TYPE (olddecl) == NULL_TREE)
3086         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3087       else if (TREE_TYPE (newdecl) == NULL_TREE)
3088         types_match = 0;
3089       else
3090         types_match = comptypes (TREE_TYPE (newdecl),
3091                                  TREE_TYPE (olddecl),
3092                                  COMPARE_REDECLARATION);
3093     }
3094
3095   return types_match;
3096 }
3097
3098 /* If NEWDECL is `static' and an `extern' was seen previously,
3099    warn about it.  OLDDECL is the previous declaration.
3100
3101    Note that this does not apply to the C++ case of declaring
3102    a variable `extern const' and then later `const'.
3103
3104    Don't complain about built-in functions, since they are beyond
3105    the user's control.  */
3106
3107 static void
3108 warn_extern_redeclared_static (newdecl, olddecl)
3109      tree newdecl, olddecl;
3110 {
3111   static const char *explicit_extern_static_warning
3112     = "`%D' was declared `extern' and later `static'";
3113   static const char *implicit_extern_static_warning
3114     = "`%D' was declared implicitly `extern' and later `static'";
3115
3116   tree name;
3117
3118   if (TREE_CODE (newdecl) == TYPE_DECL
3119       || TREE_CODE (newdecl) == TEMPLATE_DECL
3120       || TREE_CODE (newdecl) == CONST_DECL)
3121     return;
3122
3123   /* Don't get confused by static member functions; that's a different
3124      use of `static'.  */
3125   if (TREE_CODE (newdecl) == FUNCTION_DECL
3126       && DECL_STATIC_FUNCTION_P (newdecl))
3127     return;
3128
3129   /* If the old declaration was `static', or the new one isn't, then
3130      then everything is OK.  */
3131   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3132     return;
3133
3134   /* It's OK to declare a builtin function as `static'.  */
3135   if (TREE_CODE (olddecl) == FUNCTION_DECL
3136       && DECL_ARTIFICIAL (olddecl))
3137     return;
3138
3139   name = DECL_ASSEMBLER_NAME (newdecl);
3140   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3141               ? implicit_extern_static_warning
3142               : explicit_extern_static_warning, newdecl);
3143   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3144 }
3145
3146 /* Handle when a new declaration NEWDECL has the same name as an old
3147    one OLDDECL in the same binding contour.  Prints an error message
3148    if appropriate.
3149
3150    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3151    Otherwise, return 0.  */
3152
3153 int
3154 duplicate_decls (newdecl, olddecl)
3155      tree newdecl, olddecl;
3156 {
3157   unsigned olddecl_uid = DECL_UID (olddecl);
3158   int olddecl_friend = 0, types_match = 0;
3159   int new_defines_function = 0;
3160
3161   if (newdecl == olddecl)
3162     return 1;
3163
3164   types_match = decls_match (newdecl, olddecl);
3165
3166   /* If either the type of the new decl or the type of the old decl is an
3167      error_mark_node, then that implies that we have already issued an
3168      error (earlier) for some bogus type specification, and in that case,
3169      it is rather pointless to harass the user with yet more error message
3170      about the same declaration, so just pretend the types match here.  */
3171   if (TREE_TYPE (newdecl) == error_mark_node
3172       || TREE_TYPE (olddecl) == error_mark_node)
3173     types_match = 1;
3174
3175   /* Check for redeclaration and other discrepancies. */
3176   if (TREE_CODE (olddecl) == FUNCTION_DECL
3177       && DECL_ARTIFICIAL (olddecl))
3178     {
3179       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3180         {
3181           /* If you declare a built-in or predefined function name as static,
3182              the old definition is overridden, but optionally warn this was a
3183              bad choice of name.  */
3184           if (! TREE_PUBLIC (newdecl))
3185             {
3186               if (warn_shadow)
3187                 cp_warning ("shadowing %s function `%#D'",
3188                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3189                             olddecl);
3190               /* Discard the old built-in function.  */
3191               return 0;
3192             }
3193           /* If the built-in is not ansi, then programs can override
3194              it even globally without an error.  */
3195           else if (! DECL_BUILT_IN (olddecl))
3196             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3197                         olddecl, newdecl);
3198           else
3199             {
3200               cp_error ("declaration of `%#D'", newdecl);
3201               cp_error ("conflicts with built-in declaration `%#D'",
3202                         olddecl);
3203             }
3204           return 0;
3205         }
3206       else if (!types_match)
3207         {
3208           if ((DECL_EXTERN_C_P (newdecl)
3209                && DECL_EXTERN_C_P (olddecl))
3210               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3211                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3212             {
3213               /* A near match; override the builtin.  */
3214
3215               if (TREE_PUBLIC (newdecl))
3216                 {
3217                   cp_warning ("new declaration `%#D'", newdecl);
3218                   cp_warning ("ambiguates built-in declaration `%#D'",
3219                               olddecl);
3220                 }
3221               else if (warn_shadow)
3222                 cp_warning ("shadowing %s function `%#D'",
3223                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3224                             olddecl);
3225             }
3226           else
3227             /* Discard the old built-in function.  */
3228             return 0;
3229         }
3230
3231       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3232         {
3233           /* If a builtin function is redeclared as `static', merge
3234              the declarations, but make the original one static.  */
3235           DECL_THIS_STATIC (olddecl) = 1;
3236           TREE_PUBLIC (olddecl) = 0;
3237
3238           /* Make the old declaration consistent with the new one so
3239              that all remnants of the builtin-ness of this function
3240              will be banished.  */
3241           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3242           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3243           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3244           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3245                                        newdecl);
3246         }
3247     }
3248   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3249     {
3250       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3251            && TREE_CODE (newdecl) != TYPE_DECL
3252            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3253                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3254           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3255               && TREE_CODE (olddecl) != TYPE_DECL
3256               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3257                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3258                         == TYPE_DECL))))
3259         {
3260           /* We do nothing special here, because C++ does such nasty
3261              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3262              get shadowed, and know that if we need to find a TYPE_DECL
3263              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3264              slot of the identifier.  */
3265           return 0;
3266         }
3267
3268       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3269            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3270           || (TREE_CODE (olddecl) == FUNCTION_DECL
3271               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3272         return 0;
3273
3274       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3275       if (TREE_CODE (olddecl) == TREE_LIST)
3276         olddecl = TREE_VALUE (olddecl);
3277       cp_error_at ("previous declaration of `%#D'", olddecl);
3278
3279       /* New decl is completely inconsistent with the old one =>
3280          tell caller to replace the old one.  */
3281
3282       return 0;
3283     }
3284   else if (!types_match)
3285     {
3286       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3287         /* These are certainly not duplicate declarations; they're
3288            from different scopes.  */
3289         return 0;
3290
3291       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3292         {
3293           /* The name of a class template may not be declared to refer to
3294              any other template, class, function, object, namespace, value,
3295              or type in the same scope.  */
3296           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3297               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3298             {
3299               cp_error ("declaration of template `%#D'", newdecl);
3300               cp_error_at ("conflicts with previous declaration `%#D'",
3301                            olddecl);
3302             }
3303           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3304                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3305                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3306                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3307                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3308                                            DECL_TEMPLATE_PARMS (olddecl)))
3309             {
3310               cp_error ("new declaration `%#D'", newdecl);
3311               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3312             }
3313           return 0;
3314         }
3315       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3316         {
3317           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3318             {
3319               cp_error ("declaration of C function `%#D' conflicts with",
3320                         newdecl);
3321               cp_error_at ("previous declaration `%#D' here", olddecl);
3322             }
3323           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3324                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3325             {
3326               cp_error ("new declaration `%#D'", newdecl);
3327               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3328             }
3329           else
3330             return 0;
3331         }
3332
3333       /* Already complained about this, so don't do so again.  */
3334       else if (current_class_type == NULL_TREE
3335           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3336         {
3337           cp_error ("conflicting types for `%#D'", newdecl);
3338           cp_error_at ("previous declaration as `%#D'", olddecl);
3339         }
3340     }
3341   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3342             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3343                  && (!DECL_TEMPLATE_INFO (newdecl)
3344                      || (DECL_TI_TEMPLATE (newdecl)
3345                          != DECL_TI_TEMPLATE (olddecl))))
3346                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3347                     && (!DECL_TEMPLATE_INFO (olddecl)
3348                         || (DECL_TI_TEMPLATE (olddecl)
3349                             != DECL_TI_TEMPLATE (newdecl))))))
3350     /* It's OK to have a template specialization and a non-template
3351        with the same type, or to have specializations of two
3352        different templates with the same type.  Note that if one is a
3353        specialization, and the other is an instantiation of the same
3354        template, that we do not exit at this point.  That situation
3355        can occur if we instantiate a template class, and then
3356        specialize one of its methods.  This situation is legal, but
3357        the declarations must be merged in the usual way.  */
3358     return 0;
3359   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3360            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3361                 && !DECL_USE_TEMPLATE (newdecl))
3362                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3363                    && !DECL_USE_TEMPLATE (olddecl))))
3364     /* One of the declarations is a template instantiation, and the
3365        other is not a template at all.  That's OK.  */
3366     return 0;
3367   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3368            && DECL_NAMESPACE_ALIAS (newdecl)
3369            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3370     /* Redeclaration of namespace alias, ignore it. */
3371     return 1;
3372   else
3373     {
3374       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3375       if (errmsg)
3376         {
3377           cp_error (errmsg, newdecl);
3378           if (DECL_NAME (olddecl) != NULL_TREE)
3379             cp_error_at ((DECL_INITIAL (olddecl)
3380                           && namespace_bindings_p ())
3381                          ? "`%#D' previously defined here"
3382                          : "`%#D' previously declared here", olddecl);
3383         }
3384       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3385                && DECL_INITIAL (olddecl) != NULL_TREE
3386                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3387                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3388         {
3389           /* Prototype decl follows defn w/o prototype.  */
3390           cp_warning_at ("prototype for `%#D'", newdecl);
3391           cp_warning_at ("follows non-prototype definition here", olddecl);
3392         }
3393       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3394                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3395         {
3396           /* extern "C" int foo ();
3397              int foo () { bar (); }
3398              is OK.  */
3399           if (current_lang_stack
3400               == &VARRAY_TREE (current_lang_base, 0))
3401             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3402           else
3403             {
3404               cp_error_at ("previous declaration of `%#D' with %L linkage",
3405                            olddecl, DECL_LANGUAGE (olddecl));
3406               cp_error ("conflicts with new declaration with %L linkage",
3407                         DECL_LANGUAGE (newdecl));
3408             }
3409         }
3410
3411       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3412         ;
3413       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3414         {
3415           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3416           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3417           int i = 1;
3418
3419           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3420             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3421
3422           for (; t1 && t1 != void_list_node;
3423                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3424             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3425               {
3426                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3427                                            TREE_PURPOSE (t2)))
3428                   {
3429                     if (pedantic)
3430                       {
3431                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3432                                     i, newdecl);
3433                         cp_pedwarn_at ("after previous specification in `%#D'",
3434                                        olddecl);
3435                       }
3436                   }
3437                 else
3438                   {
3439                     cp_error ("default argument given for parameter %d of `%#D'",
3440                               i, newdecl);
3441                     cp_error_at ("after previous specification in `%#D'",
3442                                  olddecl);
3443                   }
3444               }
3445
3446           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3447               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3448             {
3449               cp_warning ("`%#D' was used before it was declared inline",
3450                           newdecl);
3451               cp_warning_at ("previous non-inline declaration here",
3452                              olddecl);
3453             }
3454         }
3455     }
3456
3457   /* If new decl is `static' and an `extern' was seen previously,
3458      warn about it.  */
3459   warn_extern_redeclared_static (newdecl, olddecl);
3460
3461   /* We have committed to returning 1 at this point.  */
3462   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3463     {
3464       /* Now that functions must hold information normally held
3465          by field decls, there is extra work to do so that
3466          declaration information does not get destroyed during
3467          definition.  */
3468       if (DECL_VINDEX (olddecl))
3469         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3470       if (DECL_VIRTUAL_CONTEXT (olddecl))
3471         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3472       if (DECL_CONTEXT (olddecl))
3473         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3474       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3475         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3476       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3477       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3478       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3479       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3480       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3481       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3482       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3483       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3484
3485       /* Optionally warn about more than one declaration for the same
3486          name, but don't warn about a function declaration followed by a
3487          definition.  */
3488       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3489           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3490           /* Don't warn about extern decl followed by definition. */
3491           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3492           /* Don't warn about friends, let add_friend take care of it. */
3493           && ! DECL_FRIEND_P (newdecl))
3494         {
3495           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3496           cp_warning_at ("previous declaration of `%D'", olddecl);
3497         }
3498     }
3499
3500   /* Deal with C++: must preserve virtual function table size.  */
3501   if (TREE_CODE (olddecl) == TYPE_DECL)
3502     {
3503       register tree newtype = TREE_TYPE (newdecl);
3504       register tree oldtype = TREE_TYPE (olddecl);
3505
3506       if (newtype != error_mark_node && oldtype != error_mark_node
3507           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3508         {
3509           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3510           CLASSTYPE_FRIEND_CLASSES (newtype)
3511             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3512         }
3513
3514       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3515     }
3516
3517   /* Copy all the DECL_... slots specified in the new decl
3518      except for any that we copy here from the old type.  */
3519   DECL_MACHINE_ATTRIBUTES (newdecl)
3520     = merge_machine_decl_attributes (olddecl, newdecl);
3521
3522   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3523     {
3524       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3525       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3526         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3527                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3528
3529       return 1;
3530     }
3531
3532   if (types_match)
3533     {
3534       /* Automatically handles default parameters.  */
3535       tree oldtype = TREE_TYPE (olddecl);
3536       tree newtype;
3537
3538       /* Merge the data types specified in the two decls.  */
3539       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3540
3541       /* If common_type produces a non-typedef type, just use the old type.  */
3542       if (TREE_CODE (newdecl) == TYPE_DECL
3543           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3544         newtype = oldtype;
3545
3546       if (TREE_CODE (newdecl) == VAR_DECL)
3547         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3548       /* Do this after calling `common_type' so that default
3549          parameters don't confuse us.  */
3550       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3551           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3552               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3553         {
3554           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3555                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3556           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3557                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3558
3559           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3560               && DECL_SOURCE_LINE (olddecl) != 0
3561               && flag_exceptions
3562               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3563                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3564             {
3565               cp_error ("declaration of `%F' throws different exceptions",
3566                         newdecl);
3567               cp_error_at ("than previous declaration `%F'", olddecl);
3568             }
3569         }
3570       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3571
3572       /* Lay the type out, unless already done.  */
3573       if (! same_type_p (newtype, oldtype)
3574           && TREE_TYPE (newdecl) != error_mark_node
3575           && !(processing_template_decl && uses_template_parms (newdecl)))
3576         layout_type (TREE_TYPE (newdecl));
3577
3578       if ((TREE_CODE (newdecl) == VAR_DECL
3579            || TREE_CODE (newdecl) == PARM_DECL
3580            || TREE_CODE (newdecl) == RESULT_DECL
3581            || TREE_CODE (newdecl) == FIELD_DECL
3582            || TREE_CODE (newdecl) == TYPE_DECL)
3583           && !(processing_template_decl && uses_template_parms (newdecl)))
3584         layout_decl (newdecl, 0);
3585
3586       /* Merge the type qualifiers.  */
3587       if (TREE_READONLY (newdecl))
3588         TREE_READONLY (olddecl) = 1;
3589       if (TREE_THIS_VOLATILE (newdecl))
3590         TREE_THIS_VOLATILE (olddecl) = 1;
3591
3592       /* Merge the initialization information.  */
3593       if (DECL_INITIAL (newdecl) == NULL_TREE
3594           && DECL_INITIAL (olddecl) != NULL_TREE)
3595         {
3596           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3597           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3598           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3599           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3600               && DECL_LANG_SPECIFIC (newdecl)
3601               && DECL_LANG_SPECIFIC (olddecl))
3602             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3603         }
3604
3605       /* Merge the section attribute.
3606          We want to issue an error if the sections conflict but that must be
3607          done later in decl_attributes since we are called before attributes
3608          are assigned.  */
3609       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3610         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3611
3612       /* Keep the old rtl since we can safely use it.  */
3613       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3614
3615       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3616         {
3617           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3618             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3619           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3620             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3621           DECL_NO_LIMIT_STACK (newdecl)
3622             |= DECL_NO_LIMIT_STACK (olddecl);
3623         }
3624     }
3625   /* If cannot merge, then use the new type and qualifiers,
3626      and don't preserve the old rtl.  */
3627   else
3628     {
3629       /* Clean out any memory we had of the old declaration.  */
3630       tree oldstatic = value_member (olddecl, static_aggregates);
3631       if (oldstatic)
3632         TREE_VALUE (oldstatic) = error_mark_node;
3633
3634       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3635       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3636       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3637       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3638     }
3639
3640   /* Merge the storage class information.  */
3641   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3642   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3643   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3644   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3645   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3646   if (! DECL_EXTERNAL (olddecl))
3647     DECL_EXTERNAL (newdecl) = 0;
3648
3649   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3650     {
3651       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3652       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3653       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3654       DECL_TEMPLATE_INSTANTIATED (newdecl)
3655         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3656       /* Don't really know how much of the language-specific
3657          values we should copy from old to new.  */
3658       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3659       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3660       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3661       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3662       olddecl_friend = DECL_FRIEND_P (olddecl);
3663
3664       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3665       if (TREE_CODE (newdecl) == FUNCTION_DECL
3666           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3667         DECL_BEFRIENDING_CLASSES (newdecl)
3668           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3669                      DECL_BEFRIENDING_CLASSES (olddecl));
3670     }
3671
3672   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3673     {
3674       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3675           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3676         {
3677           /* If newdecl is not a specialization, then it is not a
3678              template-related function at all.  And that means that we
3679              shoud have exited above, returning 0.  */
3680           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3681                               0);
3682
3683           if (TREE_USED (olddecl))
3684             /* From [temp.expl.spec]:
3685
3686                If a template, a member template or the member of a class
3687                template is explicitly specialized then that
3688                specialization shall be declared before the first use of
3689                that specialization that would cause an implicit
3690                instantiation to take place, in every translation unit in
3691                which such a use occurs.  */
3692             cp_error ("explicit specialization of %D after first use",
3693                       olddecl);
3694
3695           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3696         }
3697       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3698
3699       /* If either decl says `inline', this fn is inline, unless its
3700          definition was passed already.  */
3701       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3702         DECL_INLINE (olddecl) = 1;
3703       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3704
3705       if (! types_match)
3706         {
3707           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3708           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3709           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3710         }
3711       if (! types_match || new_defines_function)
3712         {
3713           /* These need to be copied so that the names are available.
3714              Note that if the types do match, we'll preserve inline
3715              info and other bits, but if not, we won't.  */
3716           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3717           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3718         }
3719       if (new_defines_function)
3720         /* If defining a function declared with other language
3721            linkage, use the previously declared language linkage.  */
3722         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3723       else if (types_match)
3724         {
3725           /* If redeclaring a builtin function, and not a definition,
3726              it stays built in.  */
3727           if (DECL_BUILT_IN (olddecl))
3728             {
3729               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3730               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3731               /* If we're keeping the built-in definition, keep the rtl,
3732                  regardless of declaration matches.  */
3733               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3734             }
3735           else
3736             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3737
3738           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3739           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3740             /* Previously saved insns go together with
3741                the function's previous definition.  */
3742             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3743           /* Don't clear out the arguments if we're redefining a function.  */
3744           if (DECL_ARGUMENTS (olddecl))
3745             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3746         }
3747     }
3748
3749   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3750     {
3751       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3752     }
3753
3754   /* Now preserve various other info from the definition.  */
3755   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3756   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3757   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3758   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3759
3760   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3761     {
3762       int function_size;
3763
3764       function_size = sizeof (struct tree_decl);
3765
3766       bcopy ((char *) newdecl + sizeof (struct tree_common),
3767              (char *) olddecl + sizeof (struct tree_common),
3768              function_size - sizeof (struct tree_common));
3769
3770       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3771         {
3772           /* If newdecl is a template instantiation, it is possible that
3773              the following sequence of events has occurred:
3774
3775              o A friend function was declared in a class template.  The
3776              class template was instantiated.
3777
3778              o The instantiation of the friend declaration was
3779              recorded on the instantiation list, and is newdecl.
3780
3781              o Later, however, instantiate_class_template called pushdecl
3782              on the newdecl to perform name injection.  But, pushdecl in
3783              turn called duplicate_decls when it discovered that another
3784              declaration of a global function with the same name already
3785              existed.
3786
3787              o Here, in duplicate_decls, we decided to clobber newdecl.
3788
3789              If we're going to do that, we'd better make sure that
3790              olddecl, and not newdecl, is on the list of
3791              instantiations so that if we try to do the instantiation
3792              again we won't get the clobbered declaration.  */
3793
3794           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3795           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3796
3797           for (; decls; decls = TREE_CHAIN (decls))
3798             if (TREE_VALUE (decls) == newdecl)
3799               TREE_VALUE (decls) = olddecl;
3800         }
3801     }
3802   else
3803     {
3804       bcopy ((char *) newdecl + sizeof (struct tree_common),
3805              (char *) olddecl + sizeof (struct tree_common),
3806              sizeof (struct tree_decl) - sizeof (struct tree_common)
3807              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3808     }
3809
3810   DECL_UID (olddecl) = olddecl_uid;
3811   if (olddecl_friend)
3812     DECL_FRIEND_P (olddecl) = 1;
3813
3814   /* NEWDECL contains the merged attribute lists.
3815      Update OLDDECL to be the same.  */
3816   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3817
3818   return 1;
3819 }
3820
3821 /* Record a decl-node X as belonging to the current lexical scope.
3822    Check for errors (such as an incompatible declaration for the same
3823    name already seen in the same scope).
3824
3825    Returns either X or an old decl for the same name.
3826    If an old decl is returned, it may have been smashed
3827    to agree with what X says.  */
3828
3829 tree
3830 pushdecl (x)
3831      tree x;
3832 {
3833   register tree t;
3834   register tree name;
3835   int need_new_binding;
3836
3837   /* We shouldn't be calling pushdecl when we're generating RTL for a
3838      function that we already did semantic analysis on previously.  */
3839   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3840                       19990913);
3841
3842   need_new_binding = 1;
3843
3844   if (DECL_TEMPLATE_PARM_P (x))
3845     /* Template parameters have no context; they are not X::T even
3846        when declared within a class or namespace.  */
3847     ;
3848   else
3849     {
3850       if (current_function_decl && x != current_function_decl
3851           /* A local declaration for a function doesn't constitute
3852              nesting.  */
3853           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3854           /* A local declaration for an `extern' variable is in the
3855              scope of the current namespace, not the current
3856              function.  */
3857           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3858           && !DECL_CONTEXT (x))
3859         DECL_CONTEXT (x) = current_function_decl;
3860
3861       /* If this is the declaration for a namespace-scope function,
3862          but the declaration itself is in a local scope, mark the
3863          declaration.  */
3864       if (TREE_CODE (x) == FUNCTION_DECL
3865           && DECL_NAMESPACE_SCOPE_P (x)
3866           && current_function_decl
3867           && x != current_function_decl)
3868         DECL_LOCAL_FUNCTION_P (x) = 1;
3869     }
3870
3871   name = DECL_NAME (x);
3872   if (name)
3873     {
3874       int different_binding_level = 0;
3875
3876       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3877         name = TREE_OPERAND (name, 0);
3878
3879       /* In case this decl was explicitly namespace-qualified, look it
3880          up in its namespace context.  */
3881       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3882           && namespace_bindings_p ())
3883         t = namespace_binding (name, DECL_CONTEXT (x));
3884       else
3885         t = lookup_name_current_level (name);
3886
3887       /* [basic.link] If there is a visible declaration of an entity
3888          with linkage having the same name and type, ignoring entities
3889          declared outside the innermost enclosing namespace scope, the
3890          block scope declaration declares that same entity and
3891          receives the linkage of the previous declaration.  */
3892       if (! t && current_function_decl && x != current_function_decl
3893           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3894           && DECL_EXTERNAL (x))
3895         {
3896           /* Look in block scope.  */
3897           t = IDENTIFIER_VALUE (name);
3898           /* Or in the innermost namespace.  */
3899           if (! t)
3900             t = namespace_binding (name, DECL_CONTEXT (x));
3901           /* Does it have linkage?  */
3902           if (t && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3903             t = NULL_TREE;
3904           if (t)
3905             different_binding_level = 1;
3906         }
3907
3908       /* If we are declaring a function, and the result of name-lookup
3909          was an OVERLOAD, look for an overloaded instance that is
3910          actually the same as the function we are declaring.  (If
3911          there is one, we have to merge our declaration with the
3912          previous declaration.)  */
3913       if (t && TREE_CODE (t) == OVERLOAD)
3914         {
3915           tree match;
3916
3917           if (TREE_CODE (x) == FUNCTION_DECL)
3918             for (match = t; match; match = OVL_NEXT (match))
3919               {
3920                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3921                     == DECL_ASSEMBLER_NAME (x))
3922                   break;
3923               }
3924           else
3925             /* Just choose one.  */
3926             match = t;
3927
3928           if (match)
3929             t = OVL_CURRENT (match);
3930           else
3931             t = NULL_TREE;
3932         }
3933
3934       if (t == error_mark_node)
3935         {
3936           /* error_mark_node is 0 for a while during initialization!  */
3937           t = NULL_TREE;
3938           cp_error_at ("`%#D' used prior to declaration", x);
3939         }
3940       else if (t != NULL_TREE)
3941         {
3942           if (different_binding_level)
3943             {
3944               if (decls_match (x, t))
3945                 /* The standard only says that the local extern
3946                    inherits linkage from the previous decl; in
3947                    particular, default args are not shared.  It would
3948                    be nice to propagate inlining info, though.  FIXME.  */
3949                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3950             }
3951           else if (TREE_CODE (t) == PARM_DECL)
3952             {
3953               if (DECL_CONTEXT (t) == NULL_TREE)
3954                 fatal ("parse errors have confused me too much");
3955
3956               /* Check for duplicate params.  */
3957               if (duplicate_decls (x, t))
3958                 return t;
3959             }
3960           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3961                     || DECL_FUNCTION_TEMPLATE_P (x))
3962                    && is_overloaded_fn (t))
3963             /* Don't do anything just yet. */;
3964           else if (t == wchar_decl_node)
3965             {
3966               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3967                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3968
3969               /* Throw away the redeclaration.  */
3970               return t;
3971             }
3972           else if (TREE_CODE (t) != TREE_CODE (x))
3973             {
3974               if (duplicate_decls (x, t))
3975                 return t;
3976             }
3977           else if (duplicate_decls (x, t))
3978             {
3979               if (TREE_CODE (t) == TYPE_DECL)
3980                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3981               else if (TREE_CODE (t) == FUNCTION_DECL)
3982                 check_default_args (t);
3983
3984               return t;
3985             }
3986           else if (DECL_MAIN_P (x))
3987             {
3988               /* A redeclaration of main, but not a duplicate of the
3989                  previous one.
3990
3991                  [basic.start.main]
3992
3993                  This function shall not be overloaded.  */
3994               cp_error_at ("invalid redeclaration of `%D'", t);
3995               cp_error ("as `%D'", x);
3996               /* We don't try to push this declaration since that
3997                  causes a crash.  */
3998               return x;
3999             }
4000         }
4001
4002       check_template_shadow (x);
4003
4004       /* If this is a function conjured up by the backend, massage it
4005          so it looks friendly.  */
4006       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4007         {
4008           retrofit_lang_decl (x);
4009           DECL_LANGUAGE (x) = lang_c;
4010         }
4011
4012       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4013         {
4014           t = push_overloaded_decl (x, PUSH_LOCAL);
4015           if (t != x)
4016             return t;
4017           if (!namespace_bindings_p ())
4018             /* We do not need to create a binding for this name;
4019                push_overloaded_decl will have already done so if
4020                necessary.  */
4021             need_new_binding = 0;
4022         }
4023       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4024         {
4025           t = push_overloaded_decl (x, PUSH_GLOBAL);
4026           if (t == x)
4027             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4028           return t;
4029         }
4030
4031       /* If declaring a type as a typedef, copy the type (unless we're
4032          at line 0), and install this TYPE_DECL as the new type's typedef
4033          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4034       if (TREE_CODE (x) == TYPE_DECL)
4035         {
4036           tree type = TREE_TYPE (x);
4037           if (DECL_SOURCE_LINE (x) == 0)
4038             {
4039               if (TYPE_NAME (type) == 0)
4040                 TYPE_NAME (type) = x;
4041             }
4042           else if (type != error_mark_node && TYPE_NAME (type) != x
4043                    /* We don't want to copy the type when all we're
4044                       doing is making a TYPE_DECL for the purposes of
4045                       inlining.  */
4046                    && (!TYPE_NAME (type)
4047                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4048             {
4049               DECL_ORIGINAL_TYPE (x) = type;
4050               type = build_type_copy (type);
4051               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4052               TYPE_NAME (type) = x;
4053               TREE_TYPE (x) = type;
4054             }
4055
4056           if (type != error_mark_node
4057               && TYPE_NAME (type)
4058               && TYPE_IDENTIFIER (type))
4059             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4060                                                   current_binding_level);
4061
4062         }
4063
4064       /* Multiple external decls of the same identifier ought to match.
4065
4066          We get warnings about inline functions where they are defined.
4067          We get warnings about other functions from push_overloaded_decl.
4068
4069          Avoid duplicate warnings where they are used.  */
4070       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4071         {
4072           tree decl;
4073
4074           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4075           if (decl && TREE_CODE (decl) == OVERLOAD)
4076             decl = OVL_FUNCTION (decl);
4077
4078           if (decl && decl != error_mark_node
4079               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4080               /* If different sort of thing, we already gave an error.  */
4081               && TREE_CODE (decl) == TREE_CODE (x)
4082               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4083             {
4084               cp_pedwarn ("type mismatch with previous external decl", x);
4085               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4086             }
4087         }
4088
4089       /* This name is new in its binding level.
4090          Install the new declaration and return it.  */
4091       if (namespace_bindings_p ())
4092         {
4093           /* Install a global value.  */
4094
4095           /* If the first global decl has external linkage,
4096              warn if we later see static one.  */
4097           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4098             TREE_PUBLIC (name) = 1;
4099
4100           /* Bind the mangled name for the entity.  In the future, we
4101              should not need to do this; mangled names are an
4102              implementation detail of which the front-end should not
4103              need to be aware.  */
4104           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4105                 && t != NULL_TREE)
4106               /* For an ordinary function, we create a binding from
4107                  the mangled name (i.e., NAME) to the DECL.  But, for
4108                  an `extern "C"' function, the mangled name and the
4109                  ordinary name are the same so we need not do this.  */
4110               && !DECL_EXTERN_C_FUNCTION_P (x))
4111             {
4112               tree mangled_name;
4113
4114               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4115                   || TREE_CODE (x) == NAMESPACE_DECL)
4116                 mangled_name = name;
4117               else
4118                 mangled_name = DECL_ASSEMBLER_NAME (x);
4119
4120               if (TREE_CODE (x) == FUNCTION_DECL)
4121                 my_friendly_assert
4122                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4123                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4124               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4125             }
4126
4127           /* Don't forget if the function was used via an implicit decl.  */
4128           if (IDENTIFIER_IMPLICIT_DECL (name)
4129               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4130             TREE_USED (x) = 1;
4131
4132           /* Don't forget if its address was taken in that way.  */
4133           if (IDENTIFIER_IMPLICIT_DECL (name)
4134               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4135             TREE_ADDRESSABLE (x) = 1;
4136
4137           /* Warn about mismatches against previous implicit decl.  */
4138           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4139               /* If this real decl matches the implicit, don't complain.  */
4140               && ! (TREE_CODE (x) == FUNCTION_DECL
4141                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4142             cp_warning
4143               ("`%D' was previously implicitly declared to return `int'", x);
4144
4145           /* If new decl is `static' and an `extern' was seen previously,
4146              warn about it.  */
4147           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4148             warn_extern_redeclared_static (x, t);
4149         }
4150       else
4151         {
4152           /* Here to install a non-global value.  */
4153           tree oldlocal = IDENTIFIER_VALUE (name);
4154           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4155
4156           if (need_new_binding)
4157             {
4158               push_local_binding (name, x, 0);
4159               /* Because push_local_binding will hook X on to the
4160                  current_binding_level's name list, we don't want to
4161                  do that again below.  */
4162               need_new_binding = 0;
4163             }
4164
4165           /* If this is a TYPE_DECL, push it into the type value slot.  */
4166           if (TREE_CODE (x) == TYPE_DECL)
4167             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4168                                                   current_binding_level);
4169
4170           /* Clear out any TYPE_DECL shadowed by a namespace so that
4171              we won't think this is a type.  The C struct hack doesn't
4172              go through namespaces.  */
4173           if (TREE_CODE (x) == NAMESPACE_DECL)
4174             set_identifier_type_value_with_scope (name, NULL_TREE,
4175                                                   current_binding_level);
4176
4177           if (oldlocal)
4178             {
4179               tree d = oldlocal;
4180
4181               while (oldlocal
4182                      && TREE_CODE (oldlocal) == VAR_DECL
4183                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4184                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4185
4186               if (oldlocal == NULL_TREE)
4187                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4188             }
4189
4190           /* If this is an extern function declaration, see if we
4191              have a global definition or declaration for the function.  */
4192           if (oldlocal == NULL_TREE
4193               && DECL_EXTERNAL (x)
4194               && oldglobal != NULL_TREE
4195               && TREE_CODE (x) == FUNCTION_DECL
4196               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4197             {
4198               /* We have one.  Their types must agree.  */
4199               if (decls_match (x, oldglobal))
4200                 /* OK */;
4201               else
4202                 {
4203                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4204                   cp_warning_at ("global declaration `%#D'", oldglobal);
4205                 }
4206             }
4207           /* If we have a local external declaration,
4208              and no file-scope declaration has yet been seen,
4209              then if we later have a file-scope decl it must not be static.  */
4210           if (oldlocal == NULL_TREE
4211               && oldglobal == NULL_TREE
4212               && DECL_EXTERNAL (x)
4213               && TREE_PUBLIC (x))
4214             TREE_PUBLIC (name) = 1;
4215
4216           /* Warn if shadowing an argument at the top level of the body.  */
4217           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4218               /* Inline decls shadow nothing.  */
4219               && !DECL_FROM_INLINE (x)
4220               && TREE_CODE (oldlocal) == PARM_DECL
4221               /* Don't complain if it's from an enclosing function.  */
4222               && DECL_CONTEXT (oldlocal) == current_function_decl
4223               && TREE_CODE (x) != PARM_DECL)
4224             {
4225               /* Go to where the parms should be and see if we
4226                  find them there.  */
4227               struct binding_level *b = current_binding_level->level_chain;
4228
4229               if (cleanup_label)
4230                 b = b->level_chain;
4231
4232               /* ARM $8.3 */
4233               if (b->parm_flag == 1)
4234                 cp_error ("declaration of `%#D' shadows a parameter", name);
4235             }
4236
4237           /* Maybe warn if shadowing something else.  */
4238           if (warn_shadow && !DECL_EXTERNAL (x)
4239               /* Inline decls shadow nothing.  */
4240               && !DECL_FROM_INLINE (x)
4241               /* No shadow warnings for internally generated vars.  */
4242               && ! DECL_ARTIFICIAL (x)
4243               /* No shadow warnings for vars made for inlining.  */
4244               && ! DECL_FROM_INLINE (x))
4245             {
4246               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4247                 warning ("declaration of `%s' shadows a parameter",
4248                         IDENTIFIER_POINTER (name));
4249               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4250                        && current_class_ptr
4251                        && !TREE_STATIC (name))
4252                 warning ("declaration of `%s' shadows a member of `this'",
4253                         IDENTIFIER_POINTER (name));
4254               else if (oldlocal != NULL_TREE)
4255                 warning ("declaration of `%s' shadows previous local",
4256                         IDENTIFIER_POINTER (name));
4257               else if (oldglobal != NULL_TREE)
4258                 /* XXX shadow warnings in outer-more namespaces */
4259                 warning ("declaration of `%s' shadows global declaration",
4260                         IDENTIFIER_POINTER (name));
4261             }
4262         }
4263
4264       if (TREE_CODE (x) == FUNCTION_DECL)
4265         check_default_args (x);
4266
4267       /* Keep count of variables in this level with incomplete type.  */
4268       if (TREE_CODE (x) == VAR_DECL
4269           && TREE_TYPE (x) != error_mark_node
4270           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4271                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4272               /* RTTI TD entries are created while defining the type_info.  */
4273               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4274                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4275         {
4276           if (namespace_bindings_p ())
4277             namespace_scope_incomplete
4278               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4279           else
4280             current_binding_level->incomplete
4281               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4282         }
4283     }
4284
4285   if (need_new_binding)
4286     add_decl_to_level (x,
4287                        DECL_NAMESPACE_SCOPE_P (x)
4288                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4289                        : current_binding_level);
4290
4291   return x;
4292 }
4293
4294 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4295    caller to set DECL_CONTEXT properly.  */
4296
4297 static tree
4298 pushdecl_with_scope (x, level)
4299      tree x;
4300      struct binding_level *level;
4301 {
4302   register struct binding_level *b;
4303   tree function_decl = current_function_decl;
4304
4305   current_function_decl = NULL_TREE;
4306   if (level->parm_flag == 2)
4307     {
4308       b = class_binding_level;
4309       class_binding_level = level;
4310       pushdecl_class_level (x);
4311       class_binding_level = b;
4312     }
4313   else
4314     {
4315       b = current_binding_level;
4316       current_binding_level = level;
4317       x = pushdecl (x);
4318       current_binding_level = b;
4319     }
4320   current_function_decl = function_decl;
4321   return x;
4322 }
4323
4324 /* Like pushdecl, only it places X in the current namespace,
4325    if appropriate.  */
4326
4327 tree
4328 pushdecl_namespace_level (x)
4329      tree x;
4330 {
4331   register struct binding_level *b = current_binding_level;
4332   register tree t;
4333
4334   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4335
4336   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4337      what we want.  */
4338   if (TREE_CODE (x) == TYPE_DECL)
4339     {
4340       tree name = DECL_NAME (x);
4341       tree newval;
4342       tree *ptr = (tree *)0;
4343       for (; b != global_binding_level; b = b->level_chain)
4344         {
4345           tree shadowed = b->type_shadowed;
4346           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4347             if (TREE_PURPOSE (shadowed) == name)
4348               {
4349                 ptr = &TREE_VALUE (shadowed);
4350                 /* Can't break out of the loop here because sometimes
4351                    a binding level will have duplicate bindings for
4352                    PT names.  It's gross, but I haven't time to fix it.  */
4353               }
4354         }
4355       newval = TREE_TYPE (x);
4356       if (ptr == (tree *)0)
4357         {
4358           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4359              up here if this is changed to an assertion.  --KR  */
4360           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4361         }
4362       else
4363         {
4364           *ptr = newval;
4365         }
4366     }
4367   return t;
4368 }
4369
4370 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4371    if appropriate.  */
4372
4373 tree
4374 pushdecl_top_level (x)
4375      tree x;
4376 {
4377   push_to_top_level ();
4378   x = pushdecl_namespace_level (x);
4379   pop_from_top_level ();
4380   return x;
4381 }
4382
4383 /* Make the declaration of X appear in CLASS scope.  */
4384
4385 void
4386 pushdecl_class_level (x)
4387      tree x;
4388 {
4389   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4390      scope looks for the pre-mangled name.  */
4391   register tree name;
4392
4393   if (TREE_CODE (x) == OVERLOAD)
4394     x = OVL_CURRENT (x);
4395   name = DECL_NAME (x);
4396
4397   if (name)
4398     {
4399       push_class_level_binding (name, x);
4400       if (TREE_CODE (x) == TYPE_DECL)
4401         set_identifier_type_value (name, TREE_TYPE (x));
4402     }
4403   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4404     {
4405       tree f;
4406
4407       for (f = TYPE_FIELDS (TREE_TYPE (x));
4408            f;
4409            f = TREE_CHAIN (f))
4410         pushdecl_class_level (f);
4411     }
4412 }
4413
4414 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4415    DECL, or a modified version thereof.  */
4416
4417 tree
4418 maybe_push_decl (decl)
4419      tree decl;
4420 {
4421   tree type = TREE_TYPE (decl);
4422
4423   /* Add this decl to the current binding level, but not if it comes
4424      from another scope, e.g. a static member variable.  TEM may equal
4425      DECL or it may be a previous decl of the same name.  */
4426   if (decl == error_mark_node
4427       || (TREE_CODE (decl) != PARM_DECL
4428           && DECL_CONTEXT (decl) != NULL_TREE
4429           /* Definitions of namespace members outside their namespace are
4430              possible. */
4431           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4432       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4433       || TREE_CODE (type) == UNKNOWN_TYPE
4434       /* The declaration of a template specialization does not affect
4435          the functions available for overload resolution, so we do not
4436          call pushdecl.  */
4437       || (TREE_CODE (decl) == FUNCTION_DECL
4438           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4439     return decl;
4440   else
4441     return pushdecl (decl);
4442 }
4443
4444 /* Make the declaration(s) of X appear in CLASS scope
4445    under the name NAME.  */
4446
4447 void
4448 push_class_level_binding (name, x)
4449      tree name;
4450      tree x;
4451 {
4452   tree binding;
4453   /* The class_binding_level will be NULL if x is a template
4454      parameter name in a member template.  */
4455   if (!class_binding_level)
4456     return;
4457
4458   /* Make sure that this new member does not have the same name
4459      as a template parameter.  */
4460   if (TYPE_BEING_DEFINED (current_class_type))
4461     check_template_shadow (x);
4462
4463   /* If this declaration shadows a declaration from an enclosing
4464      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4465      we leave this class.  Record the shadowed declaration here.  */
4466   binding = IDENTIFIER_BINDING (name);
4467   if (binding
4468       && ((TREE_CODE (x) == OVERLOAD
4469            && BINDING_VALUE (binding)
4470            && is_overloaded_fn (BINDING_VALUE (binding)))
4471           || INHERITED_VALUE_BINDING_P (binding)))
4472     {
4473       tree shadow;
4474       tree old_decl;
4475
4476       /* If the old binding was from a base class, and was for a tag
4477          name, slide it over to make room for the new binding.  The
4478          old binding is still visible if explicitly qualified with a
4479          class-key.  */
4480       if (INHERITED_VALUE_BINDING_P (binding)
4481           && BINDING_VALUE (binding)
4482           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4483           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4484           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4485         {
4486           old_decl = BINDING_TYPE (binding);
4487           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4488           BINDING_VALUE (binding) = NULL_TREE;
4489           INHERITED_VALUE_BINDING_P (binding) = 0;
4490         }
4491       else
4492         old_decl = BINDING_VALUE (binding);
4493
4494       /* There was already a binding for X containing fewer
4495          functions than are named in X.  Find the previous
4496          declaration of X on the class-shadowed list, and update it.  */
4497       for (shadow = class_binding_level->class_shadowed;
4498            shadow;
4499            shadow = TREE_CHAIN (shadow))
4500         if (TREE_PURPOSE (shadow) == name
4501             && TREE_TYPE (shadow) == old_decl)
4502           {
4503             BINDING_VALUE (binding) = x;
4504             INHERITED_VALUE_BINDING_P (binding) = 0;
4505             TREE_TYPE (shadow) = x;
4506             return;
4507           }
4508     }
4509
4510   /* If we didn't replace an existing binding, put the binding on the
4511      stack of bindings for the identifier, and update
4512      IDENTIFIER_CLASS_VALUE.  */
4513   if (push_class_binding (name, x))
4514     {
4515       class_binding_level->class_shadowed
4516         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4517                      class_binding_level->class_shadowed);
4518       /* Record the value we are binding NAME to so that we can know
4519          what to pop later.  */
4520       TREE_TYPE (class_binding_level->class_shadowed) = x;
4521     }
4522 }
4523
4524 /* Insert another USING_DECL into the current binding level, returning
4525    this declaration. If this is a redeclaration, do nothing, and
4526    return NULL_TREE if this not in namespace scope (in namespace
4527    scope, a using decl might extend any previous bindings).  */
4528
4529 tree
4530 push_using_decl (scope, name)
4531      tree scope;
4532      tree name;
4533 {
4534   tree decl;
4535
4536   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4537   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4538   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4539     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4540       break;
4541   if (decl)
4542     return namespace_bindings_p () ? decl : NULL_TREE;
4543   decl = build_lang_decl (USING_DECL, name, void_type_node);
4544   DECL_INITIAL (decl) = scope;
4545   TREE_CHAIN (decl) = current_binding_level->usings;
4546   current_binding_level->usings = decl;
4547   return decl;
4548 }
4549
4550 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4551    changed (i.e. there was already a directive), or the fresh
4552    TREE_LIST otherwise.  */
4553
4554 tree
4555 push_using_directive (used)
4556      tree used;
4557 {
4558   tree ud = current_binding_level->using_directives;
4559   tree iter, ancestor;
4560
4561   /* Check if we already have this. */
4562   if (purpose_member (used, ud) != NULL_TREE)
4563     return NULL_TREE;
4564
4565   /* Recursively add all namespaces used. */
4566   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4567     push_using_directive (TREE_PURPOSE (iter));
4568
4569   ancestor = namespace_ancestor (current_decl_namespace (), used);
4570   ud = current_binding_level->using_directives;
4571   ud = tree_cons (used, ancestor, ud);
4572   current_binding_level->using_directives = ud;
4573   return ud;
4574 }
4575
4576 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4577    other definitions already in place.  We get around this by making
4578    the value of the identifier point to a list of all the things that
4579    want to be referenced by that name.  It is then up to the users of
4580    that name to decide what to do with that list.
4581
4582    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4583    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4584
4585    FLAGS is a bitwise-or of the following values:
4586      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4587                  namespace scope.
4588      PUSH_USING: DECL is being pushed as the result of a using
4589                  declaration.
4590
4591    The value returned may be a previous declaration if we guessed wrong
4592    about what language DECL should belong to (C or C++).  Otherwise,
4593    it's always DECL (and never something that's not a _DECL).  */
4594
4595 tree
4596 push_overloaded_decl (decl, flags)
4597      tree decl;
4598      int flags;
4599 {
4600   tree name = DECL_NAME (decl);
4601   tree old;
4602   tree new_binding;
4603   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4604
4605   if (doing_global)
4606     old = namespace_binding (name, DECL_CONTEXT (decl));
4607   else
4608     old = lookup_name_current_level (name);
4609
4610   if (old)
4611     {
4612       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4613         {
4614           tree t = TREE_TYPE (old);
4615           if (IS_AGGR_TYPE (t) && warn_shadow
4616               && (! DECL_IN_SYSTEM_HEADER (decl)
4617                   || ! DECL_IN_SYSTEM_HEADER (old)))
4618             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4619           old = NULL_TREE;
4620         }
4621       else if (is_overloaded_fn (old))
4622         {
4623           tree tmp;
4624
4625           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4626             {
4627               tree fn = OVL_CURRENT (tmp);
4628
4629               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4630                   && !(flags & PUSH_USING)
4631                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4632                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4633                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4634                           decl, fn);
4635
4636               if (duplicate_decls (decl, fn))
4637                 return fn;
4638             }
4639         }
4640       else if (old == error_mark_node)
4641         /* Ignore the undefined symbol marker.  */
4642         old = NULL_TREE;
4643       else
4644         {
4645           cp_error_at ("previous non-function declaration `%#D'", old);
4646           cp_error ("conflicts with function declaration `%#D'", decl);
4647           return decl;
4648         }
4649     }
4650
4651   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4652     {
4653       if (old && TREE_CODE (old) != OVERLOAD)
4654         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4655       else
4656         new_binding = ovl_cons (decl, old);
4657       if (flags & PUSH_USING)
4658         OVL_USED (new_binding) = 1;
4659     }
4660   else
4661     /* NAME is not ambiguous.  */
4662     new_binding = decl;
4663
4664   if (doing_global)
4665     set_namespace_binding (name, current_namespace, new_binding);
4666   else
4667     {
4668       /* We only create an OVERLOAD if there was a previous binding at
4669          this level, or if decl is a template. In the former case, we
4670          need to remove the old binding and replace it with the new
4671          binding.  We must also run through the NAMES on the binding
4672          level where the name was bound to update the chain.  */
4673
4674       if (TREE_CODE (new_binding) == OVERLOAD && old)
4675         {
4676           tree *d;
4677
4678           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4679                *d;
4680                d = &TREE_CHAIN (*d))
4681             if (*d == old
4682                 || (TREE_CODE (*d) == TREE_LIST
4683                     && TREE_VALUE (*d) == old))
4684               {
4685                 if (TREE_CODE (*d) == TREE_LIST)
4686                   /* Just replace the old binding with the new.  */
4687                   TREE_VALUE (*d) = new_binding;
4688                 else
4689                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4690                   *d = tree_cons (NULL_TREE, new_binding,
4691                                   TREE_CHAIN (*d));
4692
4693                 /* And update the CPLUS_BINDING node.  */
4694                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4695                   = new_binding;
4696                 return decl;
4697               }
4698
4699           /* We should always find a previous binding in this case.  */
4700           my_friendly_abort (0);
4701         }
4702
4703       /* Install the new binding.  */
4704       push_local_binding (name, new_binding, flags);
4705     }
4706
4707   return decl;
4708 }
4709 \f
4710 /* Generate an implicit declaration for identifier FUNCTIONID
4711    as a function of type int ().  Print a warning if appropriate.  */
4712
4713 tree
4714 implicitly_declare (functionid)
4715      tree functionid;
4716 {
4717   register tree decl;
4718
4719   /* We used to reuse an old implicit decl here,
4720      but this loses with inline functions because it can clobber
4721      the saved decl chains.  */
4722   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4723
4724   DECL_EXTERNAL (decl) = 1;
4725   TREE_PUBLIC (decl) = 1;
4726
4727   /* ISO standard says implicit declarations are in the innermost block.
4728      So we record the decl in the standard fashion.  */
4729   pushdecl (decl);
4730   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4731
4732   if (warn_implicit
4733       /* Only one warning per identifier.  */
4734       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4735     {
4736       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4737     }
4738
4739   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4740
4741   return decl;
4742 }
4743
4744 /* Return zero if the declaration NEWDECL is valid
4745    when the declaration OLDDECL (assumed to be for the same name)
4746    has already been seen.
4747    Otherwise return an error message format string with a %s
4748    where the identifier should go.  */
4749
4750 static const char *
4751 redeclaration_error_message (newdecl, olddecl)
4752      tree newdecl, olddecl;
4753 {
4754   if (TREE_CODE (newdecl) == TYPE_DECL)
4755     {
4756       /* Because C++ can put things into name space for free,
4757          constructs like "typedef struct foo { ... } foo"
4758          would look like an erroneous redeclaration.  */
4759       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4760         return 0;
4761       else
4762         return "redefinition of `%#D'";
4763     }
4764   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4765     {
4766       /* If this is a pure function, its olddecl will actually be
4767          the original initialization to `0' (which we force to call
4768          abort()).  Don't complain about redefinition in this case.  */
4769       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4770         return 0;
4771
4772       /* If both functions come from different namespaces, this is not
4773          a redeclaration - this is a conflict with a used function. */
4774       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4775           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4776         return "`%D' conflicts with used function";
4777
4778       /* We'll complain about linkage mismatches in
4779          warn_extern_redeclared_static.  */
4780
4781       /* Defining the same name twice is no good.  */
4782       if (DECL_INITIAL (olddecl) != NULL_TREE
4783           && DECL_INITIAL (newdecl) != NULL_TREE)
4784         {
4785           if (DECL_NAME (olddecl) == NULL_TREE)
4786             return "`%#D' not declared in class";
4787           else
4788             return "redefinition of `%#D'";
4789         }
4790       return 0;
4791     }
4792   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4793     {
4794       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4795            && (DECL_TEMPLATE_RESULT (newdecl)
4796                != DECL_TEMPLATE_RESULT (olddecl))
4797            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4798            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4799           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4800               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4801               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4802         return "redefinition of `%#D'";
4803       return 0;
4804     }
4805   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4806     {
4807       /* Objects declared at top level:  */
4808       /* If at least one is a reference, it's ok.  */
4809       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4810         return 0;
4811       /* Reject two definitions.  */
4812       return "redefinition of `%#D'";
4813     }
4814   else
4815     {
4816       /* Objects declared with block scope:  */
4817       /* Reject two definitions, and reject a definition
4818          together with an external reference.  */
4819       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4820         return "redeclaration of `%#D'";
4821       return 0;
4822     }
4823 }
4824 \f
4825 /* Create a new label, named ID.  */
4826
4827 static tree
4828 make_label_decl (id, local_p)
4829      tree id;
4830      int local_p;
4831 {
4832   tree decl;
4833
4834   decl = build_decl (LABEL_DECL, id, void_type_node);
4835   if (expanding_p)
4836     /* Make sure every label has an rtx.  */
4837     label_rtx (decl);
4838
4839   DECL_CONTEXT (decl) = current_function_decl;
4840   DECL_MODE (decl) = VOIDmode;
4841   C_DECLARED_LABEL_FLAG (decl) = local_p;
4842
4843   /* Say where one reference is to the label, for the sake of the
4844      error if it is not defined.  */
4845   DECL_SOURCE_LINE (decl) = lineno;
4846   DECL_SOURCE_FILE (decl) = input_filename;
4847
4848   /* Record the fact that this identifier is bound to this label.  */
4849   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4850
4851   return decl;
4852 }
4853
4854 /* Record this label on the list of used labels so that we can check
4855    at the end of the function to see whether or not the label was
4856    actually defined, and so we can check when the label is defined whether
4857    this use is valid.  */
4858
4859 static void
4860 use_label (decl)
4861      tree decl;
4862 {
4863   if (named_label_uses == NULL
4864       || named_label_uses->names_in_scope != current_binding_level->names
4865       || named_label_uses->label_decl != decl)
4866     {
4867       struct named_label_use_list *new_ent;
4868       new_ent = ((struct named_label_use_list *)
4869                  ggc_alloc (sizeof (struct named_label_use_list)));
4870       new_ent->label_decl = decl;
4871       new_ent->names_in_scope = current_binding_level->names;
4872       new_ent->binding_level = current_binding_level;
4873       new_ent->lineno_o_goto = lineno;
4874       new_ent->filename_o_goto = input_filename;
4875       new_ent->next = named_label_uses;
4876       named_label_uses = new_ent;
4877     }
4878 }
4879
4880 /* Look for a label named ID in the current function.  If one cannot
4881    be found, create one.  (We keep track of used, but undefined,
4882    labels, and complain about them at the end of a function.)  */
4883
4884 tree
4885 lookup_label (id)
4886      tree id;
4887 {
4888   tree decl;
4889   struct named_label_list *ent;
4890
4891   /* You can't use labels at global scope.  */
4892   if (current_function_decl == NULL_TREE)
4893     {
4894       error ("label `%s' referenced outside of any function",
4895              IDENTIFIER_POINTER (id));
4896       return NULL_TREE;
4897     }
4898
4899   /* See if we've already got this label.  */
4900   decl = IDENTIFIER_LABEL_VALUE (id);
4901   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4902     return decl;
4903
4904   /* Record this label on the list of labels used in this function.
4905      We do this before calling make_label_decl so that we get the
4906      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4907   ent = ((struct named_label_list *)
4908          ggc_alloc_cleared (sizeof (struct named_label_list)));
4909   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4910   ent->next = named_labels;
4911   named_labels = ent;
4912
4913   /* We need a new label.  */
4914   decl = make_label_decl (id, /*local_p=*/0);
4915
4916   /* Now fill in the information we didn't have before.  */
4917   ent->label_decl = decl;
4918
4919   return decl;
4920 }
4921
4922 /* Declare a local label named ID.  */
4923
4924 tree
4925 declare_local_label (id)
4926      tree id;
4927 {
4928   tree decl;
4929
4930   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4931      this scope we can restore the old value of
4932      IDENTIFIER_TYPE_VALUE.  */
4933   current_binding_level->shadowed_labels
4934     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4935                  current_binding_level->shadowed_labels);
4936   /* Look for the label.  */
4937   decl = make_label_decl (id, /*local_p=*/1);
4938   /* Now fill in the information we didn't have before.  */
4939   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4940
4941   return decl;
4942 }
4943
4944 /* Returns nonzero if it is ill-formed to jump past the declaration of
4945    DECL.  Returns 2 if it's also a real problem.  */
4946
4947 static int
4948 decl_jump_unsafe (decl)
4949      tree decl;
4950 {
4951   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4952     return 0;
4953
4954   if (DECL_INITIAL (decl) == NULL_TREE
4955       && pod_type_p (TREE_TYPE (decl)))
4956     return 0;
4957
4958   /* This is really only important if we're crossing an initialization.
4959      The POD stuff is just pedantry; why should it matter if the class
4960      contains a field of pointer to member type?  */
4961   if (DECL_INITIAL (decl)
4962       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4963     return 2;
4964   return 1;
4965 }
4966
4967 /* Check that a single previously seen jump to a newly defined label
4968    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4969    the jump context; NAMES are the names in scope in LEVEL at the jump
4970    context; FILE and LINE are the source position of the jump or 0.  */
4971
4972 static void
4973 check_previous_goto_1 (decl, level, names, file, line)
4974      tree decl;
4975      struct binding_level *level;
4976      tree names;
4977      const char *file;
4978      int line;
4979 {
4980   int identified = 0;
4981   int saw_eh = 0;
4982   struct binding_level *b = current_binding_level;
4983   for (; b; b = b->level_chain)
4984     {
4985       tree new_decls = b->names;
4986       tree old_decls = (b == level ? names : NULL_TREE);
4987       for (; new_decls != old_decls;
4988            new_decls = TREE_CHAIN (new_decls))
4989         {
4990           int problem = decl_jump_unsafe (new_decls);
4991           if (! problem)
4992             continue;
4993
4994           if (! identified)
4995             {
4996               if (decl)
4997                 cp_pedwarn ("jump to label `%D'", decl);
4998               else
4999                 pedwarn ("jump to case label");
5000
5001               if (file)
5002                 pedwarn_with_file_and_line (file, line, "  from here");
5003               identified = 1;
5004             }
5005
5006           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
5007             /* Can't skip init of __exception_info.  */
5008             cp_error_at ("  enters catch block", new_decls);
5009           else if (problem > 1)
5010             cp_error_at ("  crosses initialization of `%#D'",
5011                          new_decls);
5012           else
5013             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
5014                            new_decls);
5015         }
5016
5017       if (b == level)
5018         break;
5019       if (b->eh_region && ! saw_eh)
5020         {
5021           if (! identified)
5022             {
5023               if (decl)
5024                 cp_pedwarn ("jump to label `%D'", decl);
5025               else
5026                 pedwarn ("jump to case label");
5027
5028               if (file)
5029                 pedwarn_with_file_and_line (file, line, "  from here");
5030               identified = 1;
5031             }
5032           error ("  enters try block");
5033           saw_eh = 1;
5034         }
5035     }
5036 }
5037
5038 static void
5039 check_previous_goto (use)
5040      struct named_label_use_list *use;
5041 {
5042   check_previous_goto_1 (use->label_decl, use->binding_level,
5043                          use->names_in_scope, use->filename_o_goto,
5044                          use->lineno_o_goto);
5045 }
5046
5047 static void
5048 check_switch_goto (level)
5049      struct binding_level *level;
5050 {
5051   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5052 }
5053
5054 /* Check that any previously seen jumps to a newly defined label DECL
5055    are OK.  Called by define_label.  */
5056
5057 static void
5058 check_previous_gotos (decl)
5059      tree decl;
5060 {
5061   struct named_label_use_list **usep;
5062
5063   if (! TREE_USED (decl))
5064     return;
5065
5066   for (usep = &named_label_uses; *usep; )
5067     {
5068       struct named_label_use_list *use = *usep;
5069       if (use->label_decl == decl)
5070         {
5071           check_previous_goto (use);
5072           *usep = use->next;
5073         }
5074       else
5075         usep = &(use->next);
5076     }
5077 }
5078
5079 /* Check that a new jump to a label DECL is OK.  Called by
5080    finish_goto_stmt.  */
5081
5082 void
5083 check_goto (decl)
5084      tree decl;
5085 {
5086   int identified = 0;
5087   tree bad;
5088   struct named_label_list *lab;
5089
5090   /* We can't know where a computed goto is jumping.  So we assume
5091      that it's OK.  */
5092   if (! DECL_P (decl))
5093     return;
5094
5095   /* If the label hasn't been defined yet, defer checking.  */
5096   if (! DECL_INITIAL (decl))
5097     {
5098       use_label (decl);
5099       return;
5100     }
5101
5102   for (lab = named_labels; lab; lab = lab->next)
5103     if (decl == lab->label_decl)
5104       break;
5105
5106   /* If the label is not on named_labels it's a gcc local label, so
5107      it must be in an outer scope, so jumping to it is always OK.  */
5108   if (lab == 0)
5109     return;
5110
5111   if ((lab->eh_region || lab->bad_decls) && !identified)
5112     {
5113       cp_pedwarn_at ("jump to label `%D'", decl);
5114       pedwarn ("  from here");
5115       identified = 1;
5116     }
5117
5118   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5119     {
5120       tree b = TREE_VALUE (bad);
5121       int u = decl_jump_unsafe (b);
5122
5123       if (u > 1 && DECL_ARTIFICIAL (b))
5124         /* Can't skip init of __exception_info.  */
5125         cp_error_at ("  enters catch block", b);
5126       else if (u > 1)
5127         cp_error_at ("  skips initialization of `%#D'", b);
5128       else
5129         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5130     }
5131
5132   if (lab->eh_region)
5133     error ("  enters try block");
5134 }
5135
5136 /* Define a label, specifying the location in the source file.
5137    Return the LABEL_DECL node for the label, if the definition is valid.
5138    Otherwise return 0.  */
5139
5140 tree
5141 define_label (filename, line, name)
5142      const char *filename;
5143      int line;
5144      tree name;
5145 {
5146   tree decl = lookup_label (name);
5147   struct named_label_list *ent;
5148
5149   for (ent = named_labels; ent; ent = ent->next)
5150     if (ent->label_decl == decl)
5151       break;
5152
5153   /* After labels, make any new cleanups go into their
5154      own new (temporary) binding contour.  */
5155   current_binding_level->more_cleanups_ok = 0;
5156
5157   if (name == get_identifier ("wchar_t"))
5158     cp_pedwarn ("label named wchar_t");
5159
5160   if (DECL_INITIAL (decl) != NULL_TREE)
5161     {
5162       cp_error ("duplicate label `%D'", decl);
5163       return 0;
5164     }
5165   else
5166     {
5167       /* Mark label as having been defined.  */
5168       DECL_INITIAL (decl) = error_mark_node;
5169       /* Say where in the source.  */
5170       DECL_SOURCE_FILE (decl) = filename;
5171       DECL_SOURCE_LINE (decl) = line;
5172       if (ent)
5173         {
5174           ent->names_in_scope = current_binding_level->names;
5175           ent->binding_level = current_binding_level;
5176         }
5177       check_previous_gotos (decl);
5178       current_function_return_value = NULL_TREE;
5179       return decl;
5180     }
5181 }
5182
5183 struct cp_switch
5184 {
5185   struct binding_level *level;
5186   struct cp_switch *next;
5187 };
5188
5189 static struct cp_switch *switch_stack;
5190
5191 void
5192 push_switch ()
5193 {
5194   struct cp_switch *p
5195     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5196   p->level = current_binding_level;
5197   p->next = switch_stack;
5198   switch_stack = p;
5199 }
5200
5201 void
5202 pop_switch ()
5203 {
5204   struct cp_switch *cs;
5205
5206   cs = switch_stack;
5207   switch_stack = switch_stack->next;
5208   free (cs);
5209 }
5210
5211 /* Note that we've seen a definition of a case label, and complain if this
5212    is a bad place for one.  */
5213
5214 void
5215 define_case_label ()
5216 {
5217   tree cleanup = last_cleanup_this_contour ();
5218
5219   if (! switch_stack)
5220     /* Don't crash; we'll complain in do_case.  */
5221     return;
5222
5223   if (cleanup)
5224     {
5225       static int explained = 0;
5226       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5227       warning ("where case label appears here");
5228       if (!explained)
5229         {
5230           warning ("(enclose actions of previous case statements requiring");
5231           warning ("destructors in their own binding contours.)");
5232           explained = 1;
5233         }
5234     }
5235
5236   check_switch_goto (switch_stack->level);
5237
5238   /* After labels, make any new cleanups go into their
5239      own new (temporary) binding contour.  */
5240
5241   current_binding_level->more_cleanups_ok = 0;
5242   current_function_return_value = NULL_TREE;
5243 }
5244 \f
5245 /* Return the list of declarations of the current level.
5246    Note that this list is in reverse order unless/until
5247    you nreverse it; and when you do nreverse it, you must
5248    store the result back using `storedecls' or you will lose.  */
5249
5250 tree
5251 getdecls ()
5252 {
5253   return current_binding_level->names;
5254 }
5255
5256 /* Return the list of type-tags (for structs, etc) of the current level.  */
5257
5258 tree
5259 gettags ()
5260 {
5261   return current_binding_level->tags;
5262 }
5263
5264 /* Store the list of declarations of the current level.
5265    This is done for the parameter declarations of a function being defined,
5266    after they are modified in the light of any missing parameters.  */
5267
5268 static void
5269 storedecls (decls)
5270      tree decls;
5271 {
5272   current_binding_level->names = decls;
5273 }
5274
5275 /* Similarly, store the list of tags of the current level.  */
5276
5277 void
5278 storetags (tags)
5279      tree tags;
5280 {
5281   current_binding_level->tags = tags;
5282 }
5283 \f
5284 /* Given NAME, an IDENTIFIER_NODE,
5285    return the structure (or union or enum) definition for that name.
5286    Searches binding levels from BINDING_LEVEL up to the global level.
5287    If THISLEVEL_ONLY is nonzero, searches only the specified context
5288    (but skips any tag-transparent contexts to find one that is
5289    meaningful for tags).
5290    FORM says which kind of type the caller wants;
5291    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5292    If the wrong kind of type is found, and it's not a template, an error is
5293    reported.  */
5294
5295 static tree
5296 lookup_tag (form, name, binding_level, thislevel_only)
5297      enum tree_code form;
5298      tree name;
5299      struct binding_level *binding_level;
5300      int thislevel_only;
5301 {
5302   register struct binding_level *level;
5303   /* Non-zero if, we should look past a template parameter level, even
5304      if THISLEVEL_ONLY.  */
5305   int allow_template_parms_p = 1;
5306
5307   for (level = binding_level; level; level = level->level_chain)
5308     {
5309       register tree tail;
5310       if (ANON_AGGRNAME_P (name))
5311         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5312           {
5313             /* There's no need for error checking here, because
5314                anon names are unique throughout the compilation.  */
5315             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5316               return TREE_VALUE (tail);
5317           }
5318       else if (level->namespace_p)
5319         /* Do namespace lookup. */
5320         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5321           {
5322             tree old = binding_for_name (name, tail);
5323
5324             /* If we just skipped past a template parameter level,
5325                even though THISLEVEL_ONLY, and we find a template
5326                class declaration, then we use the _TYPE node for the
5327                template.  See the example below.  */
5328             if (thislevel_only && !allow_template_parms_p
5329                 && old && BINDING_VALUE (old)
5330                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5331               old = TREE_TYPE (BINDING_VALUE (old));
5332             else
5333               old = BINDING_TYPE (old);
5334
5335             /* If it has an original type, it is a typedef, and we
5336                should not return it.  */
5337             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5338               old = NULL_TREE;
5339             if (old && TREE_CODE (old) != form
5340                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5341               {
5342                 cp_error ("`%#D' redeclared as %C", old, form);
5343                 return NULL_TREE;
5344               }
5345             if (old)
5346               return old;
5347             if (thislevel_only || tail == global_namespace)
5348               return NULL_TREE;
5349           }
5350       else
5351         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5352           {
5353             if (TREE_PURPOSE (tail) == name)
5354               {
5355                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5356                 /* Should tighten this up; it'll probably permit
5357                    UNION_TYPE and a struct template, for example.  */
5358                 if (code != form
5359                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5360                   {
5361                     /* Definition isn't the kind we were looking for.  */
5362                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5363                               form);
5364                     return NULL_TREE;
5365                   }
5366                 return TREE_VALUE (tail);
5367               }
5368           }
5369       if (thislevel_only && ! level->tag_transparent)
5370         {
5371           if (level->template_parms_p && allow_template_parms_p)
5372             {
5373               /* We must deal with cases like this:
5374
5375                    template <class T> struct S;
5376                    template <class T> struct S {};
5377
5378                  When looking up `S', for the second declaration, we
5379                  would like to find the first declaration.  But, we
5380                  are in the pseudo-global level created for the
5381                  template parameters, rather than the (surrounding)
5382                  namespace level.  Thus, we keep going one more level,
5383                  even though THISLEVEL_ONLY is non-zero.  */
5384               allow_template_parms_p = 0;
5385               continue;
5386             }
5387           else
5388             return NULL_TREE;
5389         }
5390     }
5391   return NULL_TREE;
5392 }
5393
5394 #if 0
5395 void
5396 set_current_level_tags_transparency (tags_transparent)
5397      int tags_transparent;
5398 {
5399   current_binding_level->tag_transparent = tags_transparent;
5400 }
5401 #endif
5402
5403 /* Given a type, find the tag that was defined for it and return the tag name.
5404    Otherwise return 0.  However, the value can never be 0
5405    in the cases in which this is used.
5406
5407    C++: If NAME is non-zero, this is the new name to install.  This is
5408    done when replacing anonymous tags with real tag names.  */
5409
5410 static tree
5411 lookup_tag_reverse (type, name)
5412      tree type;
5413      tree name;
5414 {
5415   register struct binding_level *level;
5416
5417   for (level = current_binding_level; level; level = level->level_chain)
5418     {
5419       register tree tail;
5420       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5421         {
5422           if (TREE_VALUE (tail) == type)
5423             {
5424               if (name)
5425                 TREE_PURPOSE (tail) = name;
5426               return TREE_PURPOSE (tail);
5427             }
5428         }
5429     }
5430   return NULL_TREE;
5431 }
5432 \f
5433 /* Look up NAME in the NAMESPACE.  */
5434
5435 tree
5436 lookup_namespace_name (namespace, name)
5437      tree namespace, name;
5438 {
5439   tree val;
5440   tree template_id = NULL_TREE;
5441
5442   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5443
5444   if (TREE_CODE (name) == NAMESPACE_DECL)
5445     /* This happens for A::B<int> when B is a namespace. */
5446     return name;
5447   else if (TREE_CODE (name) == TEMPLATE_DECL)
5448     {
5449       /* This happens for A::B where B is a template, and there are no
5450          template arguments.  */
5451       cp_error ("invalid use of `%D'", name);
5452       return error_mark_node;
5453     }
5454
5455   namespace = ORIGINAL_NAMESPACE (namespace);
5456
5457   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5458     {
5459       template_id = name;
5460       name = TREE_OPERAND (name, 0);
5461       if (TREE_CODE (name) == OVERLOAD)
5462         name = DECL_NAME (OVL_CURRENT (name));
5463       else if (DECL_P (name))
5464         name = DECL_NAME (name);
5465     }
5466
5467   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5468
5469   val = make_node (CPLUS_BINDING);
5470   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5471     return error_mark_node;
5472
5473   if (BINDING_VALUE (val))
5474     {
5475       val = BINDING_VALUE (val);
5476
5477       if (template_id)
5478         {
5479           if (DECL_CLASS_TEMPLATE_P (val))
5480             val = lookup_template_class (val,
5481                                          TREE_OPERAND (template_id, 1),
5482                                          /*in_decl=*/NULL_TREE,
5483                                          /*context=*/NULL_TREE,
5484                                          /*entering_scope=*/0);
5485           else if (DECL_FUNCTION_TEMPLATE_P (val)
5486                    || TREE_CODE (val) == OVERLOAD)
5487             val = lookup_template_function (val,
5488                                             TREE_OPERAND (template_id, 1));
5489           else
5490             {
5491               cp_error ("`%D::%D' is not a template",
5492                         namespace, name);
5493               return error_mark_node;
5494             }
5495         }
5496
5497       /* If we have a single function from a using decl, pull it out.  */
5498       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5499         val = OVL_FUNCTION (val);
5500       return val;
5501     }
5502
5503   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5504   return error_mark_node;
5505 }
5506
5507 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5508
5509 static unsigned long
5510 typename_hash (k)
5511      hash_table_key k;
5512 {
5513   unsigned long hash;
5514   tree t;
5515
5516   t = (tree) k;
5517   hash = (((unsigned long) TYPE_CONTEXT (t))
5518           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5519
5520   return hash;
5521 }
5522
5523 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5524
5525 static boolean
5526 typename_compare (k1, k2)
5527      hash_table_key k1;
5528      hash_table_key k2;
5529 {
5530   tree t1;
5531   tree t2;
5532   tree d1;
5533   tree d2;
5534
5535   t1 = (tree) k1;
5536   t2 = (tree) k2;
5537   d1 = TYPE_NAME (t1);
5538   d2 = TYPE_NAME (t2);
5539
5540   return (DECL_NAME (d1) == DECL_NAME (d2)
5541           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5542           && ((TREE_TYPE (t1) != NULL_TREE)
5543               == (TREE_TYPE (t2) != NULL_TREE))
5544           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5545           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5546 }
5547
5548 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5549    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5550    is non-NULL, this type is being created by the implicit typename
5551    extension, and BASE_TYPE is a type named `t' in some base class of
5552    `T' which depends on template parameters.
5553
5554    Returns the new TYPENAME_TYPE.  */
5555
5556 tree
5557 build_typename_type (context, name, fullname, base_type)
5558      tree context;
5559      tree name;
5560      tree fullname;
5561      tree base_type;
5562 {
5563   tree t;
5564   tree d;
5565   struct hash_entry* e;
5566
5567   static struct hash_table ht;
5568
5569   if (!ht.table)
5570     {
5571       static struct hash_table *h = &ht;
5572       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5573                             &typename_compare))
5574         fatal ("virtual memory exhausted");
5575       ggc_add_tree_hash_table_root (&h, 1);
5576     }
5577
5578   /* Build the TYPENAME_TYPE.  */
5579   t = make_aggr_type (TYPENAME_TYPE);
5580   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5581   TYPENAME_TYPE_FULLNAME (t) = fullname;
5582   TREE_TYPE (t) = base_type;
5583
5584   /* Build the corresponding TYPE_DECL.  */
5585   d = build_decl (TYPE_DECL, name, t);
5586   TYPE_NAME (TREE_TYPE (d)) = d;
5587   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5588   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5589   DECL_ARTIFICIAL (d) = 1;
5590
5591   /* See if we already have this type.  */
5592   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5593   if (e)
5594     t = (tree) e->key;
5595   else
5596     /* Insert the type into the table.  */
5597     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5598
5599   return t;
5600 }
5601
5602 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5603    unless an error occurs, in which case error_mark_node is returned.
5604    If COMPLAIN zero, don't complain about any errors that occur.  */
5605
5606 tree
5607 make_typename_type (context, name, complain)
5608      tree context, name;
5609      int complain;
5610 {
5611   tree fullname;
5612
5613   if (TYPE_P (name))
5614     {
5615       if (!(TYPE_LANG_SPECIFIC (name)
5616             && (CLASSTYPE_IS_TEMPLATE (name)
5617                 || CLASSTYPE_USE_TEMPLATE (name))))
5618         name = TYPE_IDENTIFIER (name);
5619       else
5620         /* Create a TEMPLATE_ID_EXPR for the type.  */
5621         name = build_nt (TEMPLATE_ID_EXPR,
5622                          CLASSTYPE_TI_TEMPLATE (name),
5623                          CLASSTYPE_TI_ARGS (name));
5624     }
5625   else if (TREE_CODE (name) == TYPE_DECL)
5626     name = DECL_NAME (name);
5627
5628   fullname = name;
5629
5630   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5631     {
5632       name = TREE_OPERAND (name, 0);
5633       if (TREE_CODE (name) == TEMPLATE_DECL)
5634         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5635     }
5636   if (TREE_CODE (name) != IDENTIFIER_NODE)
5637     my_friendly_abort (2000);
5638
5639   if (TREE_CODE (context) == NAMESPACE_DECL)
5640     {
5641       /* We can get here from typename_sub0 in the explicit_template_type
5642          expansion.  Just fail.  */
5643       if (complain)
5644         cp_error ("no class template named `%#T' in `%#T'",
5645                   name, context);
5646       return error_mark_node;
5647     }
5648
5649   if (! uses_template_parms (context)
5650       || currently_open_class (context))
5651     {
5652       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5653         {
5654           tree tmpl = NULL_TREE;
5655           if (IS_AGGR_TYPE (context))
5656             tmpl = lookup_field (context, name, 0, 0);
5657           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5658             {
5659               if (complain)
5660                 cp_error ("no class template named `%#T' in `%#T'",
5661                           name, context);
5662               return error_mark_node;
5663             }
5664
5665           return lookup_template_class (tmpl,
5666                                         TREE_OPERAND (fullname, 1),
5667                                         NULL_TREE, context,
5668                                         /*entering_scope=*/0);
5669         }
5670       else
5671         {
5672           tree t;
5673
5674           if (!IS_AGGR_TYPE (context))
5675             {
5676               if (complain)
5677                 cp_error ("no type named `%#T' in `%#T'", name, context);
5678               return error_mark_node;
5679             }
5680
5681           t = lookup_field (context, name, 0, 1);
5682           if (t)
5683             return TREE_TYPE (t);
5684         }
5685     }
5686
5687   /* If the CONTEXT is not a template type, then either the field is
5688      there now or its never going to be.  */
5689   if (!uses_template_parms (context))
5690     {
5691       if (complain)
5692         cp_error ("no type named `%#T' in `%#T'", name, context);
5693       return error_mark_node;
5694     }
5695
5696
5697   return build_typename_type (context, name, fullname,  NULL_TREE);
5698 }
5699
5700 /* Select the right _DECL from multiple choices. */
5701
5702 static tree
5703 select_decl (binding, flags)
5704      tree binding;
5705      int flags;
5706 {
5707   tree val;
5708   val = BINDING_VALUE (binding);
5709   if (LOOKUP_NAMESPACES_ONLY (flags))
5710     {
5711       /* We are not interested in types. */
5712       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5713         return val;
5714       return NULL_TREE;
5715     }
5716
5717   /* If we could have a type and
5718      we have nothing or we need a type and have none.  */
5719   if (BINDING_TYPE (binding)
5720       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5721                    && TREE_CODE (val) != TYPE_DECL)))
5722     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5723   /* Don't return non-types if we really prefer types. */
5724   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5725            && (TREE_CODE (val) != TEMPLATE_DECL
5726                || !DECL_CLASS_TEMPLATE_P (val)))
5727     val = NULL_TREE;
5728
5729   return val;
5730 }
5731
5732 /* Unscoped lookup of a global: iterate over current namespaces,
5733    considering using-directives.  If SPACESP is non-NULL, store a list
5734    of the namespaces we've considered in it.  */
5735
5736 tree
5737 unqualified_namespace_lookup (name, flags, spacesp)
5738      tree name;
5739      int flags;
5740      tree *spacesp;
5741 {
5742   tree b = make_node (CPLUS_BINDING);
5743   tree initial = current_decl_namespace();
5744   tree scope = initial;
5745   tree siter;
5746   struct binding_level *level;
5747   tree val = NULL_TREE;
5748
5749   if (spacesp)
5750     *spacesp = NULL_TREE;
5751
5752   for (; !val; scope = CP_DECL_CONTEXT (scope))
5753     {
5754       if (spacesp)
5755         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5756       val = binding_for_name (name, scope);
5757
5758       /* Initialize binding for this context. */
5759       BINDING_VALUE (b) = BINDING_VALUE (val);
5760       BINDING_TYPE (b) = BINDING_TYPE (val);
5761
5762       /* Add all _DECLs seen through local using-directives. */
5763       for (level = current_binding_level;
5764            !level->namespace_p;
5765            level = level->level_chain)
5766         if (!lookup_using_namespace (name, b, level->using_directives,
5767                                      scope, flags, spacesp))
5768           /* Give up because of error. */
5769           return error_mark_node;
5770
5771       /* Add all _DECLs seen through global using-directives. */
5772       /* XXX local and global using lists should work equally. */
5773       siter = initial;
5774       while (1)
5775         {
5776           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5777                                        scope, flags, spacesp))
5778             /* Give up because of error. */
5779             return error_mark_node;
5780           if (siter == scope) break;
5781           siter = CP_DECL_CONTEXT (siter);
5782         }
5783
5784       val = select_decl (b, flags);
5785       if (scope == global_namespace)
5786         break;
5787     }
5788   return val;
5789 }
5790
5791 /* Combine prefer_type and namespaces_only into flags.  */
5792
5793 static int
5794 lookup_flags (prefer_type, namespaces_only)
5795   int prefer_type, namespaces_only;
5796 {
5797   if (namespaces_only)
5798     return LOOKUP_PREFER_NAMESPACES;
5799   if (prefer_type > 1)
5800     return LOOKUP_PREFER_TYPES;
5801   if (prefer_type > 0)
5802     return LOOKUP_PREFER_BOTH;
5803   return 0;
5804 }
5805
5806 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5807    ignore it or not.  Subroutine of lookup_name_real.  */
5808
5809 static tree
5810 qualify_lookup (val, flags)
5811      tree val;
5812      int flags;
5813 {
5814   if (val == NULL_TREE)
5815     return val;
5816   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5817     return val;
5818   if ((flags & LOOKUP_PREFER_TYPES)
5819       && (TREE_CODE (val) == TYPE_DECL
5820           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5821               && DECL_CLASS_TEMPLATE_P (val))))
5822     return val;
5823   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5824     return NULL_TREE;
5825   return val;
5826 }
5827
5828 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5829    that.  */
5830
5831 static void
5832 warn_about_implicit_typename_lookup (typename, binding)
5833      tree typename;
5834      tree binding;
5835 {
5836   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5837   tree name = DECL_NAME (typename);
5838
5839   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5840          && CLASSTYPE_TEMPLATE_INFO (subtype)
5841          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5842       && ! (TREE_CODE (binding) == TYPE_DECL
5843             && same_type_p (TREE_TYPE (binding), subtype)))
5844     {
5845       cp_warning ("lookup of `%D' finds `%#D'",
5846                   name, binding);
5847       cp_warning ("  instead of `%D' from dependent base class",
5848                   typename);
5849       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5850                   constructor_name (current_class_type), name);
5851     }
5852 }
5853
5854 /* Look up NAME in the current binding level and its superiors in the
5855    namespace of variables, functions and typedefs.  Return a ..._DECL
5856    node of some kind representing its definition if there is only one
5857    such declaration, or return a TREE_LIST with all the overloaded
5858    definitions if there are many, or return 0 if it is undefined.
5859
5860    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5861    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5862    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5863    Otherwise we prefer non-TYPE_DECLs.
5864
5865    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5866    using IDENTIFIER_CLASS_VALUE.  */
5867
5868 static tree
5869 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5870      tree name;
5871      int prefer_type, nonclass, namespaces_only;
5872 {
5873   tree t;
5874   tree val = NULL_TREE;
5875   int yylex = 0;
5876   tree from_obj = NULL_TREE;
5877   int flags;
5878   int val_is_implicit_typename = 0;
5879
5880   /* Hack: copy flag set by parser, if set. */
5881   if (only_namespace_names)
5882     namespaces_only = 1;
5883
5884   if (prefer_type == -2)
5885     {
5886       extern int looking_for_typename;
5887       tree type = NULL_TREE;
5888
5889       yylex = 1;
5890       prefer_type = looking_for_typename;
5891
5892       flags = lookup_flags (prefer_type, namespaces_only);
5893       /* If the next thing is '<', class templates are types. */
5894       if (looking_for_template)
5895         flags |= LOOKUP_TEMPLATES_EXPECTED;
5896
5897       /* std:: becomes :: for now.  */
5898       if (got_scope == std_node)
5899         got_scope = void_type_node;
5900
5901       if (got_scope)
5902         type = got_scope;
5903       else if (got_object != error_mark_node)
5904         type = got_object;
5905
5906       if (type)
5907         {
5908           if (type == error_mark_node)
5909             return error_mark_node;
5910           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5911             type = TREE_TYPE (type);
5912
5913           if (TYPE_P (type))
5914             type = complete_type (type);
5915
5916           if (TREE_CODE (type) == VOID_TYPE)
5917             type = global_namespace;
5918           if (TREE_CODE (type) == NAMESPACE_DECL)
5919             {
5920               val = make_node (CPLUS_BINDING);
5921               flags |= LOOKUP_COMPLAIN;
5922               if (!qualified_lookup_using_namespace (name, type, val, flags))
5923                 return NULL_TREE;
5924               val = select_decl (val, flags);
5925             }
5926           else if (! IS_AGGR_TYPE (type)
5927                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5928                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5929                    || TREE_CODE (type) == TYPENAME_TYPE)
5930             /* Someone else will give an error about this if needed.  */
5931             val = NULL_TREE;
5932           else if (type == current_class_type)
5933             val = IDENTIFIER_CLASS_VALUE (name);
5934           else
5935             {
5936               val = lookup_member (type, name, 0, prefer_type);
5937               type_access_control (type, val);
5938
5939               /* Restore the containing TYPENAME_TYPE if we looked
5940                  through it before.  */
5941               if (got_scope && got_scope != type
5942                   && val && TREE_CODE (val) == TYPE_DECL
5943                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5944                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5945             }
5946         }
5947       else
5948         val = NULL_TREE;
5949
5950       if (got_scope)
5951         goto done;
5952       else if (got_object && val)
5953         from_obj = val;
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               && TREE_TYPE (from_obj) != TREE_TYPE (val))
6023             {
6024               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6025                           name, got_object, TREE_TYPE (from_obj));
6026               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
6027                           TREE_TYPE (val));
6028             }
6029
6030           /* We don't change val to from_obj if got_object depends on
6031              template parms because that breaks implicit typename for
6032              destructor calls.  */
6033           if (! uses_template_parms (got_object))
6034             val = from_obj;
6035         }
6036
6037       /* If we have a single function from a using decl, pull it out.  */
6038       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6039         val = OVL_FUNCTION (val);
6040     }
6041   else if (from_obj)
6042     val = from_obj;
6043
6044   return val;
6045 }
6046
6047 tree
6048 lookup_name_nonclass (name)
6049      tree name;
6050 {
6051   return lookup_name_real (name, 0, 1, 0);
6052 }
6053
6054 tree
6055 lookup_function_nonclass (name, args)
6056      tree name;
6057      tree args;
6058 {
6059   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6060 }
6061
6062 tree
6063 lookup_name_namespace_only (name)
6064      tree name;
6065 {
6066   /* type-or-namespace, nonclass, namespace_only */
6067   return lookup_name_real (name, 1, 1, 1);
6068 }
6069
6070 tree
6071 lookup_name (name, prefer_type)
6072      tree name;
6073      int prefer_type;
6074 {
6075   return lookup_name_real (name, prefer_type, 0, 0);
6076 }
6077
6078 /* Similar to `lookup_name' but look only in the innermost non-class
6079    binding level.  */
6080
6081 tree
6082 lookup_name_current_level (name)
6083      tree name;
6084 {
6085   struct binding_level *b;
6086   tree t = NULL_TREE;
6087
6088   b = current_binding_level;
6089   while (b->parm_flag == 2)
6090     b = b->level_chain;
6091
6092   if (b->namespace_p)
6093     {
6094       t = IDENTIFIER_NAMESPACE_VALUE (name);
6095
6096       /* extern "C" function() */
6097       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6098         t = TREE_VALUE (t);
6099     }
6100   else if (IDENTIFIER_BINDING (name)
6101            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6102     {
6103       while (1)
6104         {
6105           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6106             return IDENTIFIER_VALUE (name);
6107
6108           if (b->keep == 2)
6109             b = b->level_chain;
6110           else
6111             break;
6112         }
6113     }
6114
6115   return t;
6116 }
6117
6118 /* Like lookup_name_current_level, but for types.  */
6119
6120 tree
6121 lookup_type_current_level (name)
6122      tree name;
6123 {
6124   register tree t = NULL_TREE;
6125
6126   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6127
6128   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6129       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6130     {
6131       struct binding_level *b = current_binding_level;
6132       while (1)
6133         {
6134           if (purpose_member (name, b->type_shadowed))
6135             return REAL_IDENTIFIER_TYPE_VALUE (name);
6136           if (b->keep == 2)
6137             b = b->level_chain;
6138           else
6139             break;
6140         }
6141     }
6142
6143   return t;
6144 }
6145
6146 void
6147 begin_only_namespace_names ()
6148 {
6149   only_namespace_names = 1;
6150 }
6151
6152 void
6153 end_only_namespace_names ()
6154 {
6155   only_namespace_names = 0;
6156 }
6157 \f
6158 /* Push the declarations of builtin types into the namespace.
6159    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6160    in the array RID_POINTERS.  NAME is the name used when looking
6161    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6162
6163 static void
6164 record_builtin_type (rid_index, name, type)
6165      enum rid rid_index;
6166      const char *name;
6167      tree type;
6168 {
6169   tree rname = NULL_TREE, tname = NULL_TREE;
6170   tree tdecl = NULL_TREE;
6171
6172   if ((int) rid_index < (int) CP_RID_MAX)
6173     rname = ridpointers[(int) rid_index];
6174   if (name)
6175     tname = get_identifier (name);
6176
6177   TYPE_BUILT_IN (type) = 1;
6178
6179   if (tname)
6180     {
6181       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6182       set_identifier_type_value (tname, NULL_TREE);
6183       if ((int) rid_index < (int) CP_RID_MAX)
6184         /* Built-in types live in the global namespace. */
6185         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6186     }
6187   if (rname != NULL_TREE)
6188     {
6189       if (tname != NULL_TREE)
6190         {
6191           set_identifier_type_value (rname, NULL_TREE);
6192           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6193         }
6194       else
6195         {
6196           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6197           set_identifier_type_value (rname, NULL_TREE);
6198         }
6199     }
6200 }
6201
6202 /* Record one of the standard Java types.
6203  * Declare it as having the given NAME.
6204  * If SIZE > 0, it is the size of one of the integral types;
6205  * otherwise it is the negative of the size of one of the other types.  */
6206
6207 static tree
6208 record_builtin_java_type (name, size)
6209      const char *name;
6210      int size;
6211 {
6212   tree type, decl;
6213   if (size > 0)
6214     type = make_signed_type (size);
6215   else if (size > -32)
6216     { /* "__java_char" or ""__java_boolean". */
6217       type = make_unsigned_type (-size);
6218       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6219     }
6220   else
6221     { /* "__java_float" or ""__java_double". */
6222       type = make_node (REAL_TYPE);
6223       TYPE_PRECISION (type) = - size;
6224       layout_type (type);
6225     }
6226   record_builtin_type (CP_RID_MAX, name, type);
6227   decl = TYPE_NAME (type);
6228
6229   /* Suppress generate debug symbol entries for these types,
6230      since for normal C++ they are just clutter.
6231      However, push_lang_context undoes this if extern "Java" is seen. */
6232   DECL_IGNORED_P (decl) = 1;
6233
6234   TYPE_FOR_JAVA (type) = 1;
6235   return type;
6236 }
6237
6238 /* Push a type into the namespace so that the back-ends ignore it. */
6239
6240 static void
6241 record_unknown_type (type, name)
6242      tree type;
6243      const char *name;
6244 {
6245   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6246   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6247   DECL_IGNORED_P (decl) = 1;
6248   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6249   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6250   TYPE_ALIGN (type) = 1;
6251   TYPE_USER_ALIGN (type) = 0;
6252   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6253 }
6254
6255 /* An string for which we should create an IDENTIFIER_NODE at
6256    startup.  */
6257
6258 typedef struct predefined_identifier
6259 {
6260   /* The name of the identifier.  */
6261   const char *name;
6262   /* The place where the IDENTIFIER_NODE should be stored.  */
6263   tree *node;
6264   /* Non-zero if this is the name of a constructor or destructor.  */
6265   int ctor_or_dtor_p;
6266 } predefined_identifier;
6267
6268 /* Create all the predefined identifiers.  */
6269
6270 static void
6271 initialize_predefined_identifiers ()
6272 {
6273   struct predefined_identifier *pid;
6274
6275   /* A table of identifiers to create at startup.  */
6276   static predefined_identifier predefined_identifiers[] = {
6277     { "C++", &lang_name_cplusplus, 0 },
6278     { "C", &lang_name_c, 0 },
6279     { "Java", &lang_name_java, 0 },
6280     { CTOR_NAME, &ctor_identifier, 1 },
6281     { "__base_ctor", &base_ctor_identifier, 1 },
6282     { "__comp_ctor", &complete_ctor_identifier, 1 },
6283     { DTOR_NAME, &dtor_identifier, 1 },
6284     { "__comp_dtor", &complete_dtor_identifier, 1 },
6285     { "__base_dtor", &base_dtor_identifier, 1 },
6286     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6287     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6288     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6289     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6290     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6291     { "nelts", &nelts_identifier, 0 },
6292     { THIS_NAME, &this_identifier, 0 },
6293     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6294     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6295     { "_vptr", &vptr_identifier, 0 },
6296     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6297     { "__vtt_parm", &vtt_parm_identifier, 0 },
6298     { "std", &std_identifier, 0 },
6299     { NULL, NULL, 0 }
6300   };
6301
6302   for (pid = predefined_identifiers; pid->name; ++pid)
6303     {
6304       *pid->node = get_identifier (pid->name);
6305       if (pid->ctor_or_dtor_p)
6306         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6307     }
6308 }
6309
6310 /* Create the predefined scalar types of C,
6311    and some nodes representing standard constants (0, 1, (void *)0).
6312    Initialize the global binding level.
6313    Make definitions for built-in primitive functions.  */
6314
6315 void
6316 init_decl_processing ()
6317 {
6318   tree fields[20];
6319   int wchar_type_size;
6320   tree array_domain_type;
6321
6322   /* Check to see that the user did not specify an invalid combination
6323      of command-line options.  */
6324   if (flag_new_abi && !flag_vtable_thunks)
6325     fatal ("the new ABI requires vtable thunks");
6326
6327   /* Create all the identifiers we need.  */
6328   initialize_predefined_identifiers ();
6329
6330   /* Let the back-end now how to save and restore language-specific
6331      per-function globals.  */
6332   init_lang_status = &push_cp_function_context;
6333   free_lang_status = &pop_cp_function_context;
6334   mark_lang_status = &mark_cp_function_context;
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   /* Define `int' and `char' first so that dbx will output them first.  */
6375   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6376   record_builtin_type (RID_CHAR, "char", char_type_node);
6377
6378   /* `signed' is the same as `int' */
6379   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6380   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6381   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6382   record_builtin_type (CP_RID_MAX, "long unsigned int",
6383                        long_unsigned_type_node);
6384   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6385   record_builtin_type (CP_RID_MAX, "long long int",
6386                        long_long_integer_type_node);
6387   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6388                        long_long_unsigned_type_node);
6389   record_builtin_type (CP_RID_MAX, "long long unsigned",
6390                        long_long_unsigned_type_node);
6391   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6392   record_builtin_type (CP_RID_MAX, "short unsigned int",
6393                        short_unsigned_type_node);
6394   record_builtin_type (CP_RID_MAX, "unsigned short",
6395                        short_unsigned_type_node);
6396
6397   ptrdiff_type_node
6398     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6399
6400   /* Define both `signed char' and `unsigned char'.  */
6401   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6402   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6403
6404   /* `unsigned long' is the standard type for sizeof.
6405      Note that stddef.h uses `unsigned long',
6406      and this must agree, even if long and int are the same size.  */
6407   set_sizetype
6408     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6409
6410   /* Create the widest literal types. */
6411   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6412   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6413                         widest_integer_literal_type_node));
6414
6415   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6416   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6417                         widest_unsigned_literal_type_node));
6418
6419   /* These are types that type_for_size and type_for_mode use.  */
6420   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6421   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6422   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6423   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6424 #if HOST_BITS_PER_WIDE_INT >= 64
6425   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6426 #endif
6427   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6428   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6429   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6430   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6431 #if HOST_BITS_PER_WIDE_INT >= 64
6432   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6433 #endif
6434
6435   build_common_tree_nodes_2 (flag_short_double);
6436
6437   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6438   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6439   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6440   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6441   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6442   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6443   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6444   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6445
6446   integer_two_node = build_int_2 (2, 0);
6447   TREE_TYPE (integer_two_node) = integer_type_node;
6448   integer_three_node = build_int_2 (3, 0);
6449   TREE_TYPE (integer_three_node) = integer_type_node;
6450
6451   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6452   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6453   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6454   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6455   TYPE_PRECISION (boolean_type_node) = 1;
6456   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6457   boolean_false_node = build_int_2 (0, 0);
6458   TREE_TYPE (boolean_false_node) = boolean_type_node;
6459   boolean_true_node = build_int_2 (1, 0);
6460   TREE_TYPE (boolean_true_node) = boolean_type_node;
6461
6462   signed_size_zero_node = build_int_2 (0, 0);
6463   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6464   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6465   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6466
6467   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6468                         complex_integer_type_node));
6469   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6470                         complex_float_type_node));
6471   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6472                         complex_double_type_node));
6473   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6474                         complex_long_double_type_node));
6475
6476   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6477
6478   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6479   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6480   TREE_PARMLIST (void_list_node) = 1;
6481
6482   /* Used for expressions that do nothing, but are not errors.  */
6483   void_zero_node = build_int_2 (0, 0);
6484   TREE_TYPE (void_zero_node) = void_type_node;
6485
6486   string_type_node = build_pointer_type (char_type_node);
6487   const_string_type_node
6488     = build_pointer_type (build_qualified_type (char_type_node,
6489                                                 TYPE_QUAL_CONST));
6490   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6491 #if 0
6492   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6493 #endif
6494
6495   /* Make a type to be the domain of a few array types
6496      whose domains don't really matter.
6497      200 is small enough that it always fits in size_t.  */
6498   array_domain_type = build_index_type (build_int_2 (200, 0));
6499
6500   /* Make a type for arrays of characters.
6501      With luck nothing will ever really depend on the length of this
6502      array type.  */
6503   char_array_type_node
6504     = build_array_type (char_type_node, array_domain_type);
6505
6506   /* Likewise for arrays of ints.  */
6507   int_array_type_node
6508     = build_array_type (integer_type_node, array_domain_type);
6509
6510   if (flag_new_abi)
6511     delta_type_node = ptrdiff_type_node;
6512   else if (flag_huge_objects)
6513     delta_type_node = long_integer_type_node;
6514   else
6515     delta_type_node = short_integer_type_node;
6516
6517   if (flag_new_abi)
6518     vtable_index_type = ptrdiff_type_node;
6519   else
6520     vtable_index_type = delta_type_node;
6521
6522   default_function_type
6523     = build_function_type (integer_type_node, NULL_TREE);
6524
6525   ptr_type_node = build_pointer_type (void_type_node);
6526   const_ptr_type_node
6527     = build_pointer_type (build_qualified_type (void_type_node,
6528                                                 TYPE_QUAL_CONST));
6529   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6530   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6531   lang_type_promotes_to = convert_type_from_ellipsis;
6532
6533   void_ftype_ptr
6534     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6535
6536   /* C++ extensions */
6537
6538   unknown_type_node = make_node (UNKNOWN_TYPE);
6539   record_unknown_type (unknown_type_node, "unknown type");
6540
6541   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6542   TREE_TYPE (unknown_type_node) = unknown_type_node;
6543
6544   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6545
6546   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6547      result.  */
6548   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6549   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6550
6551   /* This is special for C++ so functions can be overloaded.  */
6552   wchar_type_node = get_identifier (flag_short_wchar
6553                                     ? "short unsigned int"
6554                                     : WCHAR_TYPE);
6555   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6556   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6557   if (TREE_UNSIGNED (wchar_type_node))
6558     wchar_type_node = make_signed_type (wchar_type_size);
6559   else
6560     wchar_type_node = make_unsigned_type (wchar_type_size);
6561   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6562
6563   /* Artificial declaration of wchar_t -- can be bashed */
6564   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6565                                 wchar_type_node);
6566   pushdecl (wchar_decl_node);
6567
6568   /* This is for wide string constants.  */
6569   wchar_array_type_node
6570     = build_array_type (wchar_type_node, array_domain_type);
6571
6572   if (flag_vtable_thunks)
6573     {
6574       /* Make sure we get a unique function type, so we can give
6575          its pointer type a name.  (This wins for gdb.) */
6576       tree vfunc_type = make_node (FUNCTION_TYPE);
6577       TREE_TYPE (vfunc_type) = integer_type_node;
6578       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6579       layout_type (vfunc_type);
6580
6581       vtable_entry_type = build_pointer_type (vfunc_type);
6582     }
6583   else
6584     {
6585       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6586       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6587                               delta_type_node);
6588       fields[1] = build_decl (FIELD_DECL, index_identifier,
6589                               delta_type_node);
6590       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6591                               ptr_type_node);
6592       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6593                            double_type_node);
6594
6595       /* Make this part of an invisible union.  */
6596       fields[3] = copy_node (fields[2]);
6597       TREE_TYPE (fields[3]) = delta_type_node;
6598       DECL_NAME (fields[3]) = delta2_identifier;
6599       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6600       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6601       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6602       TREE_UNSIGNED (fields[3]) = 0;
6603       TREE_CHAIN (fields[2]) = fields[3];
6604       vtable_entry_type = build_qualified_type (vtable_entry_type,
6605                                                 TYPE_QUAL_CONST);
6606     }
6607   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6608
6609   vtbl_type_node
6610     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6611   layout_type (vtbl_type_node);
6612   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6613   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6614   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6615   layout_type (vtbl_ptr_type_node);
6616   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6617
6618   std_node = build_decl (NAMESPACE_DECL,
6619                          flag_honor_std
6620                          ? get_identifier ("fake std") : std_identifier,
6621                          void_type_node);
6622   pushdecl (std_node);
6623
6624   if (flag_new_abi)
6625     {
6626       push_namespace (get_identifier ("__cxxabiv1"));
6627       abi_node = current_namespace;
6628       pop_namespace ();
6629     }
6630
6631   global_type_node = make_node (LANG_TYPE);
6632   record_unknown_type (global_type_node, "global type");
6633
6634   /* Now, C++.  */
6635   current_lang_name = lang_name_cplusplus;
6636
6637   {
6638     tree bad_alloc_type_node, newtype, deltype;
6639     if (flag_honor_std)
6640       push_namespace (get_identifier ("std"));
6641     bad_alloc_type_node = xref_tag
6642       (class_type_node, get_identifier ("bad_alloc"), 1);
6643     if (flag_honor_std)
6644       pop_namespace ();
6645     newtype = build_exception_variant
6646       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6647     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6648     push_cp_library_fn (NEW_EXPR, newtype);
6649     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6650     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6651     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6652   }
6653
6654   abort_fndecl
6655     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6656
6657   /* Perform other language dependent initializations.  */
6658   init_class_processing ();
6659   init_init_processing ();
6660   init_search_processing ();
6661   init_rtti_processing ();
6662
6663   if (flag_exceptions)
6664     init_exception_processing ();
6665   if (flag_no_inline)
6666     {
6667       flag_inline_functions = 0;
6668     }
6669
6670   if (! supports_one_only ())
6671     flag_weak = 0;
6672
6673   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6674   function_id_node = get_identifier ("__FUNCTION__");
6675   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6676   func_id_node = get_identifier ("__func__");
6677
6678   make_fname_decl = cp_make_fname_decl;
6679   declare_function_name ();
6680
6681   /* Prepare to check format strings against argument lists.  */
6682   init_function_format_info ();
6683
6684   /* Show we use EH for cleanups.  */
6685   using_eh_for_cleanups ();
6686
6687   valid_lang_attribute = cp_valid_lang_attribute;
6688
6689   /* Maintain consistency.  Perhaps we should just complain if they
6690      say -fwritable-strings?  */
6691   if (flag_writable_strings)
6692     flag_const_strings = 0;
6693
6694   /* Add GC roots for all of our global variables.  */
6695   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6696   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6697   ggc_add_tree_root (&integer_three_node, 1);
6698   ggc_add_tree_root (&integer_two_node, 1);
6699   ggc_add_tree_root (&signed_size_zero_node, 1);
6700   ggc_add_tree_root (&size_one_node, 1);
6701   ggc_add_tree_root (&size_zero_node, 1);
6702   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6703                 mark_binding_level);
6704   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6705   ggc_add_tree_root (&static_ctors, 1);
6706   ggc_add_tree_root (&static_dtors, 1);
6707   ggc_add_tree_root (&lastiddecl, 1);
6708
6709   ggc_add_tree_root (&last_function_parm_tags, 1);
6710   ggc_add_tree_root (&current_function_return_value, 1);
6711   ggc_add_tree_root (&current_function_parms, 1);
6712   ggc_add_tree_root (&current_function_parm_tags, 1);
6713   ggc_add_tree_root (&last_function_parms, 1);
6714   ggc_add_tree_root (&error_mark_list, 1);
6715
6716   ggc_add_tree_root (&global_namespace, 1);
6717   ggc_add_tree_root (&global_type_node, 1);
6718   ggc_add_tree_root (&anonymous_namespace_name, 1);
6719
6720   ggc_add_tree_root (&got_object, 1);
6721   ggc_add_tree_root (&got_scope, 1);
6722
6723   ggc_add_tree_root (&current_lang_name, 1);
6724   ggc_add_tree_root (&static_aggregates, 1);
6725 }
6726
6727 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6728    decl, NAME is the initialization string and TYPE_DEP indicates whether
6729    NAME depended on the type of the function. We make use of that to detect
6730    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6731    the function before emitting any of it, we don't need to treat the
6732    VAR_DECL specially. We can decide whether to emit it later, if it was
6733    used.  */
6734
6735 static tree
6736 cp_make_fname_decl (id, name, type_dep)
6737      tree id;
6738      const char *name;
6739      int type_dep;
6740 {
6741   tree decl, type, init;
6742   size_t length = strlen (name);
6743   tree domain = NULL_TREE;
6744
6745   if (!processing_template_decl)
6746     type_dep = 0;
6747   if (!type_dep)
6748     domain = build_index_type (build_int_2 (length, 0));
6749
6750   type =  build_cplus_array_type
6751           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6752            domain);
6753
6754   decl = build_decl (VAR_DECL, id, type);
6755   TREE_STATIC (decl) = 1;
6756   TREE_READONLY (decl) = 1;
6757   DECL_SOURCE_LINE (decl) = 0;
6758   DECL_ARTIFICIAL (decl) = 1;
6759   DECL_IN_SYSTEM_HEADER (decl) = 1;
6760   pushdecl (decl);
6761   if (processing_template_decl)
6762     decl = push_template_decl (decl);
6763   if (type_dep)
6764     {
6765       init = build (FUNCTION_NAME, type);
6766       DECL_PRETTY_FUNCTION_P (decl) = 1;
6767     }
6768   else
6769     {
6770       init = build_string (length + 1, name);
6771       TREE_TYPE (init) = type;
6772     }
6773   DECL_INITIAL (decl) = init;
6774   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6775
6776   /* We will have to make sure we only emit this, if it is actually used. */
6777   return decl;
6778 }
6779
6780 /* Entry point for the benefit of c_common_nodes_and_builtins.
6781
6782    Make a definition for a builtin function named NAME and whose data type
6783    is TYPE.  TYPE should be a function type with argument types.
6784
6785    CLASS and CODE tell later passes how to compile calls to this function.
6786    See tree.h for possible values.
6787
6788    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6789    the name to be called if we can't opencode the function.  */
6790
6791 tree
6792 builtin_function (name, type, code, class, libname)
6793      const char *name;
6794      tree type;
6795      int code;
6796      enum built_in_class class;
6797      const char *libname;
6798 {
6799   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6800   DECL_BUILT_IN_CLASS (decl) = class;
6801   DECL_FUNCTION_CODE (decl) = code;
6802
6803   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6804
6805   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6806      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6807      function in the namespace.  */
6808   pushdecl (decl);
6809   if (libname)
6810     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6811   make_function_rtl (decl);
6812
6813   /* Warn if a function in the namespace for users
6814      is used without an occasion to consider it declared.  */
6815   if (name[0] != '_' || name[1] != '_')
6816     DECL_ANTICIPATED (decl) = 1;
6817
6818   return decl;
6819 }
6820
6821 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6822    function.  Not called directly.  */
6823
6824 static tree
6825 build_library_fn_1 (name, operator_code, type)
6826      tree name;
6827      enum tree_code operator_code;
6828      tree type;
6829 {
6830   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6831   DECL_EXTERNAL (fn) = 1;
6832   TREE_PUBLIC (fn) = 1;
6833   DECL_ARTIFICIAL (fn) = 1;
6834   TREE_NOTHROW (fn) = 1;
6835   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6836   return fn;
6837 }
6838
6839 /* Returns the _DECL for a library function with C linkage.
6840    We assume that such functions never throw; if this is incorrect,
6841    callers should unset TREE_NOTHROW.  */
6842
6843 tree
6844 build_library_fn (name, type)
6845      tree name;
6846      tree type;
6847 {
6848   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6849   make_function_rtl (fn);
6850   return fn;
6851 }
6852
6853 /* Returns the _DECL for a library function with C++ linkage.  */
6854
6855 static tree
6856 build_cp_library_fn (name, operator_code, type)
6857      tree name;
6858      enum tree_code operator_code;
6859      tree type;
6860 {
6861   tree fn = build_library_fn_1 (name, operator_code, type);
6862   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6863   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6864   set_mangled_name_for_decl (fn);
6865   make_function_rtl (fn);
6866   return fn;
6867 }
6868
6869 /* Like build_library_fn, but takes a C string instead of an
6870    IDENTIFIER_NODE.  */
6871
6872 tree
6873 build_library_fn_ptr (name, type)
6874      const char *name;
6875      tree type;
6876 {
6877   return build_library_fn (get_identifier (name), type);
6878 }
6879
6880 /* Like build_cp_library_fn, but takes a C string instead of an
6881    IDENTIFIER_NODE.  */
6882
6883 tree
6884 build_cp_library_fn_ptr (name, type)
6885      const char *name;
6886      tree type;
6887 {
6888   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6889 }
6890
6891 /* Like build_library_fn, but also pushes the function so that we will
6892    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6893
6894 tree
6895 push_library_fn (name, type)
6896      tree name, type;
6897 {
6898   tree fn = build_library_fn (name, type);
6899   pushdecl_top_level (fn);
6900   return fn;
6901 }
6902
6903 /* Like build_cp_library_fn, but also pushes the function so that it
6904    will be found by normal lookup.  */
6905
6906 static tree
6907 push_cp_library_fn (operator_code, type)
6908      enum tree_code operator_code;
6909      tree type;
6910 {
6911   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6912                                  operator_code,
6913                                  type);
6914   pushdecl (fn);
6915   return fn;
6916 }
6917
6918 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6919    a FUNCTION_TYPE.  */
6920
6921 tree
6922 push_void_library_fn (name, parmtypes)
6923      tree name, parmtypes;
6924 {
6925   tree type = build_function_type (void_type_node, parmtypes);
6926   return push_library_fn (name, type);
6927 }
6928
6929 /* Like push_library_fn, but also note that this function throws
6930    and does not return.  Used for __throw_foo and the like.  */
6931
6932 tree
6933 push_throw_library_fn (name, type)
6934      tree name, type;
6935 {
6936   tree fn = push_library_fn (name, type);
6937   TREE_THIS_VOLATILE (fn) = 1;
6938   TREE_NOTHROW (fn) = 0;
6939   return fn;
6940 }
6941 \f
6942 /* When we call finish_struct for an anonymous union, we create
6943    default copy constructors and such.  But, an anonymous union
6944    shouldn't have such things; this function undoes the damage to the
6945    anonymous union type T.
6946
6947    (The reason that we create the synthesized methods is that we don't
6948    distinguish `union { int i; }' from `typedef union { int i; } U'.
6949    The first is an anonymous union; the second is just an ordinary
6950    union type.)  */
6951
6952 void
6953 fixup_anonymous_aggr (t)
6954      tree t;
6955 {
6956   tree *q;
6957
6958   /* Wipe out memory of synthesized methods */
6959   TYPE_HAS_CONSTRUCTOR (t) = 0;
6960   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6961   TYPE_HAS_INIT_REF (t) = 0;
6962   TYPE_HAS_CONST_INIT_REF (t) = 0;
6963   TYPE_HAS_ASSIGN_REF (t) = 0;
6964   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6965
6966   /* Splice the implicitly generated functions out of the TYPE_METHODS
6967      list.  */
6968   q = &TYPE_METHODS (t);
6969   while (*q)
6970     {
6971       if (DECL_ARTIFICIAL (*q))
6972         *q = TREE_CHAIN (*q);
6973       else
6974         q = &TREE_CHAIN (*q);
6975     }
6976
6977   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6978   if (TYPE_METHODS (t))
6979     error ("an anonymous union cannot have function members");
6980 }
6981
6982 /* Make sure that a declaration with no declarator is well-formed, i.e.
6983    just defines a tagged type or anonymous union.
6984
6985    Returns the type defined, if any.  */
6986
6987 tree
6988 check_tag_decl (declspecs)
6989      tree declspecs;
6990 {
6991   int found_type = 0;
6992   int saw_friend = 0;
6993   tree ob_modifier = NULL_TREE;
6994   register tree link;
6995   register tree t = NULL_TREE;
6996
6997   for (link = declspecs; link; link = TREE_CHAIN (link))
6998     {
6999       register tree value = TREE_VALUE (link);
7000
7001       if (TYPE_P (value)
7002           || (TREE_CODE (value) == IDENTIFIER_NODE
7003               && IDENTIFIER_GLOBAL_VALUE (value)
7004               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7005         {
7006           ++found_type;
7007
7008           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7009               || TREE_CODE (value) == ENUMERAL_TYPE)
7010             {
7011               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7012               t = value;
7013             }
7014         }
7015       else if (value == ridpointers[(int) RID_FRIEND])
7016         {
7017           if (current_class_type == NULL_TREE
7018               || current_scope () != current_class_type)
7019             ob_modifier = value;
7020           else
7021             saw_friend = 1;
7022         }
7023       else if (value == ridpointers[(int) RID_STATIC]
7024                || value == ridpointers[(int) RID_EXTERN]
7025                || value == ridpointers[(int) RID_AUTO]
7026                || value == ridpointers[(int) RID_REGISTER]
7027                || value == ridpointers[(int) RID_INLINE]
7028                || value == ridpointers[(int) RID_VIRTUAL]
7029                || value == ridpointers[(int) RID_CONST]
7030                || value == ridpointers[(int) RID_VOLATILE]
7031                || value == ridpointers[(int) RID_EXPLICIT])
7032         ob_modifier = value;
7033     }
7034
7035   if (found_type > 1)
7036     error ("multiple types in one declaration");
7037
7038   if (t == NULL_TREE && ! saw_friend)
7039     pedwarn ("declaration does not declare anything");
7040
7041   /* Check for an anonymous union.  We're careful
7042      accessing TYPE_IDENTIFIER because some built-in types, like
7043      pointer-to-member types, do not have TYPE_NAME.  */
7044   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7045            && TYPE_NAME (t)
7046            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7047     {
7048       /* Anonymous unions are objects, so they can have specifiers.  */;
7049       SET_ANON_AGGR_TYPE_P (t);
7050
7051       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7052         pedwarn ("ISO C++ prohibits anonymous structs");
7053     }
7054
7055   else if (ob_modifier)
7056     {
7057       if (ob_modifier == ridpointers[(int) RID_INLINE]
7058           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7059         cp_error ("`%D' can only be specified for functions", ob_modifier);
7060       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7061         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7062       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7063         cp_error ("`%D' can only be specified for constructors",
7064                   ob_modifier);
7065       else
7066         cp_error ("`%D' can only be specified for objects and functions",
7067                   ob_modifier);
7068     }
7069
7070   return t;
7071 }
7072
7073 /* Called when a declaration is seen that contains no names to declare.
7074    If its type is a reference to a structure, union or enum inherited
7075    from a containing scope, shadow that tag name for the current scope
7076    with a forward reference.
7077    If its type defines a new named structure or union
7078    or defines an enum, it is valid but we need not do anything here.
7079    Otherwise, it is an error.
7080
7081    C++: may have to grok the declspecs to learn about static,
7082    complain for anonymous unions.  */
7083
7084 void
7085 shadow_tag (declspecs)
7086      tree declspecs;
7087 {
7088   tree t = check_tag_decl (declspecs);
7089
7090   if (t)
7091     maybe_process_partial_specialization (t);
7092
7093   /* This is where the variables in an anonymous union are
7094      declared.  An anonymous union declaration looks like:
7095      union { ... } ;
7096      because there is no declarator after the union, the parser
7097      sends that declaration here.  */
7098   if (t && ANON_AGGR_TYPE_P (t))
7099     {
7100       fixup_anonymous_aggr (t);
7101
7102       if (TYPE_FIELDS (t))
7103         {
7104           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7105                                       NULL_TREE);
7106           finish_anon_union (decl);
7107         }
7108     }
7109 }
7110 \f
7111 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7112
7113 tree
7114 groktypename (typename)
7115      tree typename;
7116 {
7117   if (TREE_CODE (typename) != TREE_LIST)
7118     return typename;
7119   return grokdeclarator (TREE_VALUE (typename),
7120                          TREE_PURPOSE (typename),
7121                          TYPENAME, 0, NULL_TREE);
7122 }
7123
7124 /* Decode a declarator in an ordinary declaration or data definition.
7125    This is called as soon as the type information and variable name
7126    have been parsed, before parsing the initializer if any.
7127    Here we create the ..._DECL node, fill in its type,
7128    and put it on the list of decls for the current context.
7129    The ..._DECL node is returned as the value.
7130
7131    Exception: for arrays where the length is not specified,
7132    the type is left null, to be filled in by `cp_finish_decl'.
7133
7134    Function definitions do not come here; they go to start_function
7135    instead.  However, external and forward declarations of functions
7136    do go through here.  Structure field declarations are done by
7137    grokfield and not through here.  */
7138
7139 tree
7140 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7141      tree declarator, declspecs;
7142      int initialized;
7143      tree attributes, prefix_attributes;
7144 {
7145   register tree decl;
7146   register tree type, tem;
7147   tree context;
7148   extern int have_extern_spec;
7149   extern int used_extern_spec;
7150   tree attrlist;
7151
7152 #if 0
7153   /* See code below that used this.  */
7154   int init_written = initialized;
7155 #endif
7156
7157   /* This should only be done once on the top most decl.  */
7158   if (have_extern_spec && !used_extern_spec)
7159     {
7160       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7161                                   declspecs);
7162       used_extern_spec = 1;
7163     }
7164
7165   if (attributes || prefix_attributes)
7166     attrlist = build_tree_list (attributes, prefix_attributes);
7167   else
7168     attrlist = NULL_TREE;
7169
7170   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7171                          attrlist);
7172
7173   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7174     return NULL_TREE;
7175
7176   type = TREE_TYPE (decl);
7177
7178   if (type == error_mark_node)
7179     return NULL_TREE;
7180
7181   context = DECL_CONTEXT (decl);
7182
7183   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7184       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7185     {
7186       /* When parsing the initializer, lookup should use the object's
7187          namespace. */
7188       push_decl_namespace (context);
7189     }
7190
7191   /* We are only interested in class contexts, later. */
7192   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7193     context = NULL_TREE;
7194
7195   if (initialized)
7196     /* Is it valid for this decl to have an initializer at all?
7197        If not, set INITIALIZED to zero, which will indirectly
7198        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7199     switch (TREE_CODE (decl))
7200       {
7201       case TYPE_DECL:
7202         /* typedef foo = bar  means give foo the same type as bar.
7203            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7204            Any other case of an initialization in a TYPE_DECL is an error.  */
7205         if (pedantic || list_length (declspecs) > 1)
7206           {
7207             cp_error ("typedef `%D' is initialized", decl);
7208             initialized = 0;
7209           }
7210         break;
7211
7212       case FUNCTION_DECL:
7213         cp_error ("function `%#D' is initialized like a variable", decl);
7214         initialized = 0;
7215         break;
7216
7217       default:
7218         break;
7219       }
7220
7221   if (initialized)
7222     {
7223       if (! toplevel_bindings_p ()
7224           && DECL_EXTERNAL (decl))
7225         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7226                     decl);
7227       DECL_EXTERNAL (decl) = 0;
7228       if (toplevel_bindings_p ())
7229         TREE_STATIC (decl) = 1;
7230
7231       /* Tell `pushdecl' this is an initialized decl
7232          even though we don't yet have the initializer expression.
7233          Also tell `cp_finish_decl' it may store the real initializer.  */
7234       DECL_INITIAL (decl) = error_mark_node;
7235     }
7236
7237 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7238   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7239 #endif
7240
7241   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7242   cplus_decl_attributes (decl, attributes, prefix_attributes);
7243
7244   if (context && COMPLETE_TYPE_P (complete_type (context)))
7245     {
7246       push_nested_class (context, 2);
7247
7248       if (TREE_CODE (decl) == VAR_DECL)
7249         {
7250           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7251           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7252             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7253           else
7254             {
7255               if (DECL_CONTEXT (field) != context)
7256                 {
7257                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7258                               DECL_CONTEXT (field), DECL_NAME (decl),
7259                               context, DECL_NAME (decl));
7260                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7261                 }
7262               /* Static data member are tricky; an in-class initialization
7263                  still doesn't provide a definition, so the in-class
7264                  declaration will have DECL_EXTERNAL set, but will have an
7265                  initialization.  Thus, duplicate_decls won't warn
7266                  about this situation, and so we check here.  */
7267               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7268                 cp_error ("duplicate initialization of %D", decl);
7269               if (duplicate_decls (decl, field))
7270                 decl = field;
7271             }
7272         }
7273       else
7274         {
7275           tree field = check_classfn (context, decl);
7276           if (field && duplicate_decls (decl, field))
7277             decl = field;
7278         }
7279
7280       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7281       DECL_IN_AGGR_P (decl) = 0;
7282       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7283           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7284         {
7285           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7286           /* [temp.expl.spec] An explicit specialization of a static data
7287              member of a template is a definition if the declaration
7288              includes an initializer; otherwise, it is a declaration.
7289
7290              We check for processing_specialization so this only applies
7291              to the new specialization syntax.  */
7292           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7293             DECL_EXTERNAL (decl) = 1;
7294         }
7295
7296       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7297         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7298                     decl);
7299     }
7300
7301   /* Enter this declaration into the symbol table.  */
7302   tem = maybe_push_decl (decl);
7303
7304   if (processing_template_decl)
7305     tem = push_template_decl (tem);
7306
7307 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7308   /* Tell the back-end to use or not use .common as appropriate.  If we say
7309      -fconserve-space, we want this to save .data space, at the expense of
7310      wrong semantics.  If we say -fno-conserve-space, we want this to
7311      produce errors about redefs; to do this we force variables into the
7312      data segment.  */
7313   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7314 #endif
7315
7316   if (! processing_template_decl)
7317     start_decl_1 (tem);
7318
7319   return tem;
7320 }
7321
7322 void
7323 start_decl_1 (decl)
7324      tree decl;
7325 {
7326   tree type = TREE_TYPE (decl);
7327   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7328
7329   if (type == error_mark_node)
7330     return;
7331
7332   /* If this type of object needs a cleanup, but we're not allowed to
7333      add any more objects with cleanups to the current scope, create a
7334      new binding level.  */
7335   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7336       && current_binding_level->more_cleanups_ok == 0)
7337     {
7338       keep_next_level (2);
7339       pushlevel (1);
7340       clear_last_expr ();
7341       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7342     }
7343
7344   if (initialized)
7345     /* Is it valid for this decl to have an initializer at all?
7346        If not, set INITIALIZED to zero, which will indirectly
7347        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7348     {
7349       /* Don't allow initializations for incomplete types except for
7350          arrays which might be completed by the initialization.  */
7351       if (COMPLETE_TYPE_P (complete_type (type)))
7352         ;                       /* A complete type is ok.  */
7353       else if (TREE_CODE (type) != ARRAY_TYPE)
7354         {
7355           cp_error ("variable `%#D' has initializer but incomplete type",
7356                     decl);
7357           initialized = 0;
7358           type = TREE_TYPE (decl) = error_mark_node;
7359         }
7360       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7361         {
7362           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7363             cp_error ("elements of array `%#D' have incomplete type", decl);
7364           /* else we already gave an error in start_decl.  */
7365           initialized = 0;
7366         }
7367     }
7368
7369   if (!initialized
7370       && TREE_CODE (decl) != TYPE_DECL
7371       && TREE_CODE (decl) != TEMPLATE_DECL
7372       && type != error_mark_node
7373       && IS_AGGR_TYPE (type)
7374       && ! DECL_EXTERNAL (decl))
7375     {
7376       if ((! processing_template_decl || ! uses_template_parms (type))
7377           && !COMPLETE_TYPE_P (complete_type (type)))
7378         {
7379           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7380                  decl);
7381           /* Change the type so that assemble_variable will give
7382              DECL an rtl we can live with: (mem (const_int 0)).  */
7383           type = TREE_TYPE (decl) = error_mark_node;
7384         }
7385       else
7386         {
7387           /* If any base type in the hierarchy of TYPE needs a constructor,
7388              then we set initialized to 1.  This way any nodes which are
7389              created for the purposes of initializing this aggregate
7390              will live as long as it does.  This is necessary for global
7391              aggregates which do not have their initializers processed until
7392              the end of the file.  */
7393           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7394         }
7395     }
7396
7397   if (! initialized)
7398     DECL_INITIAL (decl) = NULL_TREE;
7399 }
7400
7401 /* Handle initialization of references.
7402    These three arguments are from `cp_finish_decl', and have the
7403    same meaning here that they do there.
7404
7405    Quotes on semantics can be found in ARM 8.4.3.  */
7406
7407 static void
7408 grok_reference_init (decl, type, init)
7409      tree decl, type, init;
7410 {
7411   tree tmp;
7412
7413   if (init == NULL_TREE)
7414     {
7415       if ((DECL_LANG_SPECIFIC (decl) == 0
7416            || DECL_IN_AGGR_P (decl) == 0)
7417           && ! DECL_THIS_EXTERN (decl))
7418         cp_error ("`%D' declared as reference but not initialized", decl);
7419       return;
7420     }
7421
7422   if (init == error_mark_node)
7423     return;
7424
7425   if (TREE_CODE (init) == CONSTRUCTOR)
7426     {
7427       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7428       return;
7429     }
7430
7431   if (TREE_CODE (init) == TREE_LIST)
7432     init = build_compound_expr (init);
7433
7434   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7435     init = convert_from_reference (init);
7436
7437   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7438       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7439     {
7440       /* Note: default conversion is only called in very special cases.  */
7441       init = default_conversion (init);
7442     }
7443
7444   /* Convert INIT to the reference type TYPE.  This may involve the
7445      creation of a temporary, whose lifetime must be the same as that
7446      of the reference.  If so, a DECL_STMT for the temporary will be
7447      added just after the DECL_STMT for DECL.  That's why we don't set
7448      DECL_INITIAL for local references (instead assigning to them
7449      explicitly); we need to allow the temporary to be initialized
7450      first.  */
7451   tmp = convert_to_reference
7452     (type, init, CONV_IMPLICIT,
7453      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7454      decl);
7455
7456   if (tmp == error_mark_node)
7457     return;
7458   else if (tmp != NULL_TREE)
7459     {
7460       init = tmp;
7461       tmp = save_expr (tmp);
7462       if (building_stmt_tree ())
7463         {
7464           /* Initialize the declaration.  */
7465           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7466           finish_expr_stmt (tmp);
7467         }
7468       else
7469         DECL_INITIAL (decl) = tmp;
7470     }
7471   else
7472     {
7473       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7474       return;
7475     }
7476
7477   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7478     {
7479       expand_static_init (decl, DECL_INITIAL (decl));
7480       DECL_INITIAL (decl) = NULL_TREE;
7481     }
7482   return;
7483 }
7484
7485 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7486    mucking with forces it does not comprehend (i.e. initialization with a
7487    constructor).  If we are at global scope and won't go into COMMON, fill
7488    it in with a dummy CONSTRUCTOR to force the variable into .data;
7489    otherwise we can use error_mark_node.  */
7490
7491 static tree
7492 obscure_complex_init (decl, init)
7493      tree decl, init;
7494 {
7495   if (! flag_no_inline && TREE_STATIC (decl))
7496     {
7497       if (extract_init (decl, init))
7498         return NULL_TREE;
7499     }
7500
7501 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7502   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7503     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7504                                  NULL_TREE);
7505   else
7506 #endif
7507     DECL_INITIAL (decl) = error_mark_node;
7508
7509   return init;
7510 }
7511
7512 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7513    array until we finish parsing the initializer.  If that's the
7514    situation we're in, update DECL accordingly.  */
7515
7516 static void
7517 maybe_deduce_size_from_array_init (decl, init)
7518      tree decl;
7519      tree init;
7520 {
7521   tree type = TREE_TYPE (decl);
7522
7523   if (TREE_CODE (type) == ARRAY_TYPE
7524       && TYPE_DOMAIN (type) == NULL_TREE
7525       && TREE_CODE (decl) != TYPE_DECL)
7526     {
7527       int do_default
7528         = (TREE_STATIC (decl)
7529            /* Even if pedantic, an external linkage array
7530               may have incomplete type at first.  */
7531            ? pedantic && ! DECL_EXTERNAL (decl)
7532            : !DECL_EXTERNAL (decl));
7533       tree initializer = init ? init : DECL_INITIAL (decl);
7534       int failure = complete_array_type (type, initializer, do_default);
7535
7536       if (failure == 1)
7537         cp_error ("initializer fails to determine size of `%D'", decl);
7538
7539       if (failure == 2)
7540         {
7541           if (do_default)
7542             cp_error ("array size missing in `%D'", decl);
7543           /* If a `static' var's size isn't known, make it extern as
7544              well as static, so it does not get allocated.  If it's not
7545              `static', then don't mark it extern; finish_incomplete_decl
7546              will give it a default size and it will get allocated.  */
7547           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7548             DECL_EXTERNAL (decl) = 1;
7549         }
7550
7551       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7552           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7553                               integer_zero_node))
7554         cp_error ("zero-size array `%D'", decl);
7555
7556       layout_decl (decl, 0);
7557     }
7558 }
7559
7560 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7561    any appropriate error messages regarding the layout.  */
7562
7563 static void
7564 layout_var_decl (decl)
7565      tree decl;
7566 {
7567   tree type = TREE_TYPE (decl);
7568 #if 0
7569   tree ttype = target_type (type);
7570 #endif
7571
7572   /* If we haven't already layed out this declaration, do so now.
7573      Note that we must not call complete type for an external object
7574      because it's type might involve templates that we are not
7575      supposed to isntantiate yet.  (And it's perfectly legal to say
7576      `extern X x' for some incomplete type `X'.)  */
7577   if (!DECL_EXTERNAL (decl))
7578     complete_type (type);
7579   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7580     layout_decl (decl, 0);
7581
7582   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7583     {
7584       /* An automatic variable with an incomplete type: that is an error.
7585          Don't talk about array types here, since we took care of that
7586          message in grokdeclarator.  */
7587       cp_error ("storage size of `%D' isn't known", decl);
7588       TREE_TYPE (decl) = error_mark_node;
7589     }
7590 #if 0
7591   /* Keep this code around in case we later want to control debug info
7592      based on whether a type is "used".  (jason 1999-11-11) */
7593
7594   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7595     /* Let debugger know it should output info for this type.  */
7596     note_debug_info_needed (ttype);
7597
7598   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7599     note_debug_info_needed (DECL_CONTEXT (decl));
7600 #endif
7601
7602   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7603       && DECL_SIZE (decl) != NULL_TREE
7604       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7605     {
7606       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7607         constant_expression_warning (DECL_SIZE (decl));
7608       else
7609         cp_error ("storage size of `%D' isn't constant", decl);
7610     }
7611 }
7612
7613 /* If a local static variable is declared in an inline function, or if
7614    we have a weak definition, we must endeavor to create only one
7615    instance of the variable at link-time.  */
7616
7617 static void
7618 maybe_commonize_var (decl)
7619      tree decl;
7620 {
7621   /* Static data in a function with comdat linkage also has comdat
7622      linkage.  */
7623   if (TREE_STATIC (decl)
7624       /* Don't mess with __FUNCTION__.  */
7625       && ! DECL_ARTIFICIAL (decl)
7626       && current_function_decl
7627       && DECL_CONTEXT (decl) == current_function_decl
7628       && (DECL_THIS_INLINE (current_function_decl)
7629           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7630       && TREE_PUBLIC (current_function_decl))
7631     {
7632       /* Rather than try to get this right with inlining, we suppress
7633          inlining of such functions.  */
7634       current_function_cannot_inline
7635         = "function with static variable cannot be inline";
7636
7637       /* If flag_weak, we don't need to mess with this, as we can just
7638          make the function weak, and let it refer to its unique local
7639          copy.  This works because we don't allow the function to be
7640          inlined.  */
7641       if (! flag_weak)
7642         {
7643           if (DECL_INTERFACE_KNOWN (current_function_decl))
7644             {
7645               TREE_PUBLIC (decl) = 1;
7646               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7647             }
7648           else if (DECL_INITIAL (decl) == NULL_TREE
7649                    || DECL_INITIAL (decl) == error_mark_node)
7650             {
7651               TREE_PUBLIC (decl) = 1;
7652               DECL_COMMON (decl) = 1;
7653             }
7654           /* else we lose. We can only do this if we can use common,
7655              which we can't if it has been initialized.  */
7656
7657           if (TREE_PUBLIC (decl))
7658             DECL_ASSEMBLER_NAME (decl)
7659               = build_static_name (current_function_decl, DECL_NAME (decl));
7660           else
7661             {
7662               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7663               cp_warning_at ("  you can work around this by removing the initializer", decl);
7664             }
7665         }
7666     }
7667   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7668     /* Set it up again; we might have set DECL_INITIAL since the last
7669        time.  */
7670     comdat_linkage (decl);
7671 }
7672
7673 /* Issue an error message if DECL is an uninitialized const variable.  */
7674
7675 static void
7676 check_for_uninitialized_const_var (decl)
7677      tree decl;
7678 {
7679   tree type = TREE_TYPE (decl);
7680
7681   /* ``Unless explicitly declared extern, a const object does not have
7682      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7683      7.1.6 */
7684   if (TREE_CODE (decl) == VAR_DECL
7685       && TREE_CODE (type) != REFERENCE_TYPE
7686       && CP_TYPE_CONST_P (type)
7687       && !TYPE_NEEDS_CONSTRUCTING (type)
7688       && !DECL_INITIAL (decl))
7689     cp_error ("uninitialized const `%D'", decl);
7690 }
7691
7692 /* Verify INIT (the initializer for DECL), and record the
7693    initialization in DECL_INITIAL, if appropriate.  Returns a new
7694    value for INIT.  */
7695
7696 static tree
7697 check_initializer (decl, init)
7698      tree decl;
7699      tree init;
7700 {
7701   tree type;
7702
7703   if (TREE_CODE (decl) == FIELD_DECL)
7704     return init;
7705
7706   type = TREE_TYPE (decl);
7707
7708   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7709   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7710     init = NULL_TREE;
7711
7712   /* Check the initializer.  */
7713   if (init)
7714     {
7715       /* Things that are going to be initialized need to have complete
7716          type.  */
7717       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7718
7719       if (type == error_mark_node)
7720         /* We will have already complained.  */
7721         init = NULL_TREE;
7722       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7723         {
7724           cp_error ("variable-sized object `%D' may not be initialized", decl);
7725           init = NULL_TREE;
7726         }
7727       else if (TREE_CODE (type) == ARRAY_TYPE
7728                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7729         {
7730           cp_error ("elements of array `%#D' have incomplete type", decl);
7731           init = NULL_TREE;
7732         }
7733       else if (!COMPLETE_TYPE_P (type))
7734         {
7735           cp_error ("`%D' has incomplete type", decl);
7736           TREE_TYPE (decl) = error_mark_node;
7737           init = NULL_TREE;
7738         }
7739     }
7740
7741   if (TREE_CODE (decl) == CONST_DECL)
7742     {
7743       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7744
7745       DECL_INITIAL (decl) = init;
7746
7747       /* This will keep us from needing to worry about our obstacks.  */
7748       my_friendly_assert (init != NULL_TREE, 149);
7749       init = NULL_TREE;
7750     }
7751   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7752     {
7753       if (TREE_STATIC (decl))
7754         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7755       grok_reference_init (decl, type, init);
7756       init = NULL_TREE;
7757     }
7758   else if (init)
7759     {
7760       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7761         {
7762           if (TREE_CODE (type) == ARRAY_TYPE)
7763             init = digest_init (type, init, (tree *) 0);
7764           else if (TREE_CODE (init) == CONSTRUCTOR
7765                    && TREE_HAS_CONSTRUCTOR (init))
7766             {
7767               if (TYPE_NON_AGGREGATE_CLASS (type))
7768                 {
7769                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7770                             decl);
7771                   init = error_mark_node;
7772                 }
7773               else
7774                 goto dont_use_constructor;
7775             }
7776         }
7777       else
7778         {
7779         dont_use_constructor:
7780           if (TREE_CODE (init) != TREE_VEC)
7781             init = store_init_value (decl, init);
7782         }
7783
7784       if (init)
7785         /* We must hide the initializer so that expand_decl
7786            won't try to do something it does not understand.  */
7787         init = obscure_complex_init (decl, init);
7788     }
7789   else if (DECL_EXTERNAL (decl))
7790     ;
7791   else if (TYPE_P (type)
7792            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7793     {
7794       tree core_type = strip_array_types (type);
7795
7796       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7797         {
7798           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7799             cp_error ("structure `%D' with uninitialized const members", decl);
7800           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7801             cp_error ("structure `%D' with uninitialized reference members",
7802                       decl);
7803         }
7804
7805       check_for_uninitialized_const_var (decl);
7806
7807       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7808         init = obscure_complex_init (decl, NULL_TREE);
7809
7810     }
7811   else
7812     check_for_uninitialized_const_var (decl);
7813
7814   return init;
7815 }
7816
7817 /* If DECL is not a local variable, give it RTL.  */
7818
7819 static void
7820 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7821      tree decl;
7822      tree init;
7823      const char *asmspec;
7824 {
7825   int toplev = toplevel_bindings_p ();
7826   int defer_p;
7827
7828   /* Handle non-variables up front.  */
7829   if (TREE_CODE (decl) != VAR_DECL)
7830     {
7831       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7832       return;
7833     }
7834
7835   /* If we see a class member here, it should be a static data
7836      member.  */
7837   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7838     {
7839       my_friendly_assert (TREE_STATIC (decl), 19990828);
7840       /* An in-class declaration of a static data member should be
7841          external; it is only a declaration, and not a definition.  */
7842       if (init == NULL_TREE)
7843         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7844     }
7845
7846   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7847   if (asmspec)
7848     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7849
7850   /* We don't create any RTL for local variables.  */
7851   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7852     return;
7853
7854   /* We defer emission of local statics until the corresponding
7855      DECL_STMT is expanded.  */
7856   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7857
7858   /* We try to defer namespace-scope static constants so that they are
7859      not emitted into the object file unncessarily.  */
7860   if (!DECL_VIRTUAL_P (decl)
7861       && TREE_READONLY (decl)
7862       && DECL_INITIAL (decl) != NULL_TREE
7863       && DECL_INITIAL (decl) != error_mark_node
7864       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7865       && toplev
7866       && !TREE_PUBLIC (decl))
7867     {
7868       /* Fool with the linkage according to #pragma interface.  */
7869       if (!interface_unknown)
7870         {
7871           TREE_PUBLIC (decl) = 1;
7872           DECL_EXTERNAL (decl) = interface_only;
7873         }
7874
7875       defer_p = 1;
7876     }
7877
7878   /* If we're deferring the variable, just make RTL.  Do not actually
7879      emit the variable.  */
7880   if (defer_p)
7881     make_decl_rtl (decl, asmspec, toplev);
7882   /* If we're not deferring, go ahead and assemble the variable.  */
7883   else
7884     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7885 }
7886
7887 /* The old ARM scoping rules injected variables declared in the
7888    initialization statement of a for-statement into the surrounding
7889    scope.  We support this usage, in order to be backward-compatible.
7890    DECL is a just-declared VAR_DECL; if necessary inject its
7891    declaration into the surrounding scope.  */
7892
7893 void
7894 maybe_inject_for_scope_var (decl)
7895      tree decl;
7896 {
7897   if (!DECL_NAME (decl))
7898     return;
7899
7900   if (current_binding_level->is_for_scope)
7901     {
7902       struct binding_level *outer
7903         = current_binding_level->level_chain;
7904
7905       /* Check to see if the same name is already bound at the outer
7906          level, either because it was directly declared, or because a
7907          dead for-decl got preserved.  In either case, the code would
7908          not have been valid under the ARM scope rules, so clear
7909          is_for_scope for the current_binding_level.
7910
7911          Otherwise, we need to preserve the temp slot for decl to last
7912          into the outer binding level.  */
7913
7914       tree outer_binding
7915         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7916
7917       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7918           && (TREE_CODE (BINDING_VALUE (outer_binding))
7919               == VAR_DECL)
7920           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7921         {
7922           BINDING_VALUE (outer_binding)
7923             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7924           current_binding_level->is_for_scope = 0;
7925         }
7926       else if (DECL_IN_MEMORY_P (decl))
7927         preserve_temp_slots (DECL_RTL (decl));
7928     }
7929 }
7930
7931 /* Generate code to initialize DECL (a local variable).  */
7932
7933 void
7934 initialize_local_var (decl, init, flags)
7935      tree decl;
7936      tree init;
7937      int flags;
7938 {
7939   tree type = TREE_TYPE (decl);
7940
7941   /* If the type is bogus, don't bother initializing the variable.  */
7942   if (type == error_mark_node)
7943     return;
7944
7945   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7946     {
7947       /* If we used it already as memory, it must stay in memory.  */
7948       DECL_INITIAL (decl) = NULL_TREE;
7949       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7950     }
7951
7952   /* Local statics are handled differently from ordinary automatic
7953      variables.  */
7954   if (TREE_STATIC (decl))
7955     {
7956       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7957           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7958         expand_static_init (decl, init);
7959       return;
7960     }
7961
7962   if (DECL_SIZE (decl) && type != error_mark_node)
7963     {
7964       int already_used;
7965
7966       /* Compute and store the initial value.  */
7967       already_used = TREE_USED (decl) || TREE_USED (type);
7968
7969       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7970         {
7971           int saved_stmts_are_full_exprs_p;
7972
7973           emit_line_note (DECL_SOURCE_FILE (decl),
7974                           DECL_SOURCE_LINE (decl));
7975           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7976           current_stmt_tree->stmts_are_full_exprs_p = 1;
7977           if (building_stmt_tree ())
7978             finish_expr_stmt (build_aggr_init (decl, init, flags));
7979           else
7980             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7981           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7982         }
7983
7984       /* Set this to 0 so we can tell whether an aggregate which was
7985          initialized was ever used.  Don't do this if it has a
7986          destructor, so we don't complain about the 'resource
7987          allocation is initialization' idiom.  Now set
7988          attribute((unused)) on types so decls of that type will be
7989          marked used. (see TREE_USED, above.)  */
7990       if (TYPE_NEEDS_CONSTRUCTING (type)
7991           && ! already_used
7992           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7993           && DECL_NAME (decl))
7994         TREE_USED (decl) = 0;
7995       else if (already_used)
7996         TREE_USED (decl) = 1;
7997     }
7998 }
7999
8000 /* Generate code to destroy DECL (a local variable).  */
8001
8002 static void
8003 destroy_local_var (decl)
8004      tree decl;
8005 {
8006   tree type = TREE_TYPE (decl);
8007   tree cleanup;
8008
8009   /* Only variables get cleaned up.  */
8010   if (TREE_CODE (decl) != VAR_DECL)
8011     return;
8012
8013   /* And only things with destructors need cleaning up.  */
8014   if (type == error_mark_node
8015       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8016     return;
8017
8018   if (TREE_CODE (decl) == VAR_DECL &&
8019       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8020     /* We don't clean up things that aren't defined in this
8021        translation unit, or that need a static cleanup.  The latter
8022        are handled by finish_file.  */
8023     return;
8024
8025   /* Compute the cleanup.  */
8026   cleanup = maybe_build_cleanup (decl);
8027
8028   /* Record the cleanup required for this declaration.  */
8029   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8030       && cleanup)
8031     finish_decl_cleanup (decl, cleanup);
8032 }
8033
8034 /* Finish processing of a declaration;
8035    install its line number and initial value.
8036    If the length of an array type is not known before,
8037    it must be determined now, from the initial value, or it is an error.
8038
8039    INIT holds the value of an initializer that should be allowed to escape
8040    the normal rules.
8041
8042    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8043    if the (init) syntax was used.  */
8044
8045 void
8046 cp_finish_decl (decl, init, asmspec_tree, flags)
8047      tree decl, init;
8048      tree asmspec_tree;
8049      int flags;
8050 {
8051   register tree type;
8052   tree ttype = NULL_TREE;
8053   const char *asmspec = NULL;
8054   int was_readonly = 0;
8055
8056   if (! decl)
8057     {
8058       if (init)
8059         error ("assignment (not initialization) in declaration");
8060       return;
8061     }
8062
8063   /* If a name was specified, get the string.  */
8064   if (asmspec_tree)
8065       asmspec = TREE_STRING_POINTER (asmspec_tree);
8066
8067   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8068     {
8069       cp_error ("cannot initialize `%D' to namespace `%D'",
8070                 decl, init);
8071       init = NULL_TREE;
8072     }
8073
8074   if (current_class_type
8075       && CP_DECL_CONTEXT (decl) == current_class_type
8076       && TYPE_BEING_DEFINED (current_class_type)
8077       && (DECL_INITIAL (decl) || init))
8078     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8079
8080   if (TREE_CODE (decl) == VAR_DECL
8081       && DECL_CONTEXT (decl)
8082       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8083       && DECL_CONTEXT (decl) != current_namespace
8084       && init)
8085     {
8086       /* Leave the namespace of the object. */
8087       pop_decl_namespace ();
8088     }
8089
8090   type = TREE_TYPE (decl);
8091
8092   if (type == error_mark_node)
8093     return;
8094
8095   /* Add this declaration to the statement-tree.  */
8096   if (building_stmt_tree () && at_function_scope_p ())
8097     add_decl_stmt (decl);
8098
8099   if (TYPE_HAS_MUTABLE_P (type))
8100     TREE_READONLY (decl) = 0;
8101
8102   if (processing_template_decl)
8103     {
8104       if (init && DECL_INITIAL (decl))
8105         DECL_INITIAL (decl) = init;
8106       goto finish_end0;
8107     }
8108
8109   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8110   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8111
8112   /* Take care of TYPE_DECLs up front.  */
8113   if (TREE_CODE (decl) == TYPE_DECL)
8114     {
8115       if (init && DECL_INITIAL (decl))
8116         {
8117           /* typedef foo = bar; store the type of bar as the type of foo.  */
8118           TREE_TYPE (decl) = type = TREE_TYPE (init);
8119           DECL_INITIAL (decl) = init = NULL_TREE;
8120         }
8121       if (type != error_mark_node
8122           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8123         {
8124           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8125             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8126           set_identifier_type_value (DECL_NAME (decl), type);
8127           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8128         }
8129       GNU_xref_decl (current_function_decl, decl);
8130
8131       /* If we have installed this as the canonical typedef for this
8132          type, and that type has not been defined yet, delay emitting
8133          the debug information for it, as we will emit it later.  */
8134       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8135           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8136         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8137
8138       rest_of_decl_compilation (decl, NULL_PTR,
8139                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8140       goto finish_end;
8141     }
8142
8143   if (TREE_CODE (decl) != FUNCTION_DECL)
8144     ttype = target_type (type);
8145
8146   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8147       && TYPE_NEEDS_CONSTRUCTING (type))
8148     {
8149       /* Currently, GNU C++ puts constants in text space, making them
8150          impossible to initialize.  In the future, one would hope for
8151          an operating system which understood the difference between
8152          initialization and the running of a program.  */
8153       was_readonly = 1;
8154       TREE_READONLY (decl) = 0;
8155     }
8156
8157   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8158     {
8159       /* This must override the asm specifier which was placed by
8160          grokclassfn.  Lay this out fresh.  */
8161       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8162       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8163       make_decl_rtl (decl, asmspec, 0);
8164     }
8165
8166   /* Deduce size of array from initialization, if not already known.  */
8167   maybe_deduce_size_from_array_init (decl, init);
8168   init = check_initializer (decl, init);
8169
8170   GNU_xref_decl (current_function_decl, decl);
8171
8172   if (TREE_CODE (decl) == VAR_DECL)
8173     layout_var_decl (decl);
8174
8175   /* Output the assembler code and/or RTL code for variables and functions,
8176      unless the type is an undefined structure or union.
8177      If not, it will get done when the type is completed.  */
8178   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8179       || TREE_CODE (decl) == RESULT_DECL)
8180     {
8181       if (TREE_CODE (decl) == VAR_DECL)
8182         maybe_commonize_var (decl);
8183
8184       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8185
8186       if (TREE_CODE (type) == FUNCTION_TYPE
8187           || TREE_CODE (type) == METHOD_TYPE)
8188         abstract_virtuals_error (decl,
8189                                  strip_array_types (TREE_TYPE (type)));
8190       else
8191         abstract_virtuals_error (decl, strip_array_types (type));
8192
8193       if (TREE_CODE (decl) == FUNCTION_DECL)
8194         ;
8195       else if (DECL_EXTERNAL (decl)
8196                && ! (DECL_LANG_SPECIFIC (decl)
8197                      && DECL_NOT_REALLY_EXTERN (decl)))
8198         {
8199           if (init)
8200             DECL_INITIAL (decl) = init;
8201         }
8202       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8203         {
8204           /* This is a local declaration.  */
8205           if (doing_semantic_analysis_p ())
8206             maybe_inject_for_scope_var (decl);
8207           /* Initialize the local variable.  But, if we're building a
8208              statement-tree, we'll do the initialization when we
8209              expand the tree.  */
8210           if (processing_template_decl)
8211             {
8212               if (init || DECL_INITIAL (decl) == error_mark_node)
8213                 DECL_INITIAL (decl) = init;
8214             }
8215           else
8216             {
8217               /* If we're not building RTL, then we need to do so
8218                  now.  */
8219               if (!building_stmt_tree ())
8220                 emit_local_var (decl);
8221               /* Initialize the variable.  */
8222               initialize_local_var (decl, init, flags);
8223               /* Clean up the variable.  */
8224               destroy_local_var (decl);
8225             }
8226         }
8227       else if (TREE_STATIC (decl) && type != error_mark_node)
8228         {
8229           /* Cleanups for static variables are handled by `finish_file'.  */
8230           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8231               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8232             expand_static_init (decl, init);
8233         }
8234     finish_end0:
8235
8236       /* Undo call to `pushclass' that was done in `start_decl'
8237          due to initialization of qualified member variable.
8238          I.e., Foo::x = 10;  */
8239       {
8240         tree context = CP_DECL_CONTEXT (decl);
8241         if (context
8242             && TYPE_P (context)
8243             && (TREE_CODE (decl) == VAR_DECL
8244                 /* We also have a pushclass done that we need to undo here
8245                    if we're at top level and declare a method.  */
8246                 || TREE_CODE (decl) == FUNCTION_DECL)
8247             /* If size hasn't been set, we're still defining it,
8248                and therefore inside the class body; don't pop
8249                the binding level..  */
8250             && COMPLETE_TYPE_P (context)
8251             && context == current_class_type)
8252           pop_nested_class ();
8253       }
8254     }
8255
8256  finish_end:
8257
8258   if (was_readonly)
8259     TREE_READONLY (decl) = 1;
8260 }
8261
8262 /* This is here for a midend callback from c-common.c */
8263
8264 void
8265 finish_decl (decl, init, asmspec_tree)
8266      tree decl, init;
8267      tree asmspec_tree;
8268 {
8269   cp_finish_decl (decl, init, asmspec_tree, 0);
8270 }
8271
8272 /* Returns a declaration for a VAR_DECL as if:
8273
8274      extern "C" TYPE NAME;
8275
8276    had been seen.  Used to create compiler-generated global
8277    variables.  */
8278
8279 tree
8280 declare_global_var (name, type)
8281      tree name;
8282      tree type;
8283 {
8284   tree decl;
8285
8286   push_to_top_level ();
8287   decl = build_decl (VAR_DECL, name, type);
8288   TREE_PUBLIC (decl) = 1;
8289   DECL_EXTERNAL (decl) = 1;
8290   DECL_ARTIFICIAL (decl) = 1;
8291   pushdecl (decl);
8292   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8293   pop_from_top_level ();
8294
8295   return decl;
8296 }
8297
8298 /* Returns a pointer to the `atexit' function.  Note that if
8299    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8300    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8301
8302 static tree
8303 get_atexit_node ()
8304 {
8305   tree atexit_fndecl;
8306   tree arg_types;
8307   tree fn_type;
8308   tree fn_ptr_type;
8309   const char *name;
8310
8311   if (atexit_node)
8312     return atexit_node;
8313
8314   if (flag_use_cxa_atexit)
8315     {
8316       /* The declaration for `__cxa_atexit' is:
8317
8318            int __cxa_atexit (void (*)(void *), void *, void *)
8319
8320          We build up the argument types and then then function type
8321          itself.  */
8322
8323       /* First, build the pointer-to-function type for the first
8324          argument.  */
8325       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8326       fn_type = build_function_type (void_type_node, arg_types);
8327       fn_ptr_type = build_pointer_type (fn_type);
8328       /* Then, build the rest of the argument types.  */
8329       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8330       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8331       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8332       /* And the final __cxa_atexit type.  */
8333       fn_type = build_function_type (integer_type_node, arg_types);
8334       fn_ptr_type = build_pointer_type (fn_type);
8335       name = "__cxa_atexit";
8336     }
8337   else
8338     {
8339       /* The declaration for `atexit' is:
8340
8341            int atexit (void (*)());
8342
8343          We build up the argument types and then then function type
8344          itself.  */
8345       fn_type = build_function_type (void_type_node, void_list_node);
8346       fn_ptr_type = build_pointer_type (fn_type);
8347       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8348       /* Build the final atexit type.  */
8349       fn_type = build_function_type (integer_type_node, arg_types);
8350       name = "atexit";
8351     }
8352
8353   /* Now, build the function declaration.  */
8354   push_lang_context (lang_name_c);
8355   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8356   mark_used (atexit_fndecl);
8357   pop_lang_context ();
8358   atexit_node = default_conversion (atexit_fndecl);
8359
8360   return atexit_node;
8361 }
8362
8363 /* Returns the __dso_handle VAR_DECL.  */
8364
8365 static tree
8366 get_dso_handle_node ()
8367 {
8368   if (dso_handle_node)
8369     return dso_handle_node;
8370
8371   /* Declare the variable.  */
8372   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8373                                         ptr_type_node);
8374
8375   return dso_handle_node;
8376 }
8377
8378 /* Begin a new function with internal linkage whose job will be simply
8379    to destroy some particular variable.  */
8380
8381 static tree
8382 start_cleanup_fn ()
8383 {
8384   static int counter = 0;
8385   int old_interface_unknown = interface_unknown;
8386   char name[32];
8387   tree parmtypes;
8388   tree fntype;
8389   tree fndecl;
8390
8391   push_to_top_level ();
8392
8393   /* No need to mangle this.  */
8394   push_lang_context (lang_name_c);
8395
8396   interface_unknown = 1;
8397
8398   /* Build the parameter-types.  */
8399   parmtypes = void_list_node;
8400   /* Functions passed to __cxa_atexit take an additional parameter.
8401      We'll just ignore it.  After we implement the new calling
8402      convention for destructors, we can eliminate the use of
8403      additional cleanup functions entirely in the -fnew-abi case.  */
8404   if (flag_use_cxa_atexit)
8405     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8406   /* Build the function type itself.  */
8407   fntype = build_function_type (void_type_node, parmtypes);
8408   /* Build the name of the function.  */
8409   sprintf (name, "__tcf_%d", counter++);
8410   /* Build the function declaration.  */
8411   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8412   /* It's a function with internal linkage, generated by the
8413      compiler.  */
8414   TREE_PUBLIC (fndecl) = 0;
8415   DECL_ARTIFICIAL (fndecl) = 1;
8416   /* Make the function `inline' so that it is only emitted if it is
8417      actually needed.  It is unlikely that it will be inlined, since
8418      it is only called via a function pointer, but we avoid unncessary
8419      emissions this way.  */
8420   DECL_INLINE (fndecl) = 1;
8421   /* Build the parameter.  */
8422   if (flag_use_cxa_atexit)
8423     {
8424       tree parmdecl;
8425
8426       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8427       DECL_CONTEXT (parmdecl) = fndecl;
8428       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8429       TREE_USED (parmdecl) = 1;
8430       DECL_ARGUMENTS (fndecl) = parmdecl;
8431     }
8432
8433   pushdecl (fndecl);
8434   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8435   do_pushlevel ();
8436
8437   interface_unknown = old_interface_unknown;
8438
8439   pop_lang_context ();
8440
8441   return current_function_decl;
8442 }
8443
8444 /* Finish the cleanup function begun by start_cleanup_fn.  */
8445
8446 static void
8447 end_cleanup_fn ()
8448 {
8449   do_poplevel ();
8450
8451   expand_body (finish_function (0));
8452
8453   pop_from_top_level ();
8454 }
8455
8456 /* Generate code to handle the destruction of DECL, an object with
8457    static storage duration.  */
8458
8459 void
8460 register_dtor_fn (decl)
8461      tree decl;
8462 {
8463   tree cleanup;
8464   tree compound_stmt;
8465   tree args;
8466   tree fcall;
8467
8468   int saved_flag_access_control;
8469
8470   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8471     return;
8472
8473   /* Call build_cleanup before we enter the anonymous function so that
8474      any access checks will be done relative to the current scope,
8475      rather than the scope of the anonymous function.  */
8476   build_cleanup (decl);
8477
8478   /* Now start the function.  */
8479   cleanup = start_cleanup_fn ();
8480
8481   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8482      to the original function, rather than the anonymous one.  That
8483      will make the back-end think that nested functions are in use,
8484      which causes confusion.  */
8485   saved_flag_access_control = flag_access_control;
8486   flag_access_control = 0;
8487   fcall = build_cleanup (decl);
8488   flag_access_control = saved_flag_access_control;
8489
8490   /* Create the body of the anonymous function.  */
8491   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8492   finish_expr_stmt (fcall);
8493   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8494   end_cleanup_fn ();
8495
8496   /* Call atexit with the cleanup function.  */
8497   mark_addressable (cleanup);
8498   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8499   if (flag_use_cxa_atexit)
8500     {
8501       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8502       args = tree_cons (NULL_TREE, null_pointer_node, args);
8503       args = tree_cons (NULL_TREE, cleanup, args);
8504     }
8505   else
8506     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8507   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8508 }
8509
8510 void
8511 expand_static_init (decl, init)
8512      tree decl;
8513      tree init;
8514 {
8515   tree oldstatic = value_member (decl, static_aggregates);
8516
8517   if (oldstatic)
8518     {
8519       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8520         cp_error ("multiple initializations given for `%D'", decl);
8521     }
8522   else if (! toplevel_bindings_p ())
8523     {
8524       /* Emit code to perform this initialization but once.  */
8525       tree if_stmt;
8526       tree then_clause;
8527       tree assignment;
8528       tree guard;
8529       tree guard_init;
8530
8531       /* Emit code to perform this initialization but once.  This code
8532          looks like:
8533
8534            static int guard = 0;
8535            if (!guard) {
8536              // Do initialization.
8537              guard = 1;
8538              // Register variable for destruction at end of program.
8539            }
8540
8541          Note that the `temp' variable is only set to 1 *after* the
8542          initialization is complete.  This ensures that an exception,
8543          thrown during the construction, will cause the variable to
8544          reinitialized when we pass through this code again, as per:
8545
8546            [stmt.dcl]
8547
8548            If the initialization exits by throwing an exception, the
8549            initialization is not complete, so it will be tried again
8550            the next time control enters the declaration.
8551
8552          In theory, this process should be thread-safe, too; multiple
8553          threads should not be able to initialize the variable more
8554          than once.  We don't yet attempt to ensure thread-safety.  */
8555
8556       /* Create the guard variable.  */
8557       guard = get_guard (decl);
8558
8559       /* Begin the conditional initialization.  */
8560       if_stmt = begin_if_stmt ();
8561       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8562       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8563
8564       /* Do the initialization itself.  */
8565       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8566           || (init && TREE_CODE (init) == TREE_LIST))
8567         assignment = build_aggr_init (decl, init, 0);
8568       else if (init)
8569         /* The initialization we're doing here is just a bitwise
8570            copy.  */
8571         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8572       else
8573         assignment = NULL_TREE;
8574
8575       /* Once the assignment is complete, set TEMP to 1.  Since the
8576          construction of the static object is complete at this point,
8577          we want to make sure TEMP is set to 1 even if a temporary
8578          constructed during the initialization throws an exception
8579          when it is destroyed.  So, we combine the initialization and
8580          the assignment to TEMP into a single expression, ensuring
8581          that when we call finish_expr_stmt the cleanups will not be
8582          run until after TEMP is set to 1.  */
8583       guard_init = set_guard (guard);
8584       if (assignment)
8585         {
8586           assignment = tree_cons (NULL_TREE, assignment,
8587                                   build_tree_list (NULL_TREE,
8588                                                    guard_init));
8589           assignment = build_compound_expr (assignment);
8590         }
8591       else
8592         assignment = guard_init;
8593       finish_expr_stmt (assignment);
8594
8595       /* Use atexit to register a function for destroying this static
8596          variable.  */
8597       register_dtor_fn (decl);
8598
8599       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8600       finish_then_clause (if_stmt);
8601       finish_if_stmt ();
8602     }
8603   else
8604     static_aggregates = tree_cons (init, decl, static_aggregates);
8605 }
8606
8607 /* Finish the declaration of a catch-parameter.  */
8608
8609 tree
8610 start_handler_parms (declspecs, declarator)
8611      tree declspecs;
8612      tree declarator;
8613 {
8614   tree decl;
8615   if (declspecs)
8616     {
8617       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8618                              1, NULL_TREE);
8619       if (decl == NULL_TREE)
8620         error ("invalid catch parameter");
8621     }
8622   else
8623     decl = NULL_TREE;
8624
8625   return decl;
8626 }
8627
8628 \f
8629 /* Make TYPE a complete type based on INITIAL_VALUE.
8630    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8631    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8632
8633 int
8634 complete_array_type (type, initial_value, do_default)
8635      tree type, initial_value;
8636      int do_default;
8637 {
8638   register tree maxindex = NULL_TREE;
8639   int value = 0;
8640
8641   if (initial_value)
8642     {
8643       /* An array of character type can be initialized from a
8644          brace-enclosed string constant.  */
8645       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8646           && TREE_CODE (initial_value) == CONSTRUCTOR
8647           && CONSTRUCTOR_ELTS (initial_value)
8648           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8649               == STRING_CST)
8650           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8651         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8652
8653       /* Note MAXINDEX is really the maximum index, one less than the
8654          size.  */
8655       if (TREE_CODE (initial_value) == STRING_CST)
8656         {
8657           int eltsize
8658             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8659           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8660                                    / eltsize) - 1, 0);
8661         }
8662       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8663         {
8664           tree elts = CONSTRUCTOR_ELTS (initial_value);
8665
8666           maxindex = ssize_int (-1);
8667           for (; elts; elts = TREE_CHAIN (elts))
8668             {
8669               if (TREE_PURPOSE (elts))
8670                 maxindex = TREE_PURPOSE (elts);
8671               else
8672                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8673             }
8674           maxindex = copy_node (maxindex);
8675         }
8676       else
8677         {
8678           /* Make an error message unless that happened already.  */
8679           if (initial_value != error_mark_node)
8680             value = 1;
8681           else
8682             initial_value = NULL_TREE;
8683
8684           /* Prevent further error messages.  */
8685           maxindex = build_int_2 (0, 0);
8686         }
8687     }
8688
8689   if (!maxindex)
8690     {
8691       if (do_default)
8692         maxindex = build_int_2 (0, 0);
8693       value = 2;
8694     }
8695
8696   if (maxindex)
8697     {
8698       tree itype;
8699       tree domain;
8700
8701       domain = build_index_type (maxindex);
8702       TYPE_DOMAIN (type) = domain;
8703
8704       if (! TREE_TYPE (maxindex))
8705         TREE_TYPE (maxindex) = domain;
8706       if (initial_value)
8707         itype = TREE_TYPE (initial_value);
8708       else
8709         itype = NULL;
8710       if (itype && !TYPE_DOMAIN (itype))
8711         TYPE_DOMAIN (itype) = domain;
8712       /* The type of the main variant should never be used for arrays
8713          of different sizes.  It should only ever be completed with the
8714          size of the array.  */
8715       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8716         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8717     }
8718
8719   /* Lay out the type now that we can get the real answer.  */
8720
8721   layout_type (type);
8722
8723   return value;
8724 }
8725 \f
8726 /* Return zero if something is declared to be a member of type
8727    CTYPE when in the context of CUR_TYPE.  STRING is the error
8728    message to print in that case.  Otherwise, quietly return 1.  */
8729
8730 static int
8731 member_function_or_else (ctype, cur_type, flags)
8732      tree ctype, cur_type;
8733      enum overload_flags flags;
8734 {
8735   if (ctype && ctype != cur_type)
8736     {
8737       if (flags == DTOR_FLAG)
8738         cp_error ("destructor for alien class `%T' cannot be a member",
8739                   ctype);
8740       else
8741         cp_error ("constructor for alien class `%T' cannot be a member",
8742                   ctype);
8743       return 0;
8744     }
8745   return 1;
8746 }
8747 \f
8748 /* Subroutine of `grokdeclarator'.  */
8749
8750 /* Generate errors possibly applicable for a given set of specifiers.
8751    This is for ARM $7.1.2.  */
8752
8753 static void
8754 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8755      tree object;
8756      const char *type;
8757      int virtualp, quals, friendp, raises, inlinep;
8758 {
8759   if (virtualp)
8760     cp_error ("`%D' declared as a `virtual' %s", object, type);
8761   if (inlinep)
8762     cp_error ("`%D' declared as an `inline' %s", object, type);
8763   if (quals)
8764     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8765               object, type);
8766   if (friendp)
8767     cp_error_at ("`%D' declared as a friend", object);
8768   if (raises)
8769     cp_error_at ("`%D' declared with an exception specification", object);
8770 }
8771
8772 /* CTYPE is class type, or null if non-class.
8773    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8774    or METHOD_TYPE.
8775    DECLARATOR is the function's name.
8776    VIRTUALP is truthvalue of whether the function is virtual or not.
8777    FLAGS are to be passed through to `grokclassfn'.
8778    QUALS are qualifiers indicating whether the function is `const'
8779    or `volatile'.
8780    RAISES is a list of exceptions that this function can raise.
8781    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8782    not look, and -1 if we should not call `grokclassfn' at all.
8783
8784    Returns `NULL_TREE' if something goes wrong, after issuing
8785    applicable error messages.  */
8786
8787 static tree
8788 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8789             raises, check, friendp, publicp, inlinep, funcdef_flag,
8790             template_count, in_namespace)
8791      tree ctype, type;
8792      tree declarator;
8793      tree orig_declarator;
8794      int virtualp;
8795      enum overload_flags flags;
8796      tree quals, raises;
8797      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8798      tree in_namespace;
8799 {
8800   tree cname, decl;
8801   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8802   int has_default_arg = 0;
8803   tree t;
8804
8805   if (ctype)
8806     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8807       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8808   else
8809     cname = NULL_TREE;
8810
8811   if (raises)
8812     {
8813       type = build_exception_variant (type, raises);
8814     }
8815
8816   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8817   /* Propagate volatile out from type to decl. */
8818   if (TYPE_VOLATILE (type))
8819     TREE_THIS_VOLATILE (decl) = 1;
8820
8821   /* If this decl has namespace scope, set that up.  */
8822   if (in_namespace)
8823     set_decl_namespace (decl, in_namespace, friendp);
8824   else if (!ctype)
8825     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8826
8827   /* `main' and builtins have implicit 'C' linkage.  */
8828   if ((MAIN_NAME_P (declarator)
8829        || (IDENTIFIER_LENGTH (declarator) > 10
8830            && IDENTIFIER_POINTER (declarator)[0] == '_'
8831            && IDENTIFIER_POINTER (declarator)[1] == '_'
8832            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8833       && current_lang_name == lang_name_cplusplus
8834       && ctype == NULL_TREE
8835       /* NULL_TREE means global namespace.  */
8836       && DECL_CONTEXT (decl) == NULL_TREE)
8837     DECL_LANGUAGE (decl) = lang_c;
8838
8839   /* Should probably propagate const out from type to decl I bet (mrs).  */
8840   if (staticp)
8841     {
8842       DECL_STATIC_FUNCTION_P (decl) = 1;
8843       DECL_CONTEXT (decl) = ctype;
8844     }
8845
8846   if (ctype)
8847     DECL_CONTEXT (decl) = ctype;
8848
8849   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8850     {
8851       if (processing_template_decl)
8852         error ("cannot declare `::main' to be a template");
8853       if (inlinep)
8854         error ("cannot declare `::main' to be inline");
8855       if (!publicp)
8856         error ("cannot declare `::main' to be static");
8857       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8858                         integer_type_node))
8859         error ("`main' must return `int'");
8860       inlinep = 0;
8861       publicp = 1;
8862     }
8863
8864   /* Members of anonymous types and local classes have no linkage; make
8865      them internal.  */
8866   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8867                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8868     publicp = 0;
8869
8870   if (publicp)
8871     {
8872       /* [basic.link]: A name with no linkage (notably, the name of a class
8873          or enumeration declared in a local scope) shall not be used to
8874          declare an entity with linkage.
8875
8876          Only check this for public decls for now.  */
8877       t = no_linkage_check (TREE_TYPE (decl));
8878       if (t)
8879         {
8880           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8881             {
8882               if (DECL_EXTERN_C_P (decl))
8883                 /* Allow this; it's pretty common in C.  */;
8884               else
8885                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8886                             decl);
8887             }
8888           else
8889             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8890                         decl, t);
8891         }
8892     }
8893
8894   TREE_PUBLIC (decl) = publicp;
8895   if (! publicp)
8896     {
8897       DECL_INTERFACE_KNOWN (decl) = 1;
8898       DECL_NOT_REALLY_EXTERN (decl) = 1;
8899     }
8900
8901   if (inlinep)
8902     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8903
8904   DECL_EXTERNAL (decl) = 1;
8905   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8906     {
8907       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8908                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8909       quals = NULL_TREE;
8910     }
8911
8912   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8913     grok_op_properties (decl, virtualp, check < 0);
8914
8915   if (ctype && decl_function_context (decl))
8916     DECL_NO_STATIC_CHAIN (decl) = 1;
8917
8918   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8919     if (TREE_PURPOSE (t)
8920         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8921       {
8922         has_default_arg = 1;
8923         break;
8924       }
8925
8926   if (friendp
8927       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8928     {
8929       if (funcdef_flag)
8930         cp_error
8931           ("defining explicit specialization `%D' in friend declaration",
8932            orig_declarator);
8933       else
8934         {
8935           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8936             {
8937               /* Something like `template <class T> friend void f<T>()'.  */
8938               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8939                         orig_declarator);
8940               return NULL_TREE;
8941             }
8942
8943
8944           /* A friend declaration of the form friend void f<>().  Record
8945              the information in the TEMPLATE_ID_EXPR.  */
8946           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8947           DECL_TEMPLATE_INFO (decl)
8948             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8949                          TREE_OPERAND (orig_declarator, 1),
8950                          NULL_TREE);
8951
8952           if (has_default_arg)
8953             {
8954               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8955                         decl);
8956               return NULL_TREE;
8957             }
8958
8959           if (inlinep)
8960             {
8961               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8962                         decl);
8963               return NULL_TREE;
8964             }
8965         }
8966     }
8967
8968   if (has_default_arg)
8969     add_defarg_fn (decl);
8970
8971   /* Plain overloading: will not be grok'd by grokclassfn.  */
8972   if (! ctype && ! processing_template_decl
8973       && !DECL_EXTERN_C_P (decl)
8974       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8975     set_mangled_name_for_decl (decl);
8976
8977   if (funcdef_flag)
8978     /* Make the init_value nonzero so pushdecl knows this is not
8979        tentative.  error_mark_node is replaced later with the BLOCK.  */
8980     DECL_INITIAL (decl) = error_mark_node;
8981
8982   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8983     TREE_NOTHROW (decl) = 1;
8984
8985   /* Caller will do the rest of this.  */
8986   if (check < 0)
8987     return decl;
8988
8989   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8990     DECL_CONSTRUCTOR_P (decl) = 1;
8991
8992   /* Function gets the ugly name, field gets the nice one.  This call
8993      may change the type of the function (because of default
8994      parameters)!  */
8995   if (ctype != NULL_TREE)
8996     grokclassfn (ctype, decl, flags, quals);
8997
8998   decl = check_explicit_specialization (orig_declarator, decl,
8999                                         template_count,
9000                                         2 * (funcdef_flag != 0) +
9001                                         4 * (friendp != 0));
9002   if (decl == error_mark_node)
9003     return NULL_TREE;
9004
9005   if (ctype != NULL_TREE
9006       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9007       && check)
9008     {
9009       tree old_decl;
9010
9011       old_decl = check_classfn (ctype, decl);
9012
9013       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9014         /* Because grokfndecl is always supposed to return a
9015            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9016            here.  We depend on our callers to figure out that its
9017            really a template that's being returned.  */
9018         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9019
9020       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9021           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9022         {
9023           /* Remove the `this' parm added by grokclassfn.
9024              XXX Isn't this done in start_function, too?  */
9025           revert_static_member_fn (decl);
9026           last_function_parms = TREE_CHAIN (last_function_parms);
9027         }
9028       if (old_decl && DECL_ARTIFICIAL (old_decl))
9029         cp_error ("definition of implicitly-declared `%D'", old_decl);
9030
9031       if (old_decl)
9032         {
9033           /* Since we've smashed OLD_DECL to its
9034              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9035           if (TREE_CODE (decl) == TEMPLATE_DECL)
9036             decl = DECL_TEMPLATE_RESULT (decl);
9037
9038           /* Attempt to merge the declarations.  This can fail, in
9039              the case of some illegal specialization declarations.  */
9040           if (!duplicate_decls (decl, old_decl))
9041             cp_error ("no `%#D' member function declared in class `%T'",
9042                       decl, ctype);
9043           return old_decl;
9044         }
9045     }
9046
9047   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9048     return NULL_TREE;
9049
9050   if (ctype == NULL_TREE || check)
9051     return decl;
9052
9053   if (virtualp)
9054     {
9055       DECL_VIRTUAL_P (decl) = 1;
9056       if (DECL_VINDEX (decl) == NULL_TREE)
9057         DECL_VINDEX (decl) = error_mark_node;
9058       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9059     }
9060
9061   return decl;
9062 }
9063
9064 static tree
9065 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9066      tree type;
9067      tree declarator;
9068      RID_BIT_TYPE *specbits_in;
9069      int initialized;
9070      int constp;
9071      tree in_namespace;
9072 {
9073   tree decl;
9074   RID_BIT_TYPE specbits;
9075
9076   specbits = *specbits_in;
9077
9078   if (TREE_CODE (type) == OFFSET_TYPE)
9079     {
9080       /* If you declare a static member so that it
9081          can be initialized, the code will reach here.  */
9082       tree basetype = TYPE_OFFSET_BASETYPE (type);
9083       type = TREE_TYPE (type);
9084       decl = build_lang_decl (VAR_DECL, declarator, type);
9085       DECL_CONTEXT (decl) = basetype;
9086       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9087          templates.  */
9088       if (!uses_template_parms (decl))
9089         {
9090           if (flag_new_abi)
9091             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9092           else
9093             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9094                                                             declarator);
9095         }
9096     }
9097   else
9098     {
9099       tree context;
9100
9101       if (in_namespace)
9102         context = in_namespace;
9103       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9104         context = current_namespace;
9105       else
9106         context = NULL_TREE;
9107
9108       if (processing_template_decl && context)
9109         /* For global variables, declared in a template, we need the
9110            full lang_decl.  */
9111         decl = build_lang_decl (VAR_DECL, declarator, type);
9112       else
9113         decl = build_decl (VAR_DECL, declarator, type);
9114
9115       if (context)
9116         set_decl_namespace (decl, context, 0);
9117
9118       context = DECL_CONTEXT (decl);
9119       if (declarator && context && current_lang_name != lang_name_c)
9120         {
9121           if (flag_new_abi)
9122             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9123           else
9124             DECL_ASSEMBLER_NAME (decl)
9125               = build_static_name (context, declarator);
9126         }
9127     }
9128
9129   if (in_namespace)
9130     set_decl_namespace (decl, in_namespace, 0);
9131
9132   if (RIDBIT_SETP (RID_EXTERN, specbits))
9133     {
9134       DECL_THIS_EXTERN (decl) = 1;
9135       DECL_EXTERNAL (decl) = !initialized;
9136     }
9137
9138   /* In class context, static means one per class,
9139      public access, and static storage.  */
9140   if (DECL_CLASS_SCOPE_P (decl))
9141     {
9142       TREE_PUBLIC (decl) = 1;
9143       TREE_STATIC (decl) = 1;
9144       DECL_EXTERNAL (decl) = 0;
9145     }
9146   /* At top level, either `static' or no s.c. makes a definition
9147      (perhaps tentative), and absence of `static' makes it public.  */
9148   else if (toplevel_bindings_p ())
9149     {
9150       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9151                             && (DECL_THIS_EXTERN (decl) || ! constp));
9152       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9153     }
9154   /* Not at top level, only `static' makes a static definition.  */
9155   else
9156     {
9157       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9158       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9159     }
9160
9161   if (TREE_PUBLIC (decl))
9162     {
9163       /* [basic.link]: A name with no linkage (notably, the name of a class
9164          or enumeration declared in a local scope) shall not be used to
9165          declare an entity with linkage.
9166
9167          Only check this for public decls for now.  */
9168       tree t = no_linkage_check (TREE_TYPE (decl));
9169       if (t)
9170         {
9171           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9172             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9173           else
9174             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9175                         decl, t);
9176         }
9177     }
9178
9179   return decl;
9180 }
9181
9182 /* Create and return a canonical pointer to member function type, for
9183    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9184
9185 tree
9186 build_ptrmemfunc_type (type)
9187      tree type;
9188 {
9189   tree fields[4];
9190   tree t;
9191   tree u;
9192   tree unqualified_variant = NULL_TREE;
9193
9194   /* If a canonical type already exists for this type, use it.  We use
9195      this method instead of type_hash_canon, because it only does a
9196      simple equality check on the list of field members.  */
9197
9198   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9199     return t;
9200
9201   /* Make sure that we always have the unqualified pointer-to-member
9202      type first.  */
9203   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9204     unqualified_variant
9205       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9206
9207   t = make_aggr_type (RECORD_TYPE);
9208   /* Let the front-end know this is a pointer to member function...  */
9209   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9210   /* ... and not really an aggregate.  */
9211   SET_IS_AGGR_TYPE (t, 0);
9212
9213   if (!flag_new_abi)
9214     {
9215       u = make_aggr_type (UNION_TYPE);
9216       SET_IS_AGGR_TYPE (u, 0);
9217       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9218       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9219                               delta_type_node);
9220       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9221       TYPE_NAME (u) = NULL_TREE;
9222
9223       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9224                               delta_type_node);
9225       fields[1] = build_decl (FIELD_DECL, index_identifier,
9226                               delta_type_node);
9227       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9228       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9229     }
9230   else
9231     {
9232       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9233       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9234                               delta_type_node);
9235       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9236     }
9237
9238   /* Zap out the name so that the back-end will give us the debugging
9239      information for this anonymous RECORD_TYPE.  */
9240   TYPE_NAME (t) = NULL_TREE;
9241
9242   /* If this is not the unqualified form of this pointer-to-member
9243      type, set the TYPE_MAIN_VARIANT for this type to be the
9244      unqualified type.  Since they are actually RECORD_TYPEs that are
9245      not variants of each other, we must do this manually.  */
9246   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9247     {
9248       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9249       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9250       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9251       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9252     }
9253
9254   /* Cache this pointer-to-member type so that we can find it again
9255      later.  */
9256   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9257
9258   /* Seems to be wanted.  */
9259   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9260
9261   return t;
9262 }
9263
9264 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9265    Check to see that the definition is valid.  Issue appropriate error
9266    messages.  Return 1 if the definition is particularly bad, or 0
9267    otherwise.  */
9268
9269 int
9270 check_static_variable_definition (decl, type)
9271      tree decl;
9272      tree type;
9273 {
9274   /* Motion 10 at San Diego: If a static const integral data member is
9275      initialized with an integral constant expression, the initializer
9276      may appear either in the declaration (within the class), or in
9277      the definition, but not both.  If it appears in the class, the
9278      member is a member constant.  The file-scope definition is always
9279      required.  */
9280   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9281     {
9282       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9283                 type);
9284       /* If we just return the declaration, crashes will sometimes
9285          occur.  We therefore return void_type_node, as if this was a
9286          friend declaration, to cause callers to completely ignore
9287          this declaration.  */
9288       return 1;
9289     }
9290   else if (!CP_TYPE_CONST_P (type))
9291     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9292               decl);
9293   else if (pedantic && !INTEGRAL_TYPE_P (type))
9294     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9295
9296   return 0;
9297 }
9298
9299 /* Given the SIZE (i.e., number of elements) in an array, compute an
9300    appropriate index type for the array.  If non-NULL, NAME is the
9301    name of the thing being declared.  */
9302
9303 tree
9304 compute_array_index_type (name, size)
9305      tree name;
9306      tree size;
9307 {
9308   tree itype;
9309
9310   /* The size might be the result of a cast. */
9311   STRIP_TYPE_NOPS (size);
9312
9313   /* It might be a const variable or enumeration constant.  */
9314   size = decl_constant_value (size);
9315
9316   /* If this involves a template parameter, it will be a constant at
9317      instantiation time, but we don't know what the value is yet.
9318      Even if no template parameters are involved, we may an expression
9319      that is not a constant; we don't even simplify `1 + 2' when
9320      processing a template.  */
9321   if (processing_template_decl)
9322     {
9323       /* Resolve a qualified reference to an enumerator or static
9324          const data member of ours.  */
9325       if (TREE_CODE (size) == SCOPE_REF
9326           && TREE_OPERAND (size, 0) == current_class_type)
9327         {
9328           tree t = lookup_field (current_class_type,
9329                                  TREE_OPERAND (size, 1), 0, 0);
9330           if (t)
9331             size = t;
9332         }
9333
9334       return build_index_type (build_min (MINUS_EXPR, sizetype,
9335                                           size, integer_one_node));
9336     }
9337
9338   /* The array bound must be an integer type.  */
9339   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9340       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9341       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9342     {
9343       if (name)
9344         cp_error ("size of array `%D' has non-integer type", name);
9345       else
9346         cp_error ("size of array has non-integer type");
9347       size = integer_one_node;
9348     }
9349
9350   /* Normally, the array-bound will be a constant.  */
9351   if (TREE_CODE (size) == INTEGER_CST)
9352     {
9353       /* Check to see if the array bound overflowed.  Make that an
9354          error, no matter how generous we're being.  */
9355       int old_flag_pedantic_errors = flag_pedantic_errors;
9356       int old_pedantic = pedantic;
9357       pedantic = flag_pedantic_errors = 1;
9358       constant_expression_warning (size);
9359       pedantic = old_pedantic;
9360       flag_pedantic_errors = old_flag_pedantic_errors;
9361
9362       /* An array must have a positive number of elements.  */
9363       if (INT_CST_LT (size, integer_zero_node))
9364         {
9365           if (name)
9366             cp_error ("size of array `%D' is negative", name);
9367           else
9368             cp_error ("size of array is negative");
9369           size = integer_one_node;
9370         }
9371       /* Except that an extension we allow zero-sized arrays.  We
9372          always allow them in system headers because glibc uses
9373          them.  */
9374       else if (integer_zerop (size) && pedantic && !in_system_header)
9375         {
9376           if (name)
9377             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9378           else
9379             cp_pedwarn ("ISO C++ forbids zero-size array");
9380         }
9381     }
9382   else if (TREE_CONSTANT (size))
9383     {
9384       /* `(int) &fn' is not a valid array bound.  */
9385       if (name)
9386         cp_error ("size of array `%D' is not an integral constant-expression",
9387                   name);
9388       else
9389         cp_error ("size of array is not an integral constant-expression");
9390     }
9391
9392   /* Compute the index of the largest element in the array.  It is
9393      one less than the number of elements in the array.  */
9394   itype
9395     = fold (cp_build_binary_op (MINUS_EXPR,
9396                                 cp_convert (ssizetype, size),
9397                                 cp_convert (ssizetype,
9398                                             integer_one_node)));
9399
9400   /* Check for variable-sized arrays.  We allow such things as an
9401      extension, even though they are not allowed in ANSI/ISO C++.  */
9402   if (!TREE_CONSTANT (itype))
9403     {
9404       if (pedantic)
9405         {
9406           if (name)
9407             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9408                         name);
9409           else
9410             cp_pedwarn ("ISO C++ forbids variable-size array");
9411         }
9412
9413       /* Create a variable-sized array index type.  */
9414       itype = variable_size (itype);
9415     }
9416   /* Make sure that there was no overflow when creating to a signed
9417      index type.  (For example, on a 32-bit machine, an array with
9418      size 2^32 - 1 is too big.)  */
9419   else if (TREE_OVERFLOW (itype))
9420     {
9421       error ("overflow in array dimension");
9422       TREE_OVERFLOW (itype) = 0;
9423     }
9424
9425   /* Create and return the appropriate index type.  */
9426   return build_index_type (itype);
9427 }
9428
9429 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9430    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9431    with this type.  */
9432
9433 static tree
9434 create_array_type_for_decl (name, type, size)
9435      tree name;
9436      tree type;
9437      tree size;
9438 {
9439   tree itype = NULL_TREE;
9440   const char* error_msg;
9441
9442   /* If things have already gone awry, bail now.  */
9443   if (type == error_mark_node || size == error_mark_node)
9444     return error_mark_node;
9445
9446   /* Assume that everything will go OK.  */
9447   error_msg = NULL;
9448
9449   /* There are some types which cannot be array elements.  */
9450   switch (TREE_CODE (type))
9451     {
9452     case VOID_TYPE:
9453       error_msg = "array of void";
9454       break;
9455
9456     case FUNCTION_TYPE:
9457       error_msg = "array of functions";
9458       break;
9459
9460     case REFERENCE_TYPE:
9461       error_msg = "array of references";
9462       break;
9463
9464     case OFFSET_TYPE:
9465       error_msg = "array of data members";
9466       break;
9467
9468     case METHOD_TYPE:
9469       error_msg = "array of function members";
9470       break;
9471
9472     default:
9473       break;
9474     }
9475
9476   /* If something went wrong, issue an error-message and return.  */
9477   if (error_msg)
9478     {
9479       if (name)
9480         cp_error ("declaration of `%D' as %s", name, error_msg);
9481       else
9482         cp_error ("creating %s", error_msg);
9483
9484       return error_mark_node;
9485     }
9486
9487   /* [dcl.array]
9488
9489      The constant expressions that specify the bounds of the arrays
9490      can be omitted only for the first member of the sequence.  */
9491   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9492     {
9493       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9494                 name);
9495
9496       return error_mark_node;
9497     }
9498
9499   /* Figure out the index type for the array.  */
9500   if (size)
9501     itype = compute_array_index_type (name, size);
9502
9503   return build_cplus_array_type (type, itype);
9504 }
9505
9506 /* Check that it's OK to declare a function with the indicated TYPE.
9507    SFK indicates the kind of special function (if any) that this
9508    function is.  CTYPE is the class of which this function is a
9509    member.  OPTYPE is the type given in a conversion operator
9510    declaration.  Returns the actual return type of the function; that
9511    may be different than TYPE if an error occurs, or for certain
9512    special functions.  */
9513
9514 static tree
9515 check_special_function_return_type (sfk, type, ctype, optype)
9516      special_function_kind sfk;
9517      tree type;
9518      tree ctype;
9519      tree optype;
9520 {
9521   switch (sfk)
9522     {
9523     case sfk_constructor:
9524       if (type)
9525         cp_error ("return type specification for constructor invalid");
9526
9527       /* In the old ABI, we return `this'; in the new ABI we don't
9528          bother.  */
9529       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9530       break;
9531
9532     case sfk_destructor:
9533       if (type)
9534         cp_error ("return type specification for destructor invalid");
9535       type = void_type_node;
9536       break;
9537
9538     case sfk_conversion:
9539       if (type && !same_type_p (type, optype))
9540         cp_error ("operator `%T' declared to return `%T'", optype, type);
9541       else if (type)
9542         cp_pedwarn ("return type specified for `operator %T'",  optype);
9543       type = optype;
9544       break;
9545
9546     default:
9547       my_friendly_abort (20000408);
9548       break;
9549     }
9550
9551   return type;
9552 }
9553
9554 /* Given declspecs and a declarator,
9555    determine the name and type of the object declared
9556    and construct a ..._DECL node for it.
9557    (In one case we can return a ..._TYPE node instead.
9558     For invalid input we sometimes return 0.)
9559
9560    DECLSPECS is a chain of tree_list nodes whose value fields
9561     are the storage classes and type specifiers.
9562
9563    DECL_CONTEXT says which syntactic context this declaration is in:
9564      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9565      FUNCDEF for a function definition.  Like NORMAL but a few different
9566       error messages in each case.  Return value may be zero meaning
9567       this definition is too screwy to try to parse.
9568      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9569       handle member functions (which have FIELD context).
9570       Return value may be zero meaning this definition is too screwy to
9571       try to parse.
9572      PARM for a parameter declaration (either within a function prototype
9573       or before a function body).  Make a PARM_DECL, or return void_type_node.
9574      CATCHPARM for a parameter declaration before a catch clause.
9575      TYPENAME if for a typename (in a cast or sizeof).
9576       Don't make a DECL node; just return the ..._TYPE node.
9577      FIELD for a struct or union field; make a FIELD_DECL.
9578      BITFIELD for a field with specified width.
9579    INITIALIZED is 1 if the decl has an initializer.
9580
9581    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9582    normal attributes in TREE_PURPOSE, or NULL_TREE.
9583
9584    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9585    It may also be so in the PARM case, for a prototype where the
9586    argument type is specified but not the name.
9587
9588    This function is where the complicated C meanings of `static'
9589    and `extern' are interpreted.
9590
9591    For C++, if there is any monkey business to do, the function which
9592    calls this one must do it, i.e., prepending instance variables,
9593    renaming overloaded function names, etc.
9594
9595    Note that for this C++, it is an error to define a method within a class
9596    which does not belong to that class.
9597
9598    Except in the case where SCOPE_REFs are implicitly known (such as
9599    methods within a class being redundantly qualified),
9600    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9601    (class_name::decl_name).  The caller must also deal with this.
9602
9603    If a constructor or destructor is seen, and the context is FIELD,
9604    then the type gains the attribute TREE_HAS_x.  If such a declaration
9605    is erroneous, NULL_TREE is returned.
9606
9607    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9608    function, these are the qualifiers to give to the `this' pointer. We
9609    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9610
9611    May return void_type_node if the declarator turned out to be a friend.
9612    See grokfield for details.  */
9613
9614 tree
9615 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9616      tree declspecs;
9617      tree declarator;
9618      enum decl_context decl_context;
9619      int initialized;
9620      tree attrlist;
9621 {
9622   RID_BIT_TYPE specbits;
9623   int nclasses = 0;
9624   tree spec;
9625   tree type = NULL_TREE;
9626   int longlong = 0;
9627   int constp;
9628   int restrictp;
9629   int volatilep;
9630   int type_quals;
9631   int virtualp, explicitp, friendp, inlinep, staticp;
9632   int explicit_int = 0;
9633   int explicit_char = 0;
9634   int defaulted_int = 0;
9635   tree typedef_decl = NULL_TREE;
9636   const char *name;
9637   tree typedef_type = NULL_TREE;
9638   int funcdef_flag = 0;
9639   enum tree_code innermost_code = ERROR_MARK;
9640   int bitfield = 0;
9641 #if 0
9642   /* See the code below that used this.  */
9643   tree decl_machine_attr = NULL_TREE;
9644 #endif
9645   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9646      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9647   tree init = NULL_TREE;
9648
9649   /* Keep track of what sort of function is being processed
9650      so that we can warn about default return values, or explicit
9651      return values which do not match prescribed defaults.  */
9652   special_function_kind sfk = sfk_none;
9653
9654   tree dname = NULL_TREE;
9655   tree ctype = current_class_type;
9656   tree ctor_return_type = NULL_TREE;
9657   enum overload_flags flags = NO_SPECIAL;
9658   tree quals = NULL_TREE;
9659   tree raises = NULL_TREE;
9660   int template_count = 0;
9661   tree in_namespace = NULL_TREE;
9662   tree inner_attrs;
9663   int ignore_attrs;
9664
9665   RIDBIT_RESET_ALL (specbits);
9666   if (decl_context == FUNCDEF)
9667     funcdef_flag = 1, decl_context = NORMAL;
9668   else if (decl_context == MEMFUNCDEF)
9669     funcdef_flag = -1, decl_context = FIELD;
9670   else if (decl_context == BITFIELD)
9671     bitfield = 1, decl_context = FIELD;
9672
9673   /* Look inside a declarator for the name being declared
9674      and get it as a string, for an error message.  */
9675   {
9676     tree *next = &declarator;
9677     register tree decl;
9678     name = NULL;
9679
9680     while (next && *next)
9681       {
9682         decl = *next;
9683         switch (TREE_CODE (decl))
9684           {
9685           case TREE_LIST:
9686             /* For attributes.  */
9687             next = &TREE_VALUE (decl);
9688             break;
9689
9690           case COND_EXPR:
9691             ctype = NULL_TREE;
9692             next = &TREE_OPERAND (decl, 0);
9693             break;
9694
9695           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9696             {
9697               tree name = TREE_OPERAND (decl, 0);
9698               tree rename = NULL_TREE;
9699
9700               my_friendly_assert (flags == NO_SPECIAL, 152);
9701               flags = DTOR_FLAG;
9702               sfk = sfk_destructor;
9703               if (TREE_CODE (name) == TYPE_DECL)
9704                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9705               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9706               if (ctype == NULL_TREE)
9707                 {
9708                   if (current_class_type == NULL_TREE)
9709                     {
9710                       error ("destructors must be member functions");
9711                       flags = NO_SPECIAL;
9712                     }
9713                   else
9714                     {
9715                       tree t = constructor_name (current_class_name);
9716                       if (t != name)
9717                         rename = t;
9718                     }
9719                 }
9720               else
9721                 {
9722                   tree t = constructor_name (ctype);
9723                   if (t != name)
9724                     rename = t;
9725                 }
9726
9727               if (rename)
9728                 {
9729                   cp_error ("destructor `%T' must match class name `%T'",
9730                             name, rename);
9731                   TREE_OPERAND (decl, 0) = rename;
9732                 }
9733               next = &name;
9734             }
9735             break;
9736
9737           case ADDR_EXPR:       /* C++ reference declaration */
9738             /* Fall through. */
9739           case ARRAY_REF:
9740           case INDIRECT_REF:
9741             ctype = NULL_TREE;
9742             innermost_code = TREE_CODE (decl);
9743             next = &TREE_OPERAND (decl, 0);
9744             break;
9745
9746           case CALL_EXPR:
9747             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9748               {
9749                 /* This is actually a variable declaration using
9750                    constructor syntax.  We need to call start_decl and
9751                    cp_finish_decl so we can get the variable
9752                    initialized...  */
9753
9754                 tree attributes, prefix_attributes;
9755
9756                 *next = TREE_OPERAND (decl, 0);
9757                 init = CALL_DECLARATOR_PARMS (decl);
9758
9759                 if (attrlist)
9760                   {
9761                     attributes = TREE_PURPOSE (attrlist);
9762                     prefix_attributes = TREE_VALUE (attrlist);
9763                   }
9764                 else
9765                   {
9766                     attributes = NULL_TREE;
9767                     prefix_attributes = NULL_TREE;
9768                   }
9769
9770                 decl = start_decl (declarator, declspecs, 1,
9771                                    attributes, prefix_attributes);
9772                 decl_type_access_control (decl);
9773                 if (decl)
9774                   {
9775                     /* Look for __unused__ attribute */
9776                     if (TREE_USED (TREE_TYPE (decl)))
9777                       TREE_USED (decl) = 1;
9778                     finish_decl (decl, init, NULL_TREE);
9779                   }
9780                 else
9781                   cp_error ("invalid declarator");
9782                 return 0;
9783               }
9784             innermost_code = TREE_CODE (decl);
9785             if (decl_context == FIELD && ctype == NULL_TREE)
9786               ctype = current_class_type;
9787             if (ctype
9788                 && TREE_OPERAND (decl, 0)
9789                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9790                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9791                          == constructor_name_full (ctype))
9792                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9793                             == constructor_name (ctype)))))
9794               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9795             next = &TREE_OPERAND (decl, 0);
9796             decl = *next;
9797             if (ctype != NULL_TREE
9798                 && decl != NULL_TREE && flags != DTOR_FLAG
9799                 && decl == constructor_name (ctype))
9800               {
9801                 sfk = sfk_constructor;
9802                 ctor_return_type = ctype;
9803               }
9804             ctype = NULL_TREE;
9805             break;
9806
9807           case TEMPLATE_ID_EXPR:
9808               {
9809                 tree fns = TREE_OPERAND (decl, 0);
9810
9811                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9812                   fns = TREE_OPERAND (fns, 0);
9813
9814                 dname = fns;
9815                 if (TREE_CODE (dname) == COMPONENT_REF)
9816                   dname = TREE_OPERAND (dname, 1);
9817                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9818                   {
9819                     my_friendly_assert (is_overloaded_fn (dname),
9820                                         19990331);
9821                     dname = DECL_NAME (get_first_fn (dname));
9822                   }
9823               }
9824           /* Fall through. */
9825
9826           case IDENTIFIER_NODE:
9827             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9828               dname = decl;
9829
9830             next = 0;
9831
9832             if (is_rid (dname))
9833               {
9834                 cp_error ("declarator-id missing; using reserved word `%D'",
9835                           dname);
9836                 name = IDENTIFIER_POINTER (dname);
9837               }
9838             else if (!IDENTIFIER_TYPENAME_P (dname))
9839               name = IDENTIFIER_POINTER (dname);
9840             else
9841               {
9842                 my_friendly_assert (flags == NO_SPECIAL, 154);
9843                 flags = TYPENAME_FLAG;
9844                 ctor_return_type = TREE_TYPE (dname);
9845                 sfk = sfk_conversion;
9846                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9847                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9848                         == TYPE_DECL))
9849                   name = IDENTIFIER_POINTER (dname);
9850                 else
9851                   name = "<invalid operator>";
9852               }
9853             break;
9854
9855             /* C++ extension */
9856           case SCOPE_REF:
9857             {
9858               /* Perform error checking, and decide on a ctype.  */
9859               tree cname = TREE_OPERAND (decl, 0);
9860               if (cname == NULL_TREE)
9861                 ctype = NULL_TREE;
9862               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9863                 {
9864                   ctype = NULL_TREE;
9865                   in_namespace = TREE_OPERAND (decl, 0);
9866                   TREE_OPERAND (decl, 0) = NULL_TREE;
9867                 }
9868               else if (! is_aggr_type (cname, 1))
9869                 TREE_OPERAND (decl, 0) = NULL_TREE;
9870               /* Must test TREE_OPERAND (decl, 1), in case user gives
9871                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9872               else if (TREE_OPERAND (decl, 1)
9873                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9874                 ctype = cname;
9875               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9876                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9877                 {
9878                   cp_error ("`%T::%D' is not a valid declarator", cname,
9879                             TREE_OPERAND (decl, 1));
9880                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9881                             cname, TREE_OPERAND (decl, 1));
9882                   return void_type_node;
9883                 }
9884               else if (ctype == NULL_TREE)
9885                 ctype = cname;
9886               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9887                 TREE_OPERAND (decl, 0) = ctype;
9888               else
9889                 {
9890                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9891                     {
9892                       cp_error ("type `%T' is not derived from type `%T'",
9893                                 cname, ctype);
9894                       TREE_OPERAND (decl, 0) = NULL_TREE;
9895                     }
9896                   else
9897                     ctype = cname;
9898                 }
9899
9900               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9901                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9902                        == constructor_name_full (ctype))
9903                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9904                           == constructor_name (ctype))))
9905                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9906               next = &TREE_OPERAND (decl, 1);
9907               decl = *next;
9908               if (ctype)
9909                 {
9910                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9911                       && constructor_name (ctype) == decl)
9912                     {
9913                       sfk = sfk_constructor;
9914                       ctor_return_type = ctype;
9915                     }
9916                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9917                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9918                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9919                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9920                     {
9921                       sfk = sfk_destructor;
9922                       ctor_return_type = ctype;
9923                       flags = DTOR_FLAG;
9924                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9925                       next = &TREE_OPERAND (decl, 0);
9926                     }
9927                 }
9928             }
9929             break;
9930
9931           case ERROR_MARK:
9932             next = 0;
9933             break;
9934
9935           case TYPE_DECL:
9936             /* Parse error puts this typespec where
9937                a declarator should go.  */
9938             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9939             if (TREE_TYPE (decl) == current_class_type)
9940               cp_error ("  perhaps you want `%T' for a constructor",
9941                         current_class_name);
9942             dname = DECL_NAME (decl);
9943             name = IDENTIFIER_POINTER (dname);
9944
9945             /* Avoid giving two errors for this.  */
9946             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9947
9948             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9949             *next = dname;
9950             next = 0;
9951             break;
9952
9953           default:
9954             cp_compiler_error ("`%D' as declarator", decl);
9955             return 0; /* We used to do a 155 abort here.  */
9956           }
9957       }
9958   }
9959
9960   /* A function definition's declarator must have the form of
9961      a function declarator.  */
9962
9963   if (funcdef_flag && innermost_code != CALL_EXPR)
9964     return 0;
9965
9966   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9967       && innermost_code != CALL_EXPR
9968       && ! (ctype && declspecs == NULL_TREE))
9969     {
9970       cp_error ("declaration of `%D' as non-function", dname);
9971       return void_type_node;
9972     }
9973
9974   /* Anything declared one level down from the top level
9975      must be one of the parameters of a function
9976      (because the body is at least two levels down).  */
9977
9978   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9979      by not allowing C++ class definitions to specify their parameters
9980      with xdecls (must be spec.d in the parmlist).
9981
9982      Since we now wait to push a class scope until we are sure that
9983      we are in a legitimate method context, we must set oldcname
9984      explicitly (since current_class_name is not yet alive).
9985
9986      We also want to avoid calling this a PARM if it is in a namespace.  */
9987
9988   if (decl_context == NORMAL && !toplevel_bindings_p ())
9989     {
9990       struct binding_level *b = current_binding_level;
9991       current_binding_level = b->level_chain;
9992       if (current_binding_level != 0 && toplevel_bindings_p ())
9993         decl_context = PARM;
9994       current_binding_level = b;
9995     }
9996
9997   if (name == NULL)
9998     name = decl_context == PARM ? "parameter" : "type name";
9999
10000   /* Look through the decl specs and record which ones appear.
10001      Some typespecs are defined as built-in typenames.
10002      Others, the ones that are modifiers of other types,
10003      are represented by bits in SPECBITS: set the bits for
10004      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10005
10006      If there is a typedef name or a type, store the type in TYPE.
10007      This includes builtin typedefs such as `int'.
10008
10009      Set EXPLICIT_INT if the type is `int' or `char' and did not
10010      come from a user typedef.
10011
10012      Set LONGLONG if `long' is mentioned twice.
10013
10014      For C++, constructors and destructors have their own fast treatment.  */
10015
10016   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10017     {
10018       register int i;
10019       register tree id;
10020
10021       /* Certain parse errors slip through.  For example,
10022          `int class;' is not caught by the parser. Try
10023          weakly to recover here.  */
10024       if (TREE_CODE (spec) != TREE_LIST)
10025         return 0;
10026
10027       id = TREE_VALUE (spec);
10028
10029       if (TREE_CODE (id) == IDENTIFIER_NODE)
10030         {
10031           if (id == ridpointers[(int) RID_INT]
10032               || id == ridpointers[(int) RID_CHAR]
10033               || id == ridpointers[(int) RID_BOOL]
10034               || id == ridpointers[(int) RID_WCHAR])
10035             {
10036               if (type)
10037                 {
10038                   if (id == ridpointers[(int) RID_BOOL])
10039                     error ("`bool' is now a keyword");
10040                   else
10041                     cp_error ("extraneous `%T' ignored", id);
10042                 }
10043               else
10044                 {
10045                   if (id == ridpointers[(int) RID_INT])
10046                     explicit_int = 1;
10047                   else if (id == ridpointers[(int) RID_CHAR])
10048                     explicit_char = 1;
10049                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10050                 }
10051               goto found;
10052             }
10053           /* C++ aggregate types.  */
10054           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10055             {
10056               if (type)
10057                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10058               else
10059                 type = IDENTIFIER_TYPE_VALUE (id);
10060               goto found;
10061             }
10062
10063           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10064             {
10065               if (ridpointers[i] == id)
10066                 {
10067                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10068                     {
10069                       if (pedantic && ! in_system_header && warn_long_long)
10070                         pedwarn ("ISO C++ does not support `long long'");
10071                       if (longlong)
10072                         error ("`long long long' is too long for GCC");
10073                       else
10074                         longlong = 1;
10075                     }
10076                   else if (RIDBIT_SETP (i, specbits))
10077                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10078                   RIDBIT_SET (i, specbits);
10079                   goto found;
10080                 }
10081             }
10082         }
10083       /* C++ aggregate types.  */
10084       else if (TREE_CODE (id) == TYPE_DECL)
10085         {
10086           if (type)
10087             cp_error ("multiple declarations `%T' and `%T'", type,
10088                       TREE_TYPE (id));
10089           else
10090             {
10091               type = TREE_TYPE (id);
10092               TREE_VALUE (spec) = type;
10093             }
10094           goto found;
10095         }
10096       if (type)
10097         error ("two or more data types in declaration of `%s'", name);
10098       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10099         {
10100           register tree t = lookup_name (id, 1);
10101           if (!t || TREE_CODE (t) != TYPE_DECL)
10102             error ("`%s' fails to be a typedef or built in type",
10103                    IDENTIFIER_POINTER (id));
10104           else
10105             {
10106               type = TREE_TYPE (t);
10107 #if 0
10108               /* See the code below that used this.  */
10109               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10110 #endif
10111               typedef_decl = t;
10112             }
10113         }
10114       else if (id != error_mark_node)
10115         /* Can't change CLASS nodes into RECORD nodes here!  */
10116         type = id;
10117
10118     found: ;
10119     }
10120
10121   typedef_type = type;
10122
10123   /* No type at all: default to `int', and set DEFAULTED_INT
10124      because it was not a user-defined typedef.  */
10125
10126   if (type == NULL_TREE
10127       && (RIDBIT_SETP (RID_SIGNED, specbits)
10128           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10129           || RIDBIT_SETP (RID_LONG, specbits)
10130           || RIDBIT_SETP (RID_SHORT, specbits)))
10131     {
10132       /* These imply 'int'.  */
10133       type = integer_type_node;
10134       defaulted_int = 1;
10135     }
10136
10137   if (sfk != sfk_none)
10138     type = check_special_function_return_type (sfk, type,
10139                                                ctor_return_type,
10140                                                ctor_return_type);
10141   else if (type == NULL_TREE)
10142     {
10143       int is_main;
10144
10145       explicit_int = -1;
10146
10147           /* We handle `main' specially here, because 'main () { }' is so
10148              common.  With no options, it is allowed.  With -Wreturn-type,
10149              it is a warning.  It is only an error with -pedantic-errors.  */
10150       is_main = (funcdef_flag
10151                  && MAIN_NAME_P (dname)
10152                  && ctype == NULL_TREE
10153                  && in_namespace == NULL_TREE
10154                  && current_namespace == global_namespace);
10155
10156       if (in_system_header || flag_ms_extensions)
10157         /* Allow it, sigh.  */;
10158       else if (pedantic || ! is_main)
10159         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10160                     name);
10161       else if (warn_return_type)
10162         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10163                     name);
10164
10165       type = integer_type_node;
10166     }
10167
10168   ctype = NULL_TREE;
10169
10170   /* Now process the modifiers that were specified
10171      and check for invalid combinations.  */
10172
10173   /* Long double is a special combination.  */
10174
10175   if (RIDBIT_SETP (RID_LONG, specbits)
10176       && TYPE_MAIN_VARIANT (type) == double_type_node)
10177     {
10178       RIDBIT_RESET (RID_LONG, specbits);
10179       type = build_qualified_type (long_double_type_node,
10180                                    CP_TYPE_QUALS (type));
10181     }
10182
10183   /* Check all other uses of type modifiers.  */
10184
10185   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10186       || RIDBIT_SETP (RID_SIGNED, specbits)
10187       || RIDBIT_SETP (RID_LONG, specbits)
10188       || RIDBIT_SETP (RID_SHORT, specbits))
10189     {
10190       int ok = 0;
10191
10192       if (TREE_CODE (type) == REAL_TYPE)
10193         error ("short, signed or unsigned invalid for `%s'", name);
10194       else if (TREE_CODE (type) != INTEGER_TYPE)
10195         error ("long, short, signed or unsigned invalid for `%s'", name);
10196       else if (RIDBIT_SETP (RID_LONG, specbits)
10197                && RIDBIT_SETP (RID_SHORT, specbits))
10198         error ("long and short specified together for `%s'", name);
10199       else if ((RIDBIT_SETP (RID_LONG, specbits)
10200                 || RIDBIT_SETP (RID_SHORT, specbits))
10201                && explicit_char)
10202         error ("long or short specified with char for `%s'", name);
10203       else if ((RIDBIT_SETP (RID_LONG, specbits)
10204                 || RIDBIT_SETP (RID_SHORT, specbits))
10205                && TREE_CODE (type) == REAL_TYPE)
10206         error ("long or short specified with floating type for `%s'", name);
10207       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10208                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10209         error ("signed and unsigned given together for `%s'", name);
10210       else
10211         {
10212           ok = 1;
10213           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10214             {
10215               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10216                        name);
10217               if (flag_pedantic_errors)
10218                 ok = 0;
10219             }
10220         }
10221
10222       /* Discard the type modifiers if they are invalid.  */
10223       if (! ok)
10224         {
10225           RIDBIT_RESET (RID_UNSIGNED, specbits);
10226           RIDBIT_RESET (RID_SIGNED, specbits);
10227           RIDBIT_RESET (RID_LONG, specbits);
10228           RIDBIT_RESET (RID_SHORT, specbits);
10229           longlong = 0;
10230         }
10231     }
10232
10233   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10234       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10235     {
10236       error ("complex invalid for `%s'", name);
10237       RIDBIT_RESET (RID_COMPLEX, specbits);
10238     }
10239
10240   /* Decide whether an integer type is signed or not.
10241      Optionally treat bitfields as signed by default.  */
10242   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10243       /* [class.bit]
10244
10245          It is implementation-defined whether a plain (neither
10246          explicitly signed or unsigned) char, short, int, or long
10247          bit-field is signed or unsigned.
10248
10249          Naturally, we extend this to long long as well.  Note that
10250          this does not include wchar_t.  */
10251       || (bitfield && !flag_signed_bitfields
10252           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10253           /* A typedef for plain `int' without `signed' can be
10254              controlled just like plain `int', but a typedef for
10255              `signed int' cannot be so controlled.  */
10256           && !(typedef_decl
10257                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10258           && (TREE_CODE (type) == INTEGER_TYPE
10259               || TREE_CODE (type) == CHAR_TYPE)
10260           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10261     {
10262       if (longlong)
10263         type = long_long_unsigned_type_node;
10264       else if (RIDBIT_SETP (RID_LONG, specbits))
10265         type = long_unsigned_type_node;
10266       else if (RIDBIT_SETP (RID_SHORT, specbits))
10267         type = short_unsigned_type_node;
10268       else if (type == char_type_node)
10269         type = unsigned_char_type_node;
10270       else if (typedef_decl)
10271         type = unsigned_type (type);
10272       else
10273         type = unsigned_type_node;
10274     }
10275   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10276            && type == char_type_node)
10277     type = signed_char_type_node;
10278   else if (longlong)
10279     type = long_long_integer_type_node;
10280   else if (RIDBIT_SETP (RID_LONG, specbits))
10281     type = long_integer_type_node;
10282   else if (RIDBIT_SETP (RID_SHORT, specbits))
10283     type = short_integer_type_node;
10284
10285   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10286     {
10287       /* If we just have "complex", it is equivalent to
10288          "complex double", but if any modifiers at all are specified it is
10289          the complex form of TYPE.  E.g, "complex short" is
10290          "complex short int".  */
10291
10292       if (defaulted_int && ! longlong
10293           && ! (RIDBIT_SETP (RID_LONG, specbits)
10294                 || RIDBIT_SETP (RID_SHORT, specbits)
10295                 || RIDBIT_SETP (RID_SIGNED, specbits)
10296                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10297         type = complex_double_type_node;
10298       else if (type == integer_type_node)
10299         type = complex_integer_type_node;
10300       else if (type == float_type_node)
10301         type = complex_float_type_node;
10302       else if (type == double_type_node)
10303         type = complex_double_type_node;
10304       else if (type == long_double_type_node)
10305         type = complex_long_double_type_node;
10306       else
10307         type = build_complex_type (type);
10308     }
10309
10310   if (sfk == sfk_conversion
10311       && (RIDBIT_SETP (RID_CONST, specbits)
10312           || RIDBIT_SETP (RID_VOLATILE, specbits)
10313           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10314     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10315               ctor_return_type);
10316
10317   /* Set CONSTP if this declaration is `const', whether by
10318      explicit specification or via a typedef.
10319      Likewise for VOLATILEP.  */
10320
10321   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10322   restrictp =
10323     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10324   volatilep =
10325     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10326   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10327                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10328                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10329   type = cp_build_qualified_type (type, type_quals);
10330   staticp = 0;
10331   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10332   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10333   RIDBIT_RESET (RID_VIRTUAL, specbits);
10334   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10335   RIDBIT_RESET (RID_EXPLICIT, specbits);
10336
10337   if (RIDBIT_SETP (RID_STATIC, specbits))
10338     staticp = 1 + (decl_context == FIELD);
10339
10340   if (virtualp && staticp == 2)
10341     {
10342       cp_error ("member `%D' cannot be declared both virtual and static",
10343                 dname);
10344       staticp = 0;
10345     }
10346   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10347   RIDBIT_RESET (RID_FRIEND, specbits);
10348
10349   /* Warn if two storage classes are given. Default to `auto'.  */
10350
10351   if (RIDBIT_ANY_SET (specbits))
10352     {
10353       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10354       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10355       if (decl_context == PARM && nclasses > 0)
10356         error ("storage class specifiers invalid in parameter declarations");
10357       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10358         {
10359           if (decl_context == PARM)
10360             error ("typedef declaration invalid in parameter declaration");
10361           nclasses++;
10362         }
10363       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10364       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10365     }
10366
10367   /* Give error if `virtual' is used outside of class declaration.  */
10368   if (virtualp
10369       && (current_class_name == NULL_TREE || decl_context != FIELD))
10370     {
10371       error ("virtual outside class declaration");
10372       virtualp = 0;
10373     }
10374
10375   /* Static anonymous unions are dealt with here.  */
10376   if (staticp && decl_context == TYPENAME
10377       && TREE_CODE (declspecs) == TREE_LIST
10378       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10379     decl_context = FIELD;
10380
10381   /* Warn about storage classes that are invalid for certain
10382      kinds of declarations (parameters, typenames, etc.).  */
10383
10384   if (nclasses > 1)
10385     error ("multiple storage classes in declaration of `%s'", name);
10386   else if (decl_context != NORMAL && nclasses > 0)
10387     {
10388       if ((decl_context == PARM || decl_context == CATCHPARM)
10389           && (RIDBIT_SETP (RID_REGISTER, specbits)
10390               || RIDBIT_SETP (RID_AUTO, specbits)))
10391         ;
10392       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10393         ;
10394       else if (decl_context == FIELD
10395                /* C++ allows static class elements  */
10396                && RIDBIT_SETP (RID_STATIC, specbits))
10397         /* C++ also allows inlines and signed and unsigned elements,
10398            but in those cases we don't come in here.  */
10399         ;
10400       else
10401         {
10402           if (decl_context == FIELD)
10403             {
10404               tree tmp = NULL_TREE;
10405               register int op = 0;
10406
10407               if (declarator)
10408                 {
10409                   /* Avoid trying to get an operand off an identifier node.  */
10410                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10411                     tmp = declarator;
10412                   else
10413                     tmp = TREE_OPERAND (declarator, 0);
10414                   op = IDENTIFIER_OPNAME_P (tmp);
10415                   if (IDENTIFIER_TYPENAME_P (tmp))
10416                     {
10417                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10418                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10419                               == TYPE_DECL))
10420                         name = IDENTIFIER_POINTER (tmp);
10421                       else
10422                         name = "<invalid operator>";
10423                     }
10424                 }
10425               error ("storage class specified for %s `%s'",
10426                      op ? "member operator" : "field",
10427                      name);
10428             }
10429           else
10430             {
10431               if (decl_context == PARM || decl_context == CATCHPARM)
10432                 error ("storage class specified for parameter `%s'", name);
10433               else
10434                 error ("storage class specified for typename");
10435             }
10436           RIDBIT_RESET (RID_REGISTER, specbits);
10437           RIDBIT_RESET (RID_AUTO, specbits);
10438           RIDBIT_RESET (RID_EXTERN, specbits);
10439         }
10440     }
10441   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10442     {
10443       if (toplevel_bindings_p ())
10444         {
10445           /* It's common practice (and completely valid) to have a const
10446              be initialized and declared extern.  */
10447           if (!(type_quals & TYPE_QUAL_CONST))
10448             warning ("`%s' initialized and declared `extern'", name);
10449         }
10450       else
10451         error ("`%s' has both `extern' and initializer", name);
10452     }
10453   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10454            && ! toplevel_bindings_p ())
10455     error ("nested function `%s' declared `extern'", name);
10456   else if (toplevel_bindings_p ())
10457     {
10458       if (RIDBIT_SETP (RID_AUTO, specbits))
10459         error ("top-level declaration of `%s' specifies `auto'", name);
10460     }
10461
10462   if (nclasses > 0 && friendp)
10463     error ("storage class specifiers invalid in friend function declarations");
10464
10465   /* Now figure out the structure of the declarator proper.
10466      Descend through it, creating more complex types, until we reach
10467      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10468
10469   inner_attrs = NULL_TREE;
10470   ignore_attrs = 0;
10471
10472   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10473          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10474     {
10475       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10476          an INDIRECT_REF (for *...),
10477          a CALL_EXPR (for ...(...)),
10478          an identifier (for the name being declared)
10479          or a null pointer (for the place in an absolute declarator
10480          where the name was omitted).
10481          For the last two cases, we have just exited the loop.
10482
10483          For C++ it could also be
10484          a SCOPE_REF (for class :: ...).  In this case, we have converted
10485          sensible names to types, and those are the values we use to
10486          qualify the member name.
10487          an ADDR_EXPR (for &...),
10488          a BIT_NOT_EXPR (for destructors)
10489
10490          At this point, TYPE is the type of elements of an array,
10491          or for a function to return, or for a pointer to point to.
10492          After this sequence of ifs, TYPE is the type of the
10493          array or function or pointer, and DECLARATOR has had its
10494          outermost layer removed.  */
10495
10496       if (type == error_mark_node)
10497         {
10498           if (TREE_CODE (declarator) == SCOPE_REF)
10499             declarator = TREE_OPERAND (declarator, 1);
10500           else
10501             declarator = TREE_OPERAND (declarator, 0);
10502           continue;
10503         }
10504       if (quals != NULL_TREE
10505           && (declarator == NULL_TREE
10506               || TREE_CODE (declarator) != SCOPE_REF))
10507         {
10508           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10509             ctype = TYPE_METHOD_BASETYPE (type);
10510           if (ctype != NULL_TREE)
10511             {
10512               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10513               grok_method_quals (ctype, dummy, quals);
10514               type = TREE_TYPE (dummy);
10515               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10516               quals = NULL_TREE;
10517             }
10518         }
10519
10520       /* See the comment for the TREE_LIST case, below.  */
10521       if (ignore_attrs)
10522         ignore_attrs = 0;
10523       else if (inner_attrs)
10524         {
10525           decl_attributes (type, inner_attrs, NULL_TREE);
10526           inner_attrs = NULL_TREE;
10527         }
10528
10529       switch (TREE_CODE (declarator))
10530         {
10531         case TREE_LIST:
10532           {
10533             /* We encode a declarator with embedded attributes using
10534                a TREE_LIST.  The attributes apply to the declarator
10535                directly inside them, so we have to skip an iteration
10536                before applying them to the type.  If the declarator just
10537                inside is the declarator-id, we apply the attrs to the
10538                decl itself.  */
10539             inner_attrs = TREE_PURPOSE (declarator);
10540             ignore_attrs = 1;
10541             declarator = TREE_VALUE (declarator);
10542           }
10543           break;
10544
10545         case ARRAY_REF:
10546           {
10547             register tree size;
10548
10549             size = TREE_OPERAND (declarator, 1);
10550
10551             /* VC++ spells a zero-sized array with [].  */
10552             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10553                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10554               size = integer_zero_node;
10555
10556             declarator = TREE_OPERAND (declarator, 0);
10557
10558             type = create_array_type_for_decl (dname, type, size);
10559
10560             /* VLAs never work as fields. */
10561             if (decl_context == FIELD && !processing_template_decl
10562                 && TREE_CODE (type) == ARRAY_TYPE
10563                 && TYPE_DOMAIN (type) != NULL_TREE
10564                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10565               {
10566                 cp_error ("size of member `%D' is not constant", dname);
10567                 /* Proceed with arbitrary constant size, so that offset
10568                    computations don't get confused. */
10569                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10570                                                    integer_one_node);
10571               }
10572
10573             ctype = NULL_TREE;
10574           }
10575           break;
10576
10577         case CALL_EXPR:
10578           {
10579             tree arg_types;
10580             int funcdecl_p;
10581             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10582             tree inner_decl = TREE_OPERAND (declarator, 0);
10583
10584             /* Declaring a function type.
10585                Make sure we have a valid type for the function to return.  */
10586
10587             /* We now know that the TYPE_QUALS don't apply to the
10588                decl, but to its return type.  */
10589             type_quals = TYPE_UNQUALIFIED;
10590
10591             /* Warn about some types functions can't return.  */
10592
10593             if (TREE_CODE (type) == FUNCTION_TYPE)
10594               {
10595                 error ("`%s' declared as function returning a function", name);
10596                 type = integer_type_node;
10597               }
10598             if (TREE_CODE (type) == ARRAY_TYPE)
10599               {
10600                 error ("`%s' declared as function returning an array", name);
10601                 type = integer_type_node;
10602               }
10603
10604             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10605               inner_decl = TREE_OPERAND (inner_decl, 1);
10606
10607             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10608               inner_decl = dname;
10609
10610             /* Pick up type qualifiers which should be applied to `this'.  */
10611             quals = CALL_DECLARATOR_QUALS (declarator);
10612
10613             /* Pick up the exception specifications.  */
10614             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10615
10616             /* Say it's a definition only for the CALL_EXPR
10617                closest to the identifier.  */
10618             funcdecl_p
10619               = inner_decl
10620               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10621                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10622                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10623
10624             if (ctype == NULL_TREE
10625                 && decl_context == FIELD
10626                 && funcdecl_p
10627                 && (friendp == 0 || dname == current_class_name))
10628               ctype = current_class_type;
10629
10630             if (ctype && sfk == sfk_conversion)
10631               TYPE_HAS_CONVERSION (ctype) = 1;
10632             if (ctype && constructor_name (ctype) == dname)
10633               {
10634                 /* We are within a class's scope. If our declarator name
10635                    is the same as the class name, and we are defining
10636                    a function, then it is a constructor/destructor, and
10637                    therefore returns a void type.  */
10638
10639                 if (flags == DTOR_FLAG)
10640                   {
10641                     /* ISO C++ 12.4/2.  A destructor may not be
10642                        declared const or volatile.  A destructor may
10643                        not be static.  */
10644                     if (staticp == 2)
10645                       error ("destructor cannot be static member function");
10646                     if (quals)
10647                       {
10648                         cp_error ("destructors may not be `%s'",
10649                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10650                         quals = NULL_TREE;
10651                       }
10652                     if (decl_context == FIELD)
10653                       {
10654                         if (! member_function_or_else (ctype,
10655                                                        current_class_type,
10656                                                        flags))
10657                           return void_type_node;
10658                       }
10659                   }
10660                 else            /* It's a constructor.  */
10661                   {
10662                     if (explicitp == 1)
10663                       explicitp = 2;
10664                     /* ISO C++ 12.1.  A constructor may not be
10665                        declared const or volatile.  A constructor may
10666                        not be virtual.  A constructor may not be
10667                        static.  */
10668                     if (staticp == 2)
10669                       error ("constructor cannot be static member function");
10670                     if (virtualp)
10671                       {
10672                         pedwarn ("constructors cannot be declared virtual");
10673                         virtualp = 0;
10674                       }
10675                     if (quals)
10676                       {
10677                         cp_error ("constructors may not be `%s'",
10678                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10679                         quals = NULL_TREE;
10680                       }
10681                     {
10682                       RID_BIT_TYPE tmp_bits;
10683                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10684                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10685                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10686                       if (RIDBIT_ANY_SET (tmp_bits))
10687                         error ("return value type specifier for constructor ignored");
10688                     }
10689                     if (decl_context == FIELD)
10690                       {
10691                         if (! member_function_or_else (ctype,
10692                                                        current_class_type,
10693                                                        flags))
10694                           return void_type_node;
10695                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10696                         if (sfk != sfk_constructor)
10697                           return NULL_TREE;
10698                       }
10699                   }
10700                 if (decl_context == FIELD)
10701                   staticp = 0;
10702               }
10703             else if (friendp)
10704               {
10705                 if (initialized)
10706                   error ("can't initialize friend function `%s'", name);
10707                 if (virtualp)
10708                   {
10709                     /* Cannot be both friend and virtual.  */
10710                     error ("virtual functions cannot be friends");
10711                     RIDBIT_RESET (RID_FRIEND, specbits);
10712                     friendp = 0;
10713                   }
10714                 if (decl_context == NORMAL)
10715                   error ("friend declaration not in class definition");
10716                 if (current_function_decl && funcdef_flag)
10717                   cp_error ("can't define friend function `%s' in a local class definition",
10718                             name);
10719               }
10720
10721             /* Construct the function type and go to the next
10722                inner layer of declarator.  */
10723
10724             declarator = TREE_OPERAND (declarator, 0);
10725
10726             /* FIXME: This is where default args should be fully
10727                processed.  */
10728
10729             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10730
10731             if (declarator && flags == DTOR_FLAG)
10732               {
10733                 /* A destructor declared in the body of a class will
10734                    be represented as a BIT_NOT_EXPR.  But, we just
10735                    want the underlying IDENTIFIER.  */
10736                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10737                   declarator = TREE_OPERAND (declarator, 0);
10738
10739                 if (arg_types != void_list_node)
10740                   {
10741                     cp_error ("destructors may not have parameters");
10742                     arg_types = void_list_node;
10743                     last_function_parms = NULL_TREE;
10744                   }
10745               }
10746
10747             /* ANSI says that `const int foo ();'
10748                does not make the function foo const.  */
10749             type = build_function_type (type, arg_types);
10750
10751             {
10752               tree t;
10753               for (t = arg_types; t; t = TREE_CHAIN (t))
10754                 if (TREE_PURPOSE (t)
10755                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10756                   {
10757                     add_defarg_fn (type);
10758                     break;
10759                   }
10760             }
10761           }
10762           break;
10763
10764         case ADDR_EXPR:
10765         case INDIRECT_REF:
10766           /* Filter out pointers-to-references and references-to-references.
10767              We can get these if a TYPE_DECL is used.  */
10768
10769           if (TREE_CODE (type) == REFERENCE_TYPE)
10770             {
10771               error ("cannot declare %s to references",
10772                      TREE_CODE (declarator) == ADDR_EXPR
10773                      ? "references" : "pointers");
10774               declarator = TREE_OPERAND (declarator, 0);
10775               continue;
10776             }
10777
10778           if (TREE_CODE (type) == OFFSET_TYPE
10779               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10780                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10781             {
10782               cp_error ("cannot declare pointer to `%#T' member",
10783                         TREE_TYPE (type));
10784               type = TREE_TYPE (type);
10785             }
10786
10787           /* Merge any constancy or volatility into the target type
10788              for the pointer.  */
10789
10790           /* We now know that the TYPE_QUALS don't apply to the decl,
10791              but to the target of the pointer.  */
10792           type_quals = TYPE_UNQUALIFIED;
10793
10794           if (TREE_CODE (declarator) == ADDR_EXPR)
10795             {
10796               if (TREE_CODE (type) == VOID_TYPE)
10797                 error ("invalid type: `void &'");
10798               else
10799                 type = build_reference_type (type);
10800             }
10801           else if (TREE_CODE (type) == METHOD_TYPE)
10802             type = build_ptrmemfunc_type (build_pointer_type (type));
10803           else
10804             type = build_pointer_type (type);
10805
10806           /* Process a list of type modifier keywords (such as
10807              const or volatile) that were given inside the `*' or `&'.  */
10808
10809           if (TREE_TYPE (declarator))
10810             {
10811               register tree typemodlist;
10812               int erred = 0;
10813
10814               constp = 0;
10815               volatilep = 0;
10816               restrictp = 0;
10817               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10818                    typemodlist = TREE_CHAIN (typemodlist))
10819                 {
10820                   tree qualifier = TREE_VALUE (typemodlist);
10821
10822                   if (qualifier == ridpointers[(int) RID_CONST])
10823                     constp++;
10824                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10825                     volatilep++;
10826                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10827                     restrictp++;
10828                   else if (!erred)
10829                     {
10830                       erred = 1;
10831                       error ("invalid type modifier within pointer declarator");
10832                     }
10833                 }
10834               if (constp > 1)
10835                 pedwarn ("duplicate `const'");
10836               if (volatilep > 1)
10837                 pedwarn ("duplicate `volatile'");
10838               if (restrictp > 1)
10839                 pedwarn ("duplicate `restrict'");
10840
10841               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10842                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10843                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10844               if (TREE_CODE (declarator) == ADDR_EXPR
10845                   && (constp || volatilep))
10846                 {
10847                   if (constp)
10848                     pedwarn ("discarding `const' applied to a reference");
10849                   if (volatilep)
10850                     pedwarn ("discarding `volatile' applied to a reference");
10851                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10852                 }
10853               type = cp_build_qualified_type (type, type_quals);
10854             }
10855           declarator = TREE_OPERAND (declarator, 0);
10856           ctype = NULL_TREE;
10857           break;
10858
10859         case SCOPE_REF:
10860           {
10861             /* We have converted type names to NULL_TREE if the
10862                name was bogus, or to a _TYPE node, if not.
10863
10864                The variable CTYPE holds the type we will ultimately
10865                resolve to.  The code here just needs to build
10866                up appropriate member types.  */
10867             tree sname = TREE_OPERAND (declarator, 1);
10868             tree t;
10869
10870             /* Destructors can have their visibilities changed as well.  */
10871             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10872               sname = TREE_OPERAND (sname, 0);
10873
10874             if (TREE_COMPLEXITY (declarator) == 0)
10875               /* This needs to be here, in case we are called
10876                  multiple times.  */ ;
10877             else if (TREE_COMPLEXITY (declarator) == -1)
10878               /* Namespace member. */
10879               pop_decl_namespace ();
10880             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10881               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10882             else if (! IS_AGGR_TYPE_CODE
10883                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10884               ;
10885             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10886               {
10887                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10888                    that refer to ctype.  They couldn't be resolved earlier
10889                    because we hadn't pushed into the class yet.
10890                    Example: resolve 'B<T>::type' in
10891                    'B<typename B<T>::type> B<T>::f () { }'.  */
10892                 if (current_template_parms
10893                     && uses_template_parms (type)
10894                     && uses_template_parms (current_class_type))
10895                   {
10896                     tree args = current_template_args ();
10897                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10898                   }
10899
10900                 /* This pop_nested_class corresponds to the
10901                    push_nested_class used to push into class scope for
10902                    parsing the argument list of a function decl, in
10903                    qualified_id.  */
10904                 pop_nested_class ();
10905                 TREE_COMPLEXITY (declarator) = current_class_depth;
10906               }
10907             else
10908               my_friendly_abort (16);
10909
10910             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10911               {
10912                 /* We had a reference to a global decl, or
10913                    perhaps we were given a non-aggregate typedef,
10914                    in which case we cleared this out, and should just
10915                    keep going as though it wasn't there.  */
10916                 declarator = sname;
10917                 continue;
10918               }
10919             ctype = TREE_OPERAND (declarator, 0);
10920
10921             t = ctype;
10922             while (t != NULL_TREE && CLASS_TYPE_P (t))
10923               {
10924                 /* You're supposed to have one `template <...>'
10925                    for every template class, but you don't need one
10926                    for a full specialization.  For example:
10927
10928                      template <class T> struct S{};
10929                      template <> struct S<int> { void f(); };
10930                      void S<int>::f () {}
10931
10932                    is correct; there shouldn't be a `template <>' for
10933                    the definition of `S<int>::f'.  */
10934                 if (CLASSTYPE_TEMPLATE_INFO (t)
10935                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10936                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10937                   template_count += 1;
10938
10939                 t = TYPE_MAIN_DECL (t);
10940                 if (DECL_LANG_SPECIFIC (t))
10941                   t = DECL_CONTEXT (t);
10942                 else
10943                   t = NULL_TREE;
10944               }
10945
10946             if (sname == NULL_TREE)
10947               goto done_scoping;
10948
10949             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10950               {
10951                 /* This is the `standard' use of the scoping operator:
10952                    basetype :: member .  */
10953
10954                 if (ctype == current_class_type)
10955                   {
10956                     /* class A {
10957                          void A::f ();
10958                        };
10959
10960                        Is this ill-formed?  */
10961
10962                     if (pedantic)
10963                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10964                                   ctype, name);
10965                   }
10966                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10967                   {
10968                     if (current_class_type == NULL_TREE
10969                         || friendp)
10970                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10971                                                       TYPE_ARG_TYPES (type));
10972                     else
10973                       {
10974                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10975                                   ctype, name, current_class_type);
10976                         return void_type_node;
10977                       }
10978                   }
10979                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10980                          || COMPLETE_TYPE_P (complete_type (ctype)))
10981                   {
10982                     /* Have to move this code elsewhere in this function.
10983                        this code is used for i.e., typedef int A::M; M *pm;
10984
10985                        It is?  How? jason 10/2/94 */
10986
10987                     if (current_class_type)
10988                       {
10989                         cp_error ("cannot declare member `%T::%s' within `%T'",
10990                                   ctype, name, current_class_type);
10991                         return void_type_node;
10992                       }
10993                     type = build_offset_type (ctype, type);
10994                   }
10995                 else if (uses_template_parms (ctype))
10996                   {
10997                     if (TREE_CODE (type) == FUNCTION_TYPE)
10998                       type
10999                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11000                                                    TYPE_ARG_TYPES (type));
11001                   }
11002                 else
11003                   {
11004                     cp_error ("structure `%T' not yet defined", ctype);
11005                     return error_mark_node;
11006                   }
11007
11008                 declarator = sname;
11009               }
11010             else if (TREE_CODE (sname) == SCOPE_REF)
11011               my_friendly_abort (17);
11012             else
11013               {
11014               done_scoping:
11015                 declarator = TREE_OPERAND (declarator, 1);
11016                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11017                   /* In this case, we will deal with it later.  */
11018                   ;
11019                 else
11020                   {
11021                     if (TREE_CODE (type) == FUNCTION_TYPE)
11022                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11023                                                       TYPE_ARG_TYPES (type));
11024                     else
11025                       type = build_offset_type (ctype, type);
11026                   }
11027               }
11028           }
11029           break;
11030
11031         case BIT_NOT_EXPR:
11032           declarator = TREE_OPERAND (declarator, 0);
11033           break;
11034
11035         case RECORD_TYPE:
11036         case UNION_TYPE:
11037         case ENUMERAL_TYPE:
11038           declarator = NULL_TREE;
11039           break;
11040
11041         case ERROR_MARK:
11042           declarator = NULL_TREE;
11043           break;
11044
11045         default:
11046           my_friendly_abort (158);
11047         }
11048     }
11049
11050   /* See the comment for the TREE_LIST case, above.  */
11051   if (inner_attrs)
11052     {
11053       if (! ignore_attrs)
11054         decl_attributes (type, inner_attrs, NULL_TREE);
11055       else if (attrlist)
11056         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11057       else
11058         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11059     }
11060
11061   /* Now TYPE has the actual type.  */
11062
11063   if (explicitp == 1 || (explicitp && friendp))
11064     {
11065       /* [dcl.fct.spec] The explicit specifier shall only be used in
11066          declarations of constructors within a class definition.  */
11067       error ("only declarations of constructors can be `explicit'");
11068       explicitp = 0;
11069     }
11070
11071   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11072     {
11073       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11074         {
11075           error ("non-member `%s' cannot be declared `mutable'", name);
11076           RIDBIT_RESET (RID_MUTABLE, specbits);
11077         }
11078       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11079         {
11080           error ("non-object member `%s' cannot be declared `mutable'", name);
11081           RIDBIT_RESET (RID_MUTABLE, specbits);
11082         }
11083       else if (TREE_CODE (type) == FUNCTION_TYPE
11084                || TREE_CODE (type) == METHOD_TYPE)
11085         {
11086           error ("function `%s' cannot be declared `mutable'", name);
11087           RIDBIT_RESET (RID_MUTABLE, specbits);
11088         }
11089       else if (staticp)
11090         {
11091           error ("static `%s' cannot be declared `mutable'", name);
11092           RIDBIT_RESET (RID_MUTABLE, specbits);
11093         }
11094       else if (type_quals & TYPE_QUAL_CONST)
11095         {
11096           error ("const `%s' cannot be declared `mutable'", name);
11097           RIDBIT_RESET (RID_MUTABLE, specbits);
11098         }
11099     }
11100
11101   if (declarator == NULL_TREE
11102       || TREE_CODE (declarator) == IDENTIFIER_NODE
11103       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11104           && (TREE_CODE (type) == FUNCTION_TYPE
11105               || TREE_CODE (type) == METHOD_TYPE)))
11106     /* OK */;
11107   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11108     {
11109       cp_error ("template-id `%D' used as a declarator", declarator);
11110       declarator = dname;
11111     }
11112   else
11113     /* Unexpected declarator format.  */
11114     my_friendly_abort (990210);
11115
11116   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11117
11118   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11119     {
11120       tree decl;
11121
11122       /* Note that the grammar rejects storage classes
11123          in typenames, fields or parameters.  */
11124       if (current_lang_name == lang_name_java)
11125         TYPE_FOR_JAVA (type) = 1;
11126
11127       if (decl_context == FIELD)
11128         {
11129           if (declarator == constructor_name (current_class_type))
11130             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11131                         declarator);
11132           decl = build_lang_decl (TYPE_DECL, declarator, type);
11133         }
11134       else
11135         decl = build_decl (TYPE_DECL, declarator, type);
11136
11137       /* If the user declares "typedef struct {...} foo" then the
11138          struct will have an anonymous name.  Fill that name in now.
11139          Nothing can refer to it, so nothing needs know about the name
11140          change.  */
11141       if (type != error_mark_node
11142           && declarator
11143           && TYPE_NAME (type)
11144           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11145           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11146           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11147         {
11148           tree oldname = TYPE_NAME (type);
11149           tree t;
11150
11151           /* Replace the anonymous name with the real name everywhere.  */
11152           lookup_tag_reverse (type, declarator);
11153           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11154             if (TYPE_NAME (t) == oldname)
11155               TYPE_NAME (t) = decl;
11156
11157           if (TYPE_LANG_SPECIFIC (type))
11158             TYPE_WAS_ANONYMOUS (type) = 1;
11159
11160           /* If this is a typedef within a template class, the nested
11161              type is a (non-primary) template.  The name for the
11162              template needs updating as well.  */
11163           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11164             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11165               = TYPE_IDENTIFIER (type);
11166
11167           if (flag_new_abi)
11168             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11169           else
11170             {
11171               /* XXX Temporarily set the scope.
11172                  When returning, start_decl expects it as NULL_TREE,
11173                  and will then then set it using pushdecl. */
11174               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11175               if (current_class_type)
11176                 DECL_CONTEXT (decl) = current_class_type;
11177               else
11178                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11179
11180               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11181               DECL_ASSEMBLER_NAME (decl)
11182                 = get_identifier (build_overload_name (type, 1, 1));
11183               DECL_CONTEXT (decl) = NULL_TREE;
11184             }
11185
11186           /* FIXME remangle member functions; member functions of a
11187              type with external linkage have external linkage.  */
11188         }
11189
11190       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11191         {
11192           cp_error_at ("typedef name may not be class-qualified", decl);
11193           return NULL_TREE;
11194         }
11195       else if (quals)
11196         {
11197           if (ctype == NULL_TREE)
11198             {
11199               if (TREE_CODE (type) != METHOD_TYPE)
11200                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11201               else
11202                 ctype = TYPE_METHOD_BASETYPE (type);
11203             }
11204           if (ctype != NULL_TREE)
11205             grok_method_quals (ctype, decl, quals);
11206         }
11207
11208       if (RIDBIT_SETP (RID_SIGNED, specbits)
11209           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11210         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11211
11212       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11213                       inlinep, friendp, raises != NULL_TREE);
11214
11215       if (initialized)
11216         error ("typedef declaration includes an initializer");
11217
11218       return decl;
11219     }
11220
11221   /* Detect the case of an array type of unspecified size
11222      which came, as such, direct from a typedef name.
11223      We must copy the type, so that each identifier gets
11224      a distinct type, so that each identifier's size can be
11225      controlled separately by its own initializer.  */
11226
11227   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11228       && TYPE_DOMAIN (type) == NULL_TREE)
11229     {
11230       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11231     }
11232
11233   /* If this is a type name (such as, in a cast or sizeof),
11234      compute the type and return it now.  */
11235
11236   if (decl_context == TYPENAME)
11237     {
11238       /* Note that the grammar rejects storage classes
11239          in typenames, fields or parameters.  */
11240       if (type_quals != TYPE_UNQUALIFIED)
11241         type_quals = TYPE_UNQUALIFIED;
11242
11243       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11244       if (friendp)
11245         {
11246           if (type_quals != TYPE_UNQUALIFIED)
11247             {
11248               cp_error ("type qualifiers specified for friend class declaration");
11249               type_quals = TYPE_UNQUALIFIED;
11250             }
11251           if (inlinep)
11252             {
11253               cp_error ("`inline' specified for friend class declaration");
11254               inlinep = 0;
11255             }
11256           if (!current_aggr && TREE_CODE (type) != TYPENAME_TYPE)
11257             {
11258               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11259                 cp_error ("template parameters cannot be friends");
11260               else
11261                 cp_error ("friend declaration requires `%#T'", type);
11262             }
11263
11264           /* Only try to do this stuff if we didn't already give up.  */
11265           if (type != integer_type_node)
11266             {
11267               /* A friendly class?  */
11268               if (current_class_type)
11269                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11270               else
11271                 cp_error ("trying to make class `%T' a friend of global scope",
11272                           type);
11273               type = void_type_node;
11274             }
11275         }
11276       else if (quals)
11277         {
11278           if (ctype == NULL_TREE)
11279             {
11280               if (TREE_CODE (type) != METHOD_TYPE)
11281                 cp_error ("invalid qualifiers on non-member function type");
11282               else
11283                 ctype = TYPE_METHOD_BASETYPE (type);
11284             }
11285           if (ctype)
11286             {
11287               tree dummy = build_decl (TYPE_DECL, declarator, type);
11288               grok_method_quals (ctype, dummy, quals);
11289               type = TREE_TYPE (dummy);
11290             }
11291         }
11292
11293       return type;
11294     }
11295   else if (declarator == NULL_TREE && decl_context != PARM
11296            && decl_context != CATCHPARM
11297            && TREE_CODE (type) != UNION_TYPE
11298            && ! bitfield)
11299     {
11300       cp_error ("abstract declarator `%T' used as declaration", type);
11301       declarator = make_anon_name ();
11302     }
11303
11304   /* `void' at top level (not within pointer)
11305      is allowed only in typedefs or type names.
11306      We don't complain about parms either, but that is because
11307      a better error message can be made later.  */
11308
11309   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11310     {
11311       if (! declarator)
11312         error ("unnamed variable or field declared void");
11313       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11314         {
11315           if (IDENTIFIER_OPNAME_P (declarator))
11316             my_friendly_abort (356);
11317           else
11318             error ("variable or field `%s' declared void", name);
11319         }
11320       else
11321         error ("variable or field declared void");
11322       type = integer_type_node;
11323     }
11324
11325   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11326      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11327
11328   if (decl_context == PARM || decl_context == CATCHPARM)
11329     {
11330       if (ctype || in_namespace)
11331         error ("cannot use `::' in parameter declaration");
11332
11333       /* A parameter declared as an array of T is really a pointer to T.
11334          One declared as a function is really a pointer to a function.
11335          One declared as a member is really a pointer to member.  */
11336
11337       if (TREE_CODE (type) == ARRAY_TYPE)
11338         {
11339           /* Transfer const-ness of array into that of type pointed to.  */
11340           type = build_pointer_type (TREE_TYPE (type));
11341           type_quals = TYPE_UNQUALIFIED;
11342         }
11343       else if (TREE_CODE (type) == FUNCTION_TYPE)
11344         type = build_pointer_type (type);
11345       else if (TREE_CODE (type) == OFFSET_TYPE)
11346         type = build_pointer_type (type);
11347       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11348         {
11349           error ("declaration of `%s' as void", name);
11350           return NULL_TREE;
11351         }
11352     }
11353
11354   {
11355     register tree decl;
11356
11357     if (decl_context == PARM)
11358       {
11359         decl = build_decl (PARM_DECL, declarator, type);
11360
11361         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11362                         inlinep, friendp, raises != NULL_TREE);
11363
11364         /* Compute the type actually passed in the parmlist,
11365            for the case where there is no prototype.
11366            (For example, shorts and chars are passed as ints.)
11367            When there is a prototype, this is overridden later.  */
11368
11369         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11370       }
11371     else if (decl_context == FIELD)
11372       {
11373         if (type == error_mark_node)
11374           {
11375             /* Happens when declaring arrays of sizes which
11376                are error_mark_node, for example.  */
11377             decl = NULL_TREE;
11378           }
11379         else if (in_namespace && !friendp)
11380           {
11381             /* Something like struct S { int N::j; };  */
11382             cp_error ("invalid use of `::'");
11383             decl = NULL_TREE;
11384           }
11385         else if (TREE_CODE (type) == FUNCTION_TYPE)
11386           {
11387             int publicp = 0;
11388             tree function_context;
11389
11390             /* We catch the others as conflicts with the builtin
11391                typedefs.  */
11392             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11393               {
11394                 cp_error ("function `%D' cannot be declared friend",
11395                           declarator);
11396                 friendp = 0;
11397               }
11398
11399             if (friendp == 0)
11400               {
11401                 if (ctype == NULL_TREE)
11402                   ctype = current_class_type;
11403
11404                 if (ctype == NULL_TREE)
11405                   {
11406                     cp_error ("can't make `%D' into a method -- not in a class",
11407                               declarator);
11408                     return void_type_node;
11409                   }
11410
11411                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11412                    ARM 9.5 */
11413                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11414                   {
11415                     cp_error ("function `%D' declared virtual inside a union",
11416                               declarator);
11417                     return void_type_node;
11418                   }
11419
11420                 if (declarator == ansi_opname (NEW_EXPR)
11421                     || declarator == ansi_opname (VEC_NEW_EXPR)
11422                     || declarator == ansi_opname (DELETE_EXPR)
11423                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11424                   {
11425                     if (virtualp)
11426                       {
11427                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11428                                   declarator);
11429                         virtualp = 0;
11430                       }
11431                   }
11432                 else if (staticp < 2)
11433                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11434                                                   TYPE_ARG_TYPES (type));
11435               }
11436
11437             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11438             function_context = (ctype != NULL_TREE) ?
11439               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11440             publicp = (! friendp || ! staticp)
11441               && function_context == NULL_TREE;
11442             decl = grokfndecl (ctype, type,
11443                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11444                                ? declarator : dname,
11445                                declarator,
11446                                virtualp, flags, quals, raises,
11447                                friendp ? -1 : 0, friendp, publicp, inlinep,
11448                                funcdef_flag, template_count, in_namespace);
11449             if (decl == NULL_TREE)
11450               return decl;
11451 #if 0
11452             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11453             /* The decl and setting of decl_machine_attr is also turned off.  */
11454             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11455 #endif
11456
11457             /* [class.conv.ctor]
11458
11459                A constructor declared without the function-specifier
11460                explicit that can be called with a single parameter
11461                specifies a conversion from the type of its first
11462                parameter to the type of its class.  Such a constructor
11463                is called a converting constructor.  */
11464             if (explicitp == 2)
11465               DECL_NONCONVERTING_P (decl) = 1;
11466             else if (DECL_CONSTRUCTOR_P (decl))
11467               {
11468                 /* The constructor can be called with exactly one
11469                    parameter if there is at least one parameter, and
11470                    any subsequent parameters have default arguments.
11471                    We don't look at the first parameter, which is
11472                    really just the `this' parameter for the new
11473                    object.  */
11474                 tree arg_types =
11475                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11476
11477                 /* Skip the `in_chrg' argument too, if present.  */
11478                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11479                   arg_types = TREE_CHAIN (arg_types);
11480
11481                 if (arg_types == void_list_node
11482                     || (arg_types
11483                         && TREE_CHAIN (arg_types)
11484                         && TREE_CHAIN (arg_types) != void_list_node
11485                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11486                   DECL_NONCONVERTING_P (decl) = 1;
11487               }
11488           }
11489         else if (TREE_CODE (type) == METHOD_TYPE)
11490           {
11491             /* We only get here for friend declarations of
11492                members of other classes.  */
11493             /* All method decls are public, so tell grokfndecl to set
11494                TREE_PUBLIC, also.  */
11495             decl = grokfndecl (ctype, type, declarator, declarator,
11496                                virtualp, flags, quals, raises,
11497                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11498                                template_count, in_namespace);
11499             if (decl == NULL_TREE)
11500               return NULL_TREE;
11501           }
11502         else if (!staticp && ! processing_template_decl
11503                  && !COMPLETE_TYPE_P (complete_type (type))
11504                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11505           {
11506             if (declarator)
11507               cp_error ("field `%D' has incomplete type", declarator);
11508             else
11509               cp_error ("name `%T' has incomplete type", type);
11510
11511             /* If we're instantiating a template, tell them which
11512                instantiation made the field's type be incomplete.  */
11513             if (current_class_type
11514                 && TYPE_NAME (current_class_type)
11515                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11516                 && declspecs && TREE_VALUE (declspecs)
11517                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11518               cp_error ("  in instantiation of template `%T'",
11519                         current_class_type);
11520
11521             type = error_mark_node;
11522             decl = NULL_TREE;
11523           }
11524         else
11525           {
11526             if (friendp)
11527               {
11528                 error ("`%s' is neither function nor member function; cannot be declared friend",
11529                        IDENTIFIER_POINTER (declarator));
11530                 friendp = 0;
11531               }
11532             decl = NULL_TREE;
11533           }
11534
11535         if (friendp)
11536           {
11537             /* Friends are treated specially.  */
11538             if (ctype == current_class_type)
11539               warning ("member functions are implicitly friends of their class");
11540             else
11541               {
11542                 tree t = NULL_TREE;
11543                 if (decl && DECL_NAME (decl))
11544                   {
11545                     if (template_class_depth (current_class_type) == 0)
11546                       {
11547                         decl
11548                           = check_explicit_specialization
11549                           (declarator, decl,
11550                            template_count, 2 * (funcdef_flag != 0) + 4);
11551                         if (decl == error_mark_node)
11552                           return error_mark_node;
11553                       }
11554
11555                     t = do_friend (ctype, declarator, decl,
11556                                    last_function_parms, attrlist, flags, quals,
11557                                    funcdef_flag);
11558                   }
11559                 if (t && funcdef_flag)
11560                   return t;
11561
11562                 return void_type_node;
11563               }
11564           }
11565
11566         /* Structure field.  It may not be a function, except for C++ */
11567
11568         if (decl == NULL_TREE)
11569           {
11570             if (initialized)
11571               {
11572                 if (!staticp)
11573                   {
11574                     /* An attempt is being made to initialize a non-static
11575                        member.  But, from [class.mem]:
11576
11577                        4 A member-declarator can contain a
11578                        constant-initializer only if it declares a static
11579                        member (_class.static_) of integral or enumeration
11580                        type, see _class.static.data_.
11581
11582                        This used to be relatively common practice, but
11583                        the rest of the compiler does not correctly
11584                        handle the initialization unless the member is
11585                        static so we make it static below.  */
11586                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11587                                 declarator);
11588                     cp_pedwarn ("making `%D' static", declarator);
11589                     staticp = 1;
11590                   }
11591
11592                 if (uses_template_parms (type))
11593                   /* We'll check at instantiation time.  */
11594                   ;
11595                 else if (check_static_variable_definition (declarator,
11596                                                            type))
11597                   /* If we just return the declaration, crashes
11598                      will sometimes occur.  We therefore return
11599                      void_type_node, as if this was a friend
11600                      declaration, to cause callers to completely
11601                      ignore this declaration.  */
11602                   return void_type_node;
11603               }
11604
11605             /* 9.2p13 [class.mem] */
11606             if (declarator == constructor_name (current_class_type)
11607                 /* The standard does not allow non-static data members
11608                    here either, but we agreed at the 10/99 meeting
11609                    to change that in TC 1 so that they are allowed in
11610                    classes with no user-defined constructors.  */
11611                 && staticp)
11612               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11613                           declarator);
11614
11615             if (staticp)
11616               {
11617                 /* C++ allows static class members.  All other work
11618                    for this is done by grokfield.  */
11619                 decl = build_lang_decl (VAR_DECL, declarator, type);
11620                 TREE_STATIC (decl) = 1;
11621                 /* In class context, 'static' means public access.  */
11622                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11623               }
11624             else
11625               {
11626                 decl = build_decl (FIELD_DECL, declarator, type);
11627                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11628                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11629                   {
11630                     DECL_MUTABLE_P (decl) = 1;
11631                     RIDBIT_RESET (RID_MUTABLE, specbits);
11632                   }
11633               }
11634
11635             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11636                             inlinep, friendp, raises != NULL_TREE);
11637           }
11638       }
11639     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11640       {
11641         tree original_name;
11642         int publicp = 0;
11643
11644         if (! declarator)
11645           return NULL_TREE;
11646
11647         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11648           original_name = dname;
11649         else
11650           original_name = declarator;
11651
11652         if (RIDBIT_SETP (RID_AUTO, specbits))
11653           error ("storage class `auto' invalid for function `%s'", name);
11654         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11655           error ("storage class `register' invalid for function `%s'", name);
11656
11657         /* Function declaration not at top level.
11658            Storage classes other than `extern' are not allowed
11659            and `extern' makes no difference.  */
11660         if (! toplevel_bindings_p ()
11661             && (RIDBIT_SETP (RID_STATIC, specbits)
11662                 || RIDBIT_SETP (RID_INLINE, specbits))
11663             && pedantic)
11664           {
11665             if (RIDBIT_SETP (RID_STATIC, specbits))
11666               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11667             else
11668               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11669           }
11670
11671         if (ctype == NULL_TREE)
11672           {
11673             if (virtualp)
11674               {
11675                 error ("virtual non-class function `%s'", name);
11676                 virtualp = 0;
11677               }
11678           }
11679         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11680           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11681                                           TYPE_ARG_TYPES (type));
11682
11683         /* Record presence of `static'.  */
11684         publicp = (ctype != NULL_TREE
11685                    || RIDBIT_SETP (RID_EXTERN, specbits)
11686                    || !RIDBIT_SETP (RID_STATIC, specbits));
11687
11688         decl = grokfndecl (ctype, type, original_name, declarator,
11689                            virtualp, flags, quals, raises,
11690                            1, friendp,
11691                            publicp, inlinep, funcdef_flag,
11692                            template_count, in_namespace);
11693         if (decl == NULL_TREE)
11694           return NULL_TREE;
11695
11696         if (staticp == 1)
11697           {
11698             int illegal_static = 0;
11699
11700             /* Don't allow a static member function in a class, and forbid
11701                declaring main to be static.  */
11702             if (TREE_CODE (type) == METHOD_TYPE)
11703               {
11704                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11705                 illegal_static = 1;
11706               }
11707             else if (current_function_decl)
11708               {
11709                 /* FIXME need arm citation */
11710                 error ("cannot declare static function inside another function");
11711                 illegal_static = 1;
11712               }
11713
11714             if (illegal_static)
11715               {
11716                 staticp = 0;
11717                 RIDBIT_RESET (RID_STATIC, specbits);
11718               }
11719           }
11720       }
11721     else
11722       {
11723         /* It's a variable.  */
11724
11725         /* An uninitialized decl with `extern' is a reference.  */
11726         decl = grokvardecl (type, declarator, &specbits,
11727                             initialized,
11728                             (type_quals & TYPE_QUAL_CONST) != 0,
11729                             in_namespace);
11730         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11731                         inlinep, friendp, raises != NULL_TREE);
11732
11733         if (ctype)
11734           {
11735             DECL_CONTEXT (decl) = ctype;
11736             if (staticp == 1)
11737               {
11738                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11739                 staticp = 0;
11740                 RIDBIT_RESET (RID_STATIC, specbits);
11741               }
11742             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11743               {
11744                 cp_error ("static member `%D' declared `register'", decl);
11745                 RIDBIT_RESET (RID_REGISTER, specbits);
11746               }
11747             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11748               {
11749                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11750                             decl);
11751                 RIDBIT_RESET (RID_EXTERN, specbits);
11752               }
11753           }
11754       }
11755
11756     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11757
11758     /* Record `register' declaration for warnings on &
11759        and in case doing stupid register allocation.  */
11760
11761     if (RIDBIT_SETP (RID_REGISTER, specbits))
11762       DECL_REGISTER (decl) = 1;
11763
11764     if (RIDBIT_SETP (RID_EXTERN, specbits))
11765       DECL_THIS_EXTERN (decl) = 1;
11766
11767     if (RIDBIT_SETP (RID_STATIC, specbits))
11768       DECL_THIS_STATIC (decl) = 1;
11769
11770     /* Record constancy and volatility.  There's no need to do this
11771        when processing a template; we'll do this for the instantiated
11772        declaration based on the type of DECL.  */
11773     if (!processing_template_decl)
11774       c_apply_type_quals_to_decl (type_quals, decl);
11775
11776     return decl;
11777   }
11778 }
11779 \f
11780 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11781    An empty exprlist is a parmlist.  An exprlist which
11782    contains only identifiers at the global level
11783    is a parmlist.  Otherwise, it is an exprlist.  */
11784
11785 int
11786 parmlist_is_exprlist (exprs)
11787      tree exprs;
11788 {
11789   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11790     return 0;
11791
11792   if (toplevel_bindings_p ())
11793     {
11794       /* At the global level, if these are all identifiers,
11795          then it is a parmlist.  */
11796       while (exprs)
11797         {
11798           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11799             return 1;
11800           exprs = TREE_CHAIN (exprs);
11801         }
11802       return 0;
11803     }
11804   return 1;
11805 }
11806
11807 /* Subroutine of start_function.  Ensure that each of the parameter
11808    types (as listed in PARMS) is complete, as is required for a
11809    function definition.  */
11810
11811 static void
11812 require_complete_types_for_parms (parms)
11813      tree parms;
11814 {
11815   for (; parms; parms = TREE_CHAIN (parms))
11816     {
11817       tree type = TREE_TYPE (parms);
11818
11819       /* Try to complete the TYPE.  */
11820       type = complete_type (type);
11821
11822       if (type == error_mark_node)
11823         continue;
11824
11825       if (!COMPLETE_TYPE_P (type))
11826         {
11827           if (DECL_NAME (parms))
11828             error ("parameter `%s' has incomplete type",
11829                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11830           else
11831             error ("parameter has incomplete type");
11832           TREE_TYPE (parms) = error_mark_node;
11833         }
11834       else
11835         layout_decl (parms, 0);
11836     }
11837 }
11838
11839 /* Returns non-zero if T is a local variable.  */
11840
11841 int
11842 local_variable_p (t)
11843      tree t;
11844 {
11845   if ((TREE_CODE (t) == VAR_DECL
11846        /* A VAR_DECL with a context that is a _TYPE is a static data
11847           member.  */
11848        && !TYPE_P (CP_DECL_CONTEXT (t))
11849        /* Any other non-local variable must be at namespace scope.  */
11850        && !DECL_NAMESPACE_SCOPE_P (t))
11851       || (TREE_CODE (t) == PARM_DECL))
11852     return 1;
11853
11854   return 0;
11855 }
11856
11857 /* Returns non-zero if T is an automatic local variable or a label.
11858    (These are the declarations that need to be remapped when the code
11859    containing them is duplicated.)  */
11860
11861 int
11862 nonstatic_local_decl_p (t)
11863      tree t;
11864 {
11865   return ((local_variable_p (t) && !TREE_STATIC (t))
11866           || TREE_CODE (t) == LABEL_DECL
11867           || TREE_CODE (t) == RESULT_DECL);
11868 }
11869
11870 /* Like local_variable_p, but suitable for use as a tree-walking
11871    function.  */
11872
11873 static tree
11874 local_variable_p_walkfn (tp, walk_subtrees, data)
11875      tree *tp;
11876      int *walk_subtrees ATTRIBUTE_UNUSED;
11877      void *data ATTRIBUTE_UNUSED;
11878 {
11879   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11880           ? *tp : NULL_TREE);
11881 }
11882
11883 /* Check that ARG, which is a default-argument expression for a
11884    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11885    something goes wrong.  DECL may also be a _TYPE node, rather than a
11886    DECL, if there is no DECL available.  */
11887
11888 tree
11889 check_default_argument (decl, arg)
11890      tree decl;
11891      tree arg;
11892 {
11893   tree var;
11894   tree decl_type;
11895
11896   if (TREE_CODE (arg) == DEFAULT_ARG)
11897     /* We get a DEFAULT_ARG when looking at an in-class declaration
11898        with a default argument.  Ignore the argument for now; we'll
11899        deal with it after the class is complete.  */
11900     return arg;
11901
11902   if (processing_template_decl || uses_template_parms (arg))
11903     /* We don't do anything checking until instantiation-time.  Note
11904        that there may be uninstantiated arguments even for an
11905        instantiated function, since default arguments are not
11906        instantiated until they are needed.  */
11907     return arg;
11908
11909   if (TYPE_P (decl))
11910     {
11911       decl_type = decl;
11912       decl = NULL_TREE;
11913     }
11914   else
11915     decl_type = TREE_TYPE (decl);
11916
11917   if (arg == error_mark_node
11918       || decl == error_mark_node
11919       || TREE_TYPE (arg) == error_mark_node
11920       || decl_type == error_mark_node)
11921     /* Something already went wrong.  There's no need to check
11922        further.  */
11923     return error_mark_node;
11924
11925   /* [dcl.fct.default]
11926
11927      A default argument expression is implicitly converted to the
11928      parameter type.  */
11929   if (!TREE_TYPE (arg)
11930       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11931     {
11932       if (decl)
11933         cp_error ("default argument for `%#D' has type `%T'",
11934                   decl, TREE_TYPE (arg));
11935       else
11936         cp_error ("default argument for parameter of type `%T' has type `%T'",
11937                   decl_type, TREE_TYPE (arg));
11938
11939       return error_mark_node;
11940     }
11941
11942   /* [dcl.fct.default]
11943
11944      Local variables shall not be used in default argument
11945      expressions.
11946
11947      The keyword `this' shall not be used in a default argument of a
11948      member function.  */
11949   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11950   if (var)
11951     {
11952       cp_error ("default argument `%E' uses local variable `%D'",
11953                 arg, var);
11954       return error_mark_node;
11955     }
11956
11957   /* All is well.  */
11958   return arg;
11959 }
11960
11961 /* Decode the list of parameter types for a function type.
11962    Given the list of things declared inside the parens,
11963    return a list of types.
11964
11965    The list we receive can have three kinds of elements:
11966    an IDENTIFIER_NODE for names given without types,
11967    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11968    or void_type_node, to mark the end of an argument list
11969    when additional arguments are not permitted (... was not used).
11970
11971    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11972    a mere declaration.  A nonempty identifier-list gets an error message
11973    when FUNCDEF_FLAG is zero.
11974    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11975    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11976
11977    If all elements of the input list contain types,
11978    we return a list of the types.
11979    If all elements contain no type (except perhaps a void_type_node
11980    at the end), we return a null list.
11981    If some have types and some do not, it is an error, and we
11982    return a null list.
11983
11984    Also set last_function_parms to either
11985    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11986    A list of names is converted to a chain of PARM_DECLs
11987    by store_parm_decls so that ultimately it is always a chain of decls.
11988
11989    Note that in C++, parameters can take default values.  These default
11990    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11991    an error to specify default values which are followed by parameters
11992    that have no default values, or an ELLIPSES.  For simplicities sake,
11993    only parameters which are specified with their types can take on
11994    default values.  */
11995
11996 static tree
11997 grokparms (first_parm, funcdef_flag)
11998      tree first_parm;
11999      int funcdef_flag;
12000 {
12001   tree result = NULL_TREE;
12002   tree decls = NULL_TREE;
12003
12004   if (first_parm != NULL_TREE
12005       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12006     {
12007       if (! funcdef_flag)
12008         pedwarn ("parameter names (without types) in function declaration");
12009       last_function_parms = first_parm;
12010       return NULL_TREE;
12011     }
12012   else if (first_parm != NULL_TREE
12013            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12014            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12015     my_friendly_abort (145);
12016   else
12017     {
12018       /* Types were specified.  This is a list of declarators
12019          each represented as a TREE_LIST node.  */
12020       register tree parm, chain;
12021       int any_init = 0, any_error = 0;
12022
12023       if (first_parm != NULL_TREE)
12024         {
12025           tree last_result = NULL_TREE;
12026           tree last_decl = NULL_TREE;
12027
12028           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12029             {
12030               tree type = NULL_TREE, list_node = parm;
12031               register tree decl = TREE_VALUE (parm);
12032               tree init = TREE_PURPOSE (parm);
12033
12034               chain = TREE_CHAIN (parm);
12035               /* @@ weak defense against parse errors.  */
12036               if (TREE_CODE (decl) != VOID_TYPE
12037                   && TREE_CODE (decl) != TREE_LIST)
12038                 {
12039                   /* Give various messages as the need arises.  */
12040                   if (TREE_CODE (decl) == STRING_CST)
12041                     cp_error ("invalid string constant `%E'", decl);
12042                   else if (TREE_CODE (decl) == INTEGER_CST)
12043                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12044                   continue;
12045                 }
12046
12047               if (TREE_CODE (decl) != VOID_TYPE)
12048                 {
12049                   decl = grokdeclarator (TREE_VALUE (decl),
12050                                          TREE_PURPOSE (decl),
12051                                          PARM, init != NULL_TREE,
12052                                          NULL_TREE);
12053                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12054                     continue;
12055
12056                   /* Top-level qualifiers on the parameters are
12057                      ignored for function types.  */
12058                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12059
12060                   if (TREE_CODE (type) == VOID_TYPE)
12061                     decl = void_type_node;
12062                   else if (TREE_CODE (type) == METHOD_TYPE)
12063                     {
12064                       if (DECL_NAME (decl))
12065                         /* Cannot use the decl here because
12066                            we don't have DECL_CONTEXT set up yet.  */
12067                         cp_error ("parameter `%D' invalidly declared method type",
12068                                   DECL_NAME (decl));
12069                       else
12070                         error ("parameter invalidly declared method type");
12071                       type = build_pointer_type (type);
12072                       TREE_TYPE (decl) = type;
12073                     }
12074                   else if (TREE_CODE (type) == OFFSET_TYPE)
12075                     {
12076                       if (DECL_NAME (decl))
12077                         cp_error ("parameter `%D' invalidly declared offset type",
12078                                   DECL_NAME (decl));
12079                       else
12080                         error ("parameter invalidly declared offset type");
12081                       type = build_pointer_type (type);
12082                       TREE_TYPE (decl) = type;
12083                     }
12084                   else if (abstract_virtuals_error (decl, type))
12085                     any_error = 1;  /* Seems like a good idea. */
12086                   else if (POINTER_TYPE_P (type))
12087                     {
12088                       tree t = type;
12089                       while (POINTER_TYPE_P (t)
12090                              || (TREE_CODE (t) == ARRAY_TYPE
12091                                  && TYPE_DOMAIN (t) != NULL_TREE))
12092                         t = TREE_TYPE (t);
12093                       if (TREE_CODE (t) == ARRAY_TYPE)
12094                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12095                                   type,
12096                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12097                     }
12098                 }
12099
12100               if (TREE_CODE (decl) == VOID_TYPE)
12101                 {
12102                   if (result == NULL_TREE)
12103                     {
12104                       result = void_list_node;
12105                       last_result = result;
12106                     }
12107                   else
12108                     {
12109                       TREE_CHAIN (last_result) = void_list_node;
12110                       last_result = void_list_node;
12111                     }
12112                   if (chain
12113                       && (chain != void_list_node || TREE_CHAIN (chain)))
12114                     error ("`void' in parameter list must be entire list");
12115                   break;
12116                 }
12117
12118               /* Since there is a prototype, args are passed in their own types.  */
12119               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12120               if (PROMOTE_PROTOTYPES
12121                   && (TREE_CODE (type) == INTEGER_TYPE
12122                       || TREE_CODE (type) == ENUMERAL_TYPE)
12123                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12124                 DECL_ARG_TYPE (decl) = integer_type_node;
12125               if (!any_error && init)
12126                 {
12127                   any_init++;
12128                   init = check_default_argument (decl, init);
12129                 }
12130               else
12131                 init = NULL_TREE;
12132
12133               if (decls == NULL_TREE)
12134                 {
12135                   decls = decl;
12136                   last_decl = decls;
12137                 }
12138               else
12139                 {
12140                   TREE_CHAIN (last_decl) = decl;
12141                   last_decl = decl;
12142                 }
12143               list_node = tree_cons (init, type, NULL_TREE);
12144               if (result == NULL_TREE)
12145                 {
12146                   result = list_node;
12147                   last_result = result;
12148                 }
12149               else
12150                 {
12151                   TREE_CHAIN (last_result) = list_node;
12152                   last_result = list_node;
12153                 }
12154             }
12155           if (last_result)
12156             TREE_CHAIN (last_result) = NULL_TREE;
12157           /* If there are no parameters, and the function does not end
12158              with `...', then last_decl will be NULL_TREE.  */
12159           if (last_decl != NULL_TREE)
12160             TREE_CHAIN (last_decl) = NULL_TREE;
12161         }
12162     }
12163
12164   last_function_parms = decls;
12165
12166   return result;
12167 }
12168
12169 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12170    FUNCTION_TYPE with the newly parsed version of its default argument, which
12171    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12172
12173 void
12174 replace_defarg (arg, init)
12175      tree arg, init;
12176 {
12177   if (! processing_template_decl
12178       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12179     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12180                 TREE_TYPE (init), TREE_VALUE (arg));
12181   TREE_PURPOSE (arg) = init;
12182 }
12183 \f
12184 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12185    D's arguments allow it to be a copy constructor, or copy assignment
12186    operator.  */
12187
12188 int
12189 copy_args_p (d)
12190      tree d;
12191 {
12192   tree t;
12193
12194   if (!DECL_FUNCTION_MEMBER_P (d))
12195     return 0;
12196
12197   t = FUNCTION_ARG_CHAIN (d);
12198   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12199     t = TREE_CHAIN (t);
12200   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12201       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12202           == DECL_CONTEXT (d))
12203       && (TREE_CHAIN (t) == NULL_TREE
12204           || TREE_CHAIN (t) == void_list_node
12205           || TREE_PURPOSE (TREE_CHAIN (t))))
12206     return 1;
12207   return 0;
12208 }
12209
12210 /* These memoizing functions keep track of special properties which
12211    a class may have.  `grok_ctor_properties' notices whether a class
12212    has a constructor of the form X(X&), and also complains
12213    if the class has a constructor of the form X(X).
12214    `grok_op_properties' takes notice of the various forms of
12215    operator= which are defined, as well as what sorts of type conversion
12216    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12217
12218 int
12219 grok_ctor_properties (ctype, decl)
12220      tree ctype, decl;
12221 {
12222   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12223   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12224
12225   /* When a type has virtual baseclasses, a magical first int argument is
12226      added to any ctor so we can tell if the class has been initialized
12227      yet.  This could screw things up in this function, so we deliberately
12228      ignore the leading int if we're in that situation.  */
12229   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12230     {
12231       my_friendly_assert (parmtypes
12232                           && TREE_VALUE (parmtypes) == integer_type_node,
12233                           980529);
12234       parmtypes = TREE_CHAIN (parmtypes);
12235       parmtype = TREE_VALUE (parmtypes);
12236     }
12237
12238   /* [class.copy]
12239
12240      A non-template constructor for class X is a copy constructor if
12241      its first parameter is of type X&, const X&, volatile X& or const
12242      volatile X&, and either there are no other parameters or else all
12243      other parameters have default arguments.  */
12244   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12245       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12246       && (TREE_CHAIN (parmtypes) == NULL_TREE
12247           || TREE_CHAIN (parmtypes) == void_list_node
12248           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12249       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12250            && is_member_template (DECL_TI_TEMPLATE (decl))))
12251     {
12252       TYPE_HAS_INIT_REF (ctype) = 1;
12253       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12254         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12255     }
12256   /* [class.copy]
12257
12258      A declaration of a constructor for a class X is ill-formed if its
12259      first parameter is of type (optionally cv-qualified) X and either
12260      there are no other parameters or else all other parameters have
12261      default arguments.
12262
12263      We *don't* complain about member template instantiations that
12264      have this form, though; they can occur as we try to decide what
12265      constructor to use during overload resolution.  Since overload
12266      resolution will never prefer such a constructor to the
12267      non-template copy constructor (which is either explicitly or
12268      implicitly defined), there's no need to worry about their
12269      existence.  Theoretically, they should never even be
12270      instantiated, but that's hard to forestall.  */
12271   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12272            && (TREE_CHAIN (parmtypes) == NULL_TREE
12273                || TREE_CHAIN (parmtypes) == void_list_node
12274                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12275            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12276                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12277     {
12278       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12279                 ctype, ctype);
12280       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12281       return 0;
12282     }
12283   else if (TREE_CODE (parmtype) == VOID_TYPE
12284            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12285     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12286
12287   return 1;
12288 }
12289
12290 /* An operator with this code is unary, but can also be binary.  */
12291
12292 static int
12293 ambi_op_p (code)
12294      enum tree_code code;
12295 {
12296   return (code == INDIRECT_REF
12297           || code == ADDR_EXPR
12298           || code == CONVERT_EXPR
12299           || code == NEGATE_EXPR
12300           || code == PREINCREMENT_EXPR
12301           || code == PREDECREMENT_EXPR);
12302 }
12303
12304 /* An operator with this name can only be unary.  */
12305
12306 static int
12307 unary_op_p (code)
12308      enum tree_code code;
12309 {
12310   return (code == TRUTH_NOT_EXPR
12311           || code == BIT_NOT_EXPR
12312           || code == COMPONENT_REF
12313           || code == TYPE_EXPR);
12314 }
12315
12316 /* Do a little sanity-checking on how they declared their operator.  */
12317
12318 void
12319 grok_op_properties (decl, virtualp, friendp)
12320      tree decl;
12321      int virtualp, friendp;
12322 {
12323   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12324   tree argtype;
12325   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12326   tree name = DECL_NAME (decl);
12327   enum tree_code operator_code;
12328   int arity;
12329
12330   /* Count the number of arguments.  */
12331   for (argtype = argtypes, arity = 0;
12332        argtype && argtype != void_list_node;
12333        argtype = TREE_CHAIN (argtype))
12334     ++arity;
12335
12336   if (current_class_type == NULL_TREE)
12337     friendp = 1;
12338
12339   if (DECL_CONV_FN_P (decl))
12340     operator_code = TYPE_EXPR;
12341   else
12342     do
12343       {
12344 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12345         if (ansi_opname (CODE) == name)                                     \
12346           {                                                                 \
12347             operator_code = CODE;                                           \
12348             break;                                                          \
12349           }                                                                 \
12350         else if (ansi_assopname (CODE) == name)                             \
12351           {                                                                 \
12352             operator_code = CODE;                                           \
12353             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12354             break;                                                          \
12355           }
12356
12357 #include "operators.def"
12358 #undef DEF_OPERATOR
12359
12360         my_friendly_abort (20000527);
12361       }
12362     while (0);
12363   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12364   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12365
12366   if (! friendp)
12367     {
12368       switch (operator_code)
12369         {
12370         case CALL_EXPR:
12371           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12372           break;
12373
12374         case ARRAY_REF:
12375           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12376           break;
12377
12378         case COMPONENT_REF:
12379         case MEMBER_REF:
12380           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12381           break;
12382
12383         case NEW_EXPR:
12384           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12385           break;
12386
12387         case DELETE_EXPR:
12388           TYPE_GETS_DELETE (current_class_type) |= 1;
12389           break;
12390
12391         case VEC_NEW_EXPR:
12392           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12393           break;
12394
12395         case VEC_DELETE_EXPR:
12396           TYPE_GETS_DELETE (current_class_type) |= 2;
12397           break;
12398
12399         default:
12400           break;
12401         }
12402     }
12403
12404   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12405     {
12406       /* When the compiler encounters the definition of A::operator new, it
12407          doesn't look at the class declaration to find out if it's static.  */
12408       if (methodp)
12409         revert_static_member_fn (decl);
12410
12411       /* Take care of function decl if we had syntax errors.  */
12412       if (argtypes == NULL_TREE)
12413         TREE_TYPE (decl)
12414           = build_function_type (ptr_type_node,
12415                                  hash_tree_chain (integer_type_node,
12416                                                   void_list_node));
12417       else
12418         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12419     }
12420   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12421     {
12422       if (methodp)
12423         revert_static_member_fn (decl);
12424
12425       if (argtypes == NULL_TREE)
12426         TREE_TYPE (decl)
12427           = build_function_type (void_type_node,
12428                                  hash_tree_chain (ptr_type_node,
12429                                                   void_list_node));
12430       else
12431         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12432     }
12433   else
12434     {
12435       /* An operator function must either be a non-static member function
12436          or have at least one parameter of a class, a reference to a class,
12437          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12438       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12439         {
12440           if (operator_code == TYPE_EXPR
12441               || operator_code == CALL_EXPR
12442               || operator_code == COMPONENT_REF
12443               || operator_code == ARRAY_REF
12444               || operator_code == NOP_EXPR)
12445             cp_error ("`%D' must be a nonstatic member function", decl);
12446           else
12447             {
12448               tree p = argtypes;
12449
12450               if (DECL_STATIC_FUNCTION_P (decl))
12451                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12452
12453               if (p)
12454                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12455                   {
12456                     tree arg = TREE_VALUE (p);
12457                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12458                       arg = TREE_TYPE (arg);
12459
12460                     /* This lets bad template code slip through.  */
12461                     if (IS_AGGR_TYPE (arg)
12462                         || TREE_CODE (arg) == ENUMERAL_TYPE
12463                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12464                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12465                       goto foundaggr;
12466                   }
12467               cp_error
12468                 ("`%D' must have an argument of class or enumerated type",
12469                  decl);
12470             foundaggr:
12471               ;
12472             }
12473         }
12474
12475       if (operator_code == CALL_EXPR)
12476         return;                 /* No restrictions on args. */
12477
12478       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12479         {
12480           tree t = TREE_TYPE (name);
12481           if (! friendp)
12482             {
12483               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12484               const char *what = 0;
12485
12486               if (ref)
12487                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12488
12489               if (TREE_CODE (t) == VOID_TYPE)
12490                 what = "void";
12491               else if (t == current_class_type)
12492                 what = "the same type";
12493               /* Don't force t to be complete here.  */
12494               else if (IS_AGGR_TYPE (t)
12495                        && COMPLETE_TYPE_P (t)
12496                        && DERIVED_FROM_P (t, current_class_type))
12497                 what = "a base class";
12498
12499               if (what)
12500                 warning ("conversion to %s%s will never use a type conversion operator",
12501                          ref ? "a reference to " : "", what);
12502             }
12503         }
12504
12505       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12506           && operator_code == NOP_EXPR)
12507         {
12508           tree parmtype;
12509
12510           if (arity != 2 && methodp)
12511             {
12512               cp_error ("`%D' must take exactly one argument", decl);
12513               return;
12514             }
12515           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12516
12517           /* [class.copy]
12518
12519              A user-declared copy assignment operator X::operator= is
12520              a non-static non-template member function of class X with
12521              exactly one parameter of type X, X&, const X&, volatile
12522              X& or const volatile X&.  */
12523           if (copy_assignment_arg_p (parmtype, virtualp)
12524               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12525                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12526               && ! friendp)
12527             {
12528               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12529               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12530                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12531                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12532             }
12533         }
12534       else if (operator_code == COND_EXPR)
12535         {
12536           /* 13.4.0.3 */
12537           cp_error ("ISO C++ prohibits overloading operator ?:");
12538         }
12539       else if (ambi_op_p (operator_code))
12540         {
12541           if (arity == 1)
12542             /* We pick the one-argument operator codes by default, so
12543                we don't have to change anything.  */
12544             ;
12545           else if (arity == 2)
12546             {
12547               /* If we thought this was a unary operator, we now know
12548                  it to be a binary operator.  */
12549               switch (operator_code)
12550                 {
12551                 case INDIRECT_REF:
12552                   operator_code = MULT_EXPR;
12553                   break;
12554
12555                 case ADDR_EXPR:
12556                   operator_code = BIT_AND_EXPR;
12557                   break;
12558
12559                 case CONVERT_EXPR:
12560                   operator_code = PLUS_EXPR;
12561                   break;
12562
12563                 case NEGATE_EXPR:
12564                   operator_code = MINUS_EXPR;
12565                   break;
12566
12567                 case PREINCREMENT_EXPR:
12568                   operator_code = POSTINCREMENT_EXPR;
12569                   break;
12570
12571                 case PREDECREMENT_EXPR:
12572                   operator_code = POSTDECREMENT_EXPR;
12573                   break;
12574
12575                 default:
12576                   my_friendly_abort (20000527);
12577                 }
12578
12579               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12580
12581               if ((operator_code == POSTINCREMENT_EXPR
12582                    || operator_code == POSTDECREMENT_EXPR)
12583                   && ! processing_template_decl
12584                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12585                 {
12586                   if (methodp)
12587                     cp_error ("postfix `%D' must take `int' as its argument",
12588                               decl);
12589                   else
12590                     cp_error
12591                       ("postfix `%D' must take `int' as its second argument",
12592                        decl);
12593                 }
12594             }
12595           else
12596             {
12597               if (methodp)
12598                 cp_error ("`%D' must take either zero or one argument", decl);
12599               else
12600                 cp_error ("`%D' must take either one or two arguments", decl);
12601             }
12602
12603           /* More Effective C++ rule 6.  */
12604           if (warn_ecpp
12605               && (operator_code == POSTINCREMENT_EXPR
12606                   || operator_code == POSTDECREMENT_EXPR
12607                   || operator_code == PREINCREMENT_EXPR
12608                   || operator_code == PREDECREMENT_EXPR))
12609             {
12610               tree arg = TREE_VALUE (argtypes);
12611               tree ret = TREE_TYPE (TREE_TYPE (decl));
12612               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12613                 arg = TREE_TYPE (arg);
12614               arg = TYPE_MAIN_VARIANT (arg);
12615               if (operator_code == PREINCREMENT_EXPR
12616                   || operator_code == PREDECREMENT_EXPR)
12617                 {
12618                   if (TREE_CODE (ret) != REFERENCE_TYPE
12619                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12620                                        arg))
12621                     cp_warning ("prefix `%D' should return `%T'", decl,
12622                                 build_reference_type (arg));
12623                 }
12624               else
12625                 {
12626                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12627                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12628                 }
12629             }
12630         }
12631       else if (unary_op_p (operator_code))
12632         {
12633           if (arity != 1)
12634             {
12635               if (methodp)
12636                 cp_error ("`%D' must take `void'", decl);
12637               else
12638                 cp_error ("`%D' must take exactly one argument", decl);
12639             }
12640         }
12641       else /* if (binary_op_p (operator_code)) */
12642         {
12643           if (arity != 2)
12644             {
12645               if (methodp)
12646                 cp_error ("`%D' must take exactly one argument", decl);
12647               else
12648                 cp_error ("`%D' must take exactly two arguments", decl);
12649             }
12650
12651           /* More Effective C++ rule 7.  */
12652           if (warn_ecpp
12653               && (operator_code == TRUTH_ANDIF_EXPR
12654                   || operator_code == TRUTH_ORIF_EXPR
12655                   || operator_code == COMPOUND_EXPR))
12656             cp_warning ("user-defined `%D' always evaluates both arguments",
12657                         decl);
12658         }
12659
12660       /* Effective C++ rule 23.  */
12661       if (warn_ecpp
12662           && arity == 2
12663           && (operator_code == PLUS_EXPR
12664               || operator_code == MINUS_EXPR
12665               || operator_code == TRUNC_DIV_EXPR
12666               || operator_code == MULT_EXPR)
12667           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12668         cp_warning ("`%D' should return by value", decl);
12669
12670       /* 13.4.0.8 */
12671       for (; argtypes && argtypes != void_list_node;
12672           argtypes = TREE_CHAIN (argtypes))
12673         if (TREE_PURPOSE (argtypes))
12674           {
12675             TREE_PURPOSE (argtypes) = NULL_TREE;
12676             if (operator_code == POSTINCREMENT_EXPR
12677                 || operator_code == POSTDECREMENT_EXPR)
12678               {
12679                 if (pedantic)
12680                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12681               }
12682             else
12683               cp_error ("`%D' cannot have default arguments", decl);
12684           }
12685
12686     }
12687 }
12688 \f
12689 static const char *
12690 tag_name (code)
12691      enum tag_types code;
12692 {
12693   switch (code)
12694     {
12695     case record_type:
12696       return "struct";
12697     case class_type:
12698       return "class";
12699     case union_type:
12700       return "union ";
12701     case enum_type:
12702       return "enum";
12703     default:
12704       my_friendly_abort (981122);
12705     }
12706 }
12707
12708 /* Get the struct, enum or union (CODE says which) with tag NAME.
12709    Define the tag as a forward-reference if it is not defined.
12710
12711    C++: If a class derivation is given, process it here, and report
12712    an error if multiple derivation declarations are not identical.
12713
12714    If this is a definition, come in through xref_tag and only look in
12715    the current frame for the name (since C++ allows new names in any
12716    scope.)  */
12717
12718 tree
12719 xref_tag (code_type_node, name, globalize)
12720      tree code_type_node;
12721      tree name;
12722      int globalize;
12723 {
12724   enum tag_types tag_code;
12725   enum tree_code code;
12726   register tree ref, t;
12727   struct binding_level *b = current_binding_level;
12728   int got_type = 0;
12729   tree attributes = NULL_TREE;
12730   tree context = NULL_TREE;
12731
12732   /* If we are called from the parser, code_type_node will sometimes be a
12733      TREE_LIST.  This indicates that the user wrote
12734      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12735      use them later.  */
12736   if (TREE_CODE (code_type_node) == TREE_LIST)
12737     {
12738       attributes = TREE_PURPOSE (code_type_node);
12739       code_type_node = TREE_VALUE (code_type_node);
12740     }
12741
12742   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12743   switch (tag_code)
12744     {
12745     case record_type:
12746     case class_type:
12747       code = RECORD_TYPE;
12748       break;
12749     case union_type:
12750       code = UNION_TYPE;
12751       break;
12752     case enum_type:
12753       code = ENUMERAL_TYPE;
12754       break;
12755     default:
12756       my_friendly_abort (18);
12757     }
12758
12759   /* If a cross reference is requested, look up the type
12760      already defined for this tag and return it.  */
12761   if (TYPE_P (name))
12762     {
12763       t = name;
12764       name = TYPE_IDENTIFIER (t);
12765       got_type = 1;
12766     }
12767   else
12768     t = IDENTIFIER_TYPE_VALUE (name);
12769
12770   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12771       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12772     t = NULL_TREE;
12773
12774   if (! globalize)
12775     {
12776       /* If we know we are defining this tag, only look it up in
12777          this scope and don't try to find it as a type.  */
12778       ref = lookup_tag (code, name, b, 1);
12779     }
12780   else
12781     {
12782       if (t)
12783         {
12784           /* [dcl.type.elab] If the identifier resolves to a
12785              typedef-name or a template type-parameter, the
12786              elaborated-type-specifier is ill-formed.  */
12787           if (t != TYPE_MAIN_VARIANT (t)
12788               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12789             cp_pedwarn ("using typedef-name `%D' after `%s'",
12790                         TYPE_NAME (t), tag_name (tag_code));
12791           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12792             cp_error ("using template type parameter `%T' after `%s'",
12793                       t, tag_name (tag_code));
12794
12795           ref = t;
12796         }
12797       else
12798         ref = lookup_tag (code, name, b, 0);
12799
12800       if (! ref)
12801         {
12802           /* Try finding it as a type declaration.  If that wins,
12803              use it.  */
12804           ref = lookup_name (name, 1);
12805
12806           if (ref != NULL_TREE
12807               && processing_template_decl
12808               && DECL_CLASS_TEMPLATE_P (ref)
12809               && template_class_depth (current_class_type) == 0)
12810             /* Since GLOBALIZE is true, we're declaring a global
12811                template, so we want this type.  */
12812             ref = DECL_TEMPLATE_RESULT (ref);
12813
12814           if (ref && TREE_CODE (ref) == TYPE_DECL
12815               && TREE_CODE (TREE_TYPE (ref)) == code)
12816             ref = TREE_TYPE (ref);
12817           else
12818             ref = NULL_TREE;
12819         }
12820
12821       if (ref && current_class_type
12822           && template_class_depth (current_class_type)
12823           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12824         {
12825           /* Since GLOBALIZE is non-zero, we are not looking at a
12826              definition of this tag.  Since, in addition, we are currently
12827              processing a (member) template declaration of a template
12828              class, we must be very careful; consider:
12829
12830                template <class X>
12831                struct S1
12832
12833                template <class U>
12834                struct S2
12835                { template <class V>
12836                friend struct S1; };
12837
12838              Here, the S2::S1 declaration should not be confused with the
12839              outer declaration.  In particular, the inner version should
12840              have a template parameter of level 2, not level 1.  This
12841              would be particularly important if the member declaration
12842              were instead:
12843
12844                template <class V = U> friend struct S1;
12845
12846              say, when we should tsubst into `U' when instantiating
12847              S2.  On the other hand, when presented with:
12848
12849                  template <class T>
12850                  struct S1 {
12851                    template <class U>
12852                    struct S2 {};
12853                    template <class U>
12854                    friend struct S2;
12855                  };
12856
12857               we must find the inner binding eventually.  We
12858               accomplish this by making sure that the new type we
12859               create to represent this declaration has the right
12860               TYPE_CONTEXT.  */
12861           context = TYPE_CONTEXT (ref);
12862           ref = NULL_TREE;
12863         }
12864     }
12865
12866   if (! ref)
12867     {
12868       /* If no such tag is yet defined, create a forward-reference node
12869          and record it as the "definition".
12870          When a real declaration of this type is found,
12871          the forward-reference will be altered into a real type.  */
12872       if (code == ENUMERAL_TYPE)
12873         {
12874           cp_error ("use of enum `%#D' without previous declaration", name);
12875
12876           ref = make_node (ENUMERAL_TYPE);
12877
12878           /* Give the type a default layout like unsigned int
12879              to avoid crashing if it does not get defined.  */
12880           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12881           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12882           TYPE_USER_ALIGN (ref) = 0;
12883           TREE_UNSIGNED (ref) = 1;
12884           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12885           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12886           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12887
12888           /* Enable us to recognize when a type is created in class context.
12889              To do nested classes correctly, this should probably be cleared
12890              out when we leave this classes scope.  Currently this in only
12891              done in `start_enum'.  */
12892
12893           pushtag (name, ref, globalize);
12894         }
12895       else
12896         {
12897           struct binding_level *old_b = class_binding_level;
12898
12899           ref = make_aggr_type (code);
12900           TYPE_CONTEXT (ref) = context;
12901
12902 #ifdef NONNESTED_CLASSES
12903           /* Class types don't nest the way enums do.  */
12904           class_binding_level = (struct binding_level *)0;
12905 #endif
12906           pushtag (name, ref, globalize);
12907           class_binding_level = old_b;
12908         }
12909     }
12910   else
12911     {
12912       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12913         redeclare_class_template (ref, current_template_parms);
12914     }
12915
12916   /* Until the type is defined, tentatively accept whatever
12917      structure tag the user hands us.  */
12918   if (!COMPLETE_TYPE_P (ref)
12919       && ref != current_class_type
12920       /* Have to check this, in case we have contradictory tag info.  */
12921       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12922     {
12923       if (tag_code == class_type)
12924         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12925       else if (tag_code == record_type)
12926         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12927     }
12928
12929   TREE_TYPE (ref) = attributes;
12930
12931   return ref;
12932 }
12933
12934 tree
12935 xref_tag_from_type (old, id, globalize)
12936      tree old, id;
12937      int globalize;
12938 {
12939   tree code_type_node;
12940
12941   if (TREE_CODE (old) == RECORD_TYPE)
12942     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12943                       ? class_type_node : record_type_node);
12944   else
12945     code_type_node = union_type_node;
12946
12947   if (id == NULL_TREE)
12948     id = TYPE_IDENTIFIER (old);
12949
12950   return xref_tag (code_type_node, id, globalize);
12951 }
12952
12953 /* REF is a type (named NAME), for which we have just seen some
12954    baseclasses.  BINFO is a list of those baseclasses; the
12955    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12956    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12957    struct, or union.  */
12958
12959 void
12960 xref_basetypes (code_type_node, name, ref, binfo)
12961      tree code_type_node;
12962      tree name, ref;
12963      tree binfo;
12964 {
12965   /* In the declaration `A : X, Y, ... Z' we mark all the types
12966      (A, X, Y, ..., Z) so we can check for duplicates.  */
12967   tree binfos;
12968   tree base;
12969
12970   int i, len;
12971   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12972
12973   if (tag_code == union_type)
12974     {
12975       cp_error ("derived union `%T' invalid", ref);
12976       return;
12977     }
12978
12979   len = list_length (binfo);
12980
12981   /* First, make sure that any templates in base-classes are
12982      instantiated.  This ensures that if we call ourselves recursively
12983      we do not get confused about which classes are marked and which
12984      are not.  */
12985   for (base = binfo; base; base = TREE_CHAIN (base))
12986     complete_type (TREE_VALUE (base));
12987
12988   SET_CLASSTYPE_MARKED (ref);
12989   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12990
12991   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12992     {
12993       /* The base of a derived struct is public by default.  */
12994       int via_public
12995         = (TREE_PURPOSE (binfo) == access_public_node
12996            || TREE_PURPOSE (binfo) == access_public_virtual_node
12997            || (tag_code != class_type
12998                && (TREE_PURPOSE (binfo) == access_default_node
12999                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13000       int via_protected
13001         = (TREE_PURPOSE (binfo) == access_protected_node
13002            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13003       int via_virtual
13004         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13005            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13006            || TREE_PURPOSE (binfo) == access_public_virtual_node
13007            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13008       tree basetype = TREE_VALUE (binfo);
13009       tree base_binfo;
13010
13011       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13012         basetype = TREE_TYPE (basetype);
13013       if (!basetype
13014           || (TREE_CODE (basetype) != RECORD_TYPE
13015               && TREE_CODE (basetype) != TYPENAME_TYPE
13016               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13017               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
13018         {
13019           cp_error ("base type `%T' fails to be a struct or class type",
13020                     TREE_VALUE (binfo));
13021           continue;
13022         }
13023
13024       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13025
13026       /* This code replaces similar code in layout_basetypes.
13027          We put the complete_type first for implicit `typename'.  */
13028       if (!COMPLETE_TYPE_P (basetype)
13029           && ! (current_template_parms && uses_template_parms (basetype)))
13030         {
13031           cp_error ("base class `%T' has incomplete type", basetype);
13032           continue;
13033         }
13034       else
13035         {
13036           if (CLASSTYPE_MARKED (basetype))
13037             {
13038               if (basetype == ref)
13039                 cp_error ("recursive type `%T' undefined", basetype);
13040               else
13041                 cp_error ("duplicate base type `%T' invalid", basetype);
13042               continue;
13043             }
13044
13045           if (TYPE_FOR_JAVA (basetype)
13046               && (current_lang_stack
13047                   == &VARRAY_TREE (current_lang_base, 0)))
13048             TYPE_FOR_JAVA (ref) = 1;
13049
13050           /* Note that the BINFO records which describe individual
13051              inheritances are *not* shared in the lattice!  They
13052              cannot be shared because a given baseclass may be
13053              inherited with different `accessibility' by different
13054              derived classes.  (Each BINFO record describing an
13055              individual inheritance contains flags which say what
13056              the `accessibility' of that particular inheritance is.)  */
13057
13058           base_binfo
13059             = make_binfo (size_zero_node, basetype,
13060                           CLASS_TYPE_P (basetype)
13061                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13062                           CLASS_TYPE_P (basetype)
13063                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13064
13065           TREE_VEC_ELT (binfos, i) = base_binfo;
13066           TREE_VIA_PUBLIC (base_binfo) = via_public;
13067           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13068           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13069           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13070
13071           /* We need to unshare the binfos now so that lookups during class
13072              definition work.  */
13073           unshare_base_binfos (base_binfo);
13074
13075           SET_CLASSTYPE_MARKED (basetype);
13076
13077           /* We are free to modify these bits because they are meaningless
13078              at top level, and BASETYPE is a top-level type.  */
13079           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13080             {
13081               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13082               /* Converting to a virtual base class requires looking
13083                  up the offset of the virtual base.  */
13084               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13085             }
13086
13087           if (CLASS_TYPE_P (basetype))
13088             {
13089               TYPE_HAS_NEW_OPERATOR (ref)
13090                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13091               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13092                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13093               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13094               /* If the base-class uses multiple inheritance, so do we.  */
13095               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13096                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13097               /* Likewise, if converting to a base of the base may require
13098                  code, then we may need to generate code to convert to a
13099                  base as well.  */
13100               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13101                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13102             }
13103
13104           i += 1;
13105         }
13106     }
13107   if (i)
13108     TREE_VEC_LENGTH (binfos) = i;
13109   else
13110     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13111
13112   if (i > 1)
13113     {
13114       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13115       /* If there is more than one non-empty they cannot be at the same
13116          address.  */
13117       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13118     }
13119
13120   /* Unmark all the types.  */
13121   while (--i >= 0)
13122     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13123   CLEAR_CLASSTYPE_MARKED (ref);
13124
13125   /* Now that we know all the base-classes, set up the list of virtual
13126      bases.  */
13127   get_vbase_types (ref);
13128 }
13129
13130 \f
13131 /* Begin compiling the definition of an enumeration type.
13132    NAME is its name (or null if anonymous).
13133    Returns the type object, as yet incomplete.
13134    Also records info about it so that build_enumerator
13135    may be used to declare the individual values as they are read.  */
13136
13137 tree
13138 start_enum (name)
13139      tree name;
13140 {
13141   register tree enumtype = NULL_TREE;
13142   struct binding_level *b = current_binding_level;
13143
13144   /* If this is the real definition for a previous forward reference,
13145      fill in the contents in the same object that used to be the
13146      forward reference.  */
13147
13148   if (name != NULL_TREE)
13149     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13150
13151   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13152     {
13153       cp_error ("multiple definition of `%#T'", enumtype);
13154       cp_error_at ("previous definition here", enumtype);
13155       /* Clear out TYPE_VALUES, and start again.  */
13156       TYPE_VALUES (enumtype) = NULL_TREE;
13157     }
13158   else
13159     {
13160       enumtype = make_node (ENUMERAL_TYPE);
13161       pushtag (name, enumtype, 0);
13162     }
13163
13164   if (current_class_type)
13165     TREE_ADDRESSABLE (b->tags) = 1;
13166
13167   GNU_xref_decl (current_function_decl, enumtype);
13168   return enumtype;
13169 }
13170
13171 /* After processing and defining all the values of an enumeration type,
13172    install their decls in the enumeration type and finish it off.
13173    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13174    Returns ENUMTYPE.  */
13175
13176 tree
13177 finish_enum (enumtype)
13178      tree enumtype;
13179 {
13180   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13181   /* Calculate the maximum value of any enumerator in this type.  */
13182
13183   tree values = TYPE_VALUES (enumtype);
13184   if (values)
13185     {
13186       tree pair;
13187
13188       for (pair = values; pair; pair = TREE_CHAIN (pair))
13189         {
13190           tree decl;
13191           tree value;
13192
13193           /* The TREE_VALUE is a CONST_DECL for this enumeration
13194              constant.  */
13195           decl = TREE_VALUE (pair);
13196
13197           /* [dcl.enum]
13198
13199              Following the closing brace of an enum-specifier, each
13200              enumerator has the type of its enumeration.  Prior to the
13201              closing brace, the type of each enumerator is the type of
13202              its initializing value.  */
13203           TREE_TYPE (decl) = enumtype;
13204
13205           /* The DECL_INITIAL will be NULL if we are processing a
13206              template declaration and this enumeration constant had no
13207              explicit initializer.  */
13208           value = DECL_INITIAL (decl);
13209           if (value && !processing_template_decl)
13210             {
13211               /* Set the TREE_TYPE for the VALUE as well.  That's so
13212                  that when we call decl_constant_value we get an
13213                  entity of the right type (but with the constant
13214                  value).  Since we shouldn't ever call
13215                  decl_constant_value on a template type, there's no
13216                  reason to do that when processing_template_decl.
13217                  And, if the expression is something like a
13218                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13219                  wreak havoc on the intended type of the expression.
13220
13221                  Of course, there's also no point in trying to compute
13222                  minimum or maximum values if we're in a template.  */
13223               TREE_TYPE (value) = enumtype;
13224
13225               if (!minnode)
13226                 minnode = maxnode = value;
13227               else if (tree_int_cst_lt (maxnode, value))
13228                 maxnode = value;
13229               else if (tree_int_cst_lt (value, minnode))
13230                 minnode = value;
13231             }
13232
13233           if (processing_template_decl)
13234             /* If this is just a template, leave the CONST_DECL
13235                alone.  That way tsubst_copy will find CONST_DECLs for
13236                CONST_DECLs, and not INTEGER_CSTs.  */
13237             ;
13238           else
13239             /* In the list we're building up, we want the enumeration
13240                values, not the CONST_DECLs.  */
13241             TREE_VALUE (pair) = value;
13242         }
13243     }
13244   else
13245     maxnode = minnode = integer_zero_node;
13246
13247   TYPE_VALUES (enumtype) = nreverse (values);
13248
13249   if (processing_template_decl)
13250     {
13251       tree scope = current_scope ();
13252       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13253         add_tree (build_min (TAG_DEFN, enumtype));
13254     }
13255   else
13256     {
13257       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13258       int lowprec = min_precision (minnode, unsignedp);
13259       int highprec = min_precision (maxnode, unsignedp);
13260       int precision = MAX (lowprec, highprec);
13261       tree tem;
13262
13263       TYPE_SIZE (enumtype) = NULL_TREE;
13264
13265       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13266
13267       TYPE_PRECISION (enumtype) = precision;
13268       if (unsignedp)
13269         fixup_unsigned_type (enumtype);
13270       else
13271         fixup_signed_type (enumtype);
13272
13273       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13274         /* Use the width of the narrowest normal C type which is wide
13275            enough.  */
13276         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13277                                                     (precision, 1));
13278       else
13279         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13280
13281       TYPE_SIZE (enumtype) = 0;
13282       layout_type (enumtype);
13283
13284       /* Fix up all variant types of this enum type.  */
13285       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13286            tem = TYPE_NEXT_VARIANT (tem))
13287         {
13288           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13289           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13290           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13291           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13292           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13293           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13294           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13295           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13296           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13297           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13298         }
13299
13300       /* Finish debugging output for this type.  */
13301       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13302     }
13303
13304   return enumtype;
13305 }
13306
13307 /* Build and install a CONST_DECL for an enumeration constant of the
13308    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13309    Assignment of sequential values by default is handled here.  */
13310
13311 void
13312 build_enumerator (name, value, enumtype)
13313      tree name;
13314      tree value;
13315      tree enumtype;
13316 {
13317   tree decl;
13318   tree context;
13319   tree type;
13320   tree values;
13321
13322   /* Remove no-op casts from the value.  */
13323   if (value)
13324     STRIP_TYPE_NOPS (value);
13325
13326   if (! processing_template_decl)
13327     {
13328       /* Validate and default VALUE.  */
13329       if (value != NULL_TREE)
13330         {
13331           value = decl_constant_value (value);
13332
13333           if (TREE_CODE (value) == INTEGER_CST)
13334             {
13335               value = default_conversion (value);
13336               constant_expression_warning (value);
13337             }
13338           else
13339             {
13340               cp_error ("enumerator value for `%D' not integer constant", name);
13341               value = NULL_TREE;
13342             }
13343         }
13344
13345       /* Default based on previous value.  */
13346       if (value == NULL_TREE && ! processing_template_decl)
13347         {
13348           tree prev_value;
13349
13350           if (TYPE_VALUES (enumtype))
13351             {
13352               /* The next value is the previous value ... */
13353               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13354               /* ... plus one.  */
13355               value = cp_build_binary_op (PLUS_EXPR,
13356                                           prev_value,
13357                                           integer_one_node);
13358
13359               if (tree_int_cst_lt (value, prev_value))
13360                 cp_error ("overflow in enumeration values at `%D'", name);
13361             }
13362           else
13363             value = integer_zero_node;
13364         }
13365
13366       /* Remove no-op casts from the value.  */
13367       if (value)
13368         STRIP_TYPE_NOPS (value);
13369 #if 0
13370       /* To fix MAX_VAL enum consts. (bkoz)  */
13371       TREE_TYPE (value) = integer_type_node;
13372 #endif
13373     }
13374
13375   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13376      Even in other cases, we will later (in finish_enum) be setting
13377      the type of VALUE.  But, we don't need to make a copy if this
13378      VALUE is one of the enumeration constants for this same
13379      enumeration type.  */
13380   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13381     if (TREE_VALUE (values) == value)
13382       break;
13383   /* If we didn't break out of the loop, then we do need a copy.  */
13384   if (!values && value)
13385     value = copy_node (value);
13386
13387   /* C++ associates enums with global, function, or class declarations.  */
13388   context = current_scope ();
13389
13390   /* Build the actual enumeration constant.  Note that the enumeration
13391     constants have the type of their initializers until the
13392     enumeration is complete:
13393
13394       [ dcl.enum ]
13395
13396       Following the closing brace of an enum-specifier, each enumer-
13397       ator has the type of its enumeration.  Prior to the closing
13398       brace, the type of each enumerator is the type of its
13399       initializing value.
13400
13401     In finish_enum we will reset the type.  Of course, if we're
13402     processing a template, there may be no value.   */
13403   type = value ? TREE_TYPE (value) : NULL_TREE;
13404
13405   if (context && context == current_class_type)
13406     /* This enum declaration is local to the class.  We need the full
13407       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13408     decl = build_lang_decl (CONST_DECL, name, type);
13409   else
13410     /* It's a global enum, or it's local to a function.  (Note local to
13411       a function could mean local to a class method.  */
13412     decl = build_decl (CONST_DECL, name, type);
13413
13414   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13415   DECL_INITIAL (decl) = value;
13416   TREE_READONLY (decl) = 1;
13417
13418   if (context && context == current_class_type)
13419     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13420       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13421       things like `S::i' later.)  */
13422     finish_member_declaration (decl);
13423   else
13424     {
13425       pushdecl (decl);
13426       GNU_xref_decl (current_function_decl, decl);
13427     }
13428
13429   /* Add this enumeration constant to the list for this type.  */
13430   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13431 }
13432
13433 \f
13434 /* We're defining DECL.  Make sure that it's type is OK.  */
13435
13436 static void
13437 check_function_type (decl)
13438      tree decl;
13439 {
13440   tree fntype = TREE_TYPE (decl);
13441   tree return_type = complete_type (TREE_TYPE (fntype));
13442
13443   /* In a function definition, arg types must be complete.  */
13444   require_complete_types_for_parms (current_function_parms);
13445
13446   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13447     {
13448       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13449
13450       /* Make it return void instead, but don't change the
13451          type of the DECL_RESULT, in case we have a named return value.  */
13452       if (TREE_CODE (fntype) == METHOD_TYPE)
13453         {
13454           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13455           TREE_TYPE (decl)
13456             = build_cplus_method_type (ctype,
13457                                        void_type_node,
13458                                        FUNCTION_ARG_CHAIN (decl));
13459         }
13460       else
13461         TREE_TYPE (decl)
13462           = build_function_type (void_type_node,
13463                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13464       TREE_TYPE (decl)
13465         = build_exception_variant (fntype,
13466                                    TYPE_RAISES_EXCEPTIONS (fntype));
13467     }
13468   else
13469     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13470 }
13471
13472 /* Create the FUNCTION_DECL for a function definition.
13473    DECLSPECS and DECLARATOR are the parts of the declaration;
13474    they describe the function's name and the type it returns,
13475    but twisted together in a fashion that parallels the syntax of C.
13476
13477    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13478    DECLARATOR is really the DECL for the function we are about to
13479    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13480    indicating that the function is an inline defined in-class, and
13481    SF_EXPAND indicating that we should generate RTL for this
13482    function.
13483
13484    This function creates a binding context for the function body
13485    as well as setting up the FUNCTION_DECL in current_function_decl.
13486
13487    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13488    (it defines a datum instead), we return 0, which tells
13489    yyparse to report a parse error.
13490
13491    For C++, we must first check whether that datum makes any sense.
13492    For example, "class A local_a(1,2);" means that variable local_a
13493    is an aggregate of type A, which should have a constructor
13494    applied to it with the argument list [1, 2].  */
13495
13496 int
13497 start_function (declspecs, declarator, attrs, flags)
13498      tree declspecs, declarator, attrs;
13499      int flags;
13500 {
13501   tree decl1;
13502   tree ctype = NULL_TREE;
13503   tree fntype;
13504   tree restype;
13505   extern int have_extern_spec;
13506   extern int used_extern_spec;
13507   int doing_friend = 0;
13508   struct binding_level *bl;
13509
13510   /* Sanity check.  */
13511   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13512   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13513
13514   /* This should only be done once on the top most decl.  */
13515   if (have_extern_spec && !used_extern_spec)
13516     {
13517       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13518       used_extern_spec = 1;
13519     }
13520
13521   if (flags & SF_PRE_PARSED)
13522     {
13523       decl1 = declarator;
13524
13525       fntype = TREE_TYPE (decl1);
13526       if (TREE_CODE (fntype) == METHOD_TYPE)
13527         ctype = TYPE_METHOD_BASETYPE (fntype);
13528
13529       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13530          the (lexical) scope of the class in which it is defined.  */
13531       if (!ctype && DECL_FRIEND_P (decl1))
13532         {
13533           ctype = DECL_FRIEND_CONTEXT (decl1);
13534
13535           /* CTYPE could be null here if we're dealing with a template;
13536              for example, `inline friend float foo()' inside a template
13537              will have no CTYPE set.  */
13538           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13539             ctype = NULL_TREE;
13540           else
13541             doing_friend = 1;
13542         }
13543
13544       last_function_parms = DECL_ARGUMENTS (decl1);
13545       last_function_parm_tags = NULL_TREE;
13546     }
13547   else
13548     {
13549       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13550       /* If the declarator is not suitable for a function definition,
13551          cause a syntax error.  */
13552       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13553
13554       fntype = TREE_TYPE (decl1);
13555
13556       restype = TREE_TYPE (fntype);
13557       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13558         {
13559           cp_error ("semicolon missing after declaration of `%#T'", restype);
13560           shadow_tag (build_tree_list (NULL_TREE, restype));
13561           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13562           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13563             fntype = build_function_type (integer_type_node,
13564                                           TYPE_ARG_TYPES (fntype));
13565           else
13566             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13567                                               integer_type_node,
13568                                               TYPE_ARG_TYPES (fntype));
13569           TREE_TYPE (decl1) = fntype;
13570         }
13571
13572       if (TREE_CODE (fntype) == METHOD_TYPE)
13573         ctype = TYPE_METHOD_BASETYPE (fntype);
13574       else if (DECL_MAIN_P (decl1))
13575         {
13576           /* If this doesn't return integer_type, complain.  */
13577           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13578             {
13579               if (pedantic || warn_return_type)
13580                 pedwarn ("return type for `main' changed to `int'");
13581               TREE_TYPE (decl1) = fntype = default_function_type;
13582             }
13583         }
13584     }
13585
13586   /* Sometimes we don't notice that a function is a static member, and
13587      build a METHOD_TYPE for it.  Fix that up now.  */
13588   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13589       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13590     {
13591       revert_static_member_fn (decl1);
13592       last_function_parms = TREE_CHAIN (last_function_parms);
13593       ctype = NULL_TREE;
13594     }
13595
13596   /* Warn if function was previously implicitly declared
13597      (but not if we warned then).  */
13598   if (! warn_implicit
13599       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13600     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13601
13602   /* Set up current_class_type, and enter the scope of the class, if
13603      appropriate.  */
13604   if (ctype)
13605     push_nested_class (ctype, 1);
13606   else if (DECL_STATIC_FUNCTION_P (decl1))
13607     push_nested_class (DECL_CONTEXT (decl1), 2);
13608
13609   /* Now that we have entered the scope of the class, we must restore
13610      the bindings for any template parameters surrounding DECL1, if it
13611      is an inline member template.  (Order is important; consider the
13612      case where a template parameter has the same name as a field of
13613      the class.)  It is not until after this point that
13614      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13615   if (flags & SF_INCLASS_INLINE)
13616     maybe_begin_member_template_processing (decl1);
13617
13618   /* Effective C++ rule 15.  See also c_expand_return.  */
13619   if (warn_ecpp
13620       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13621       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13622     cp_warning ("`operator=' should return a reference to `*this'");
13623
13624   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13625      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13626   if (!DECL_INITIAL (decl1))
13627     DECL_INITIAL (decl1) = error_mark_node;
13628
13629 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13630   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13631 #endif
13632
13633   /* This function exists in static storage.
13634      (This does not mean `static' in the C sense!)  */
13635   TREE_STATIC (decl1) = 1;
13636
13637   /* We must call push_template_decl after current_class_type is set
13638      up.  (If we are processing inline definitions after exiting a
13639      class scope, current_class_type will be NULL_TREE until set above
13640      by push_nested_class.)  */
13641   if (processing_template_decl)
13642     decl1 = push_template_decl (decl1);
13643
13644   /* We are now in the scope of the function being defined.  */
13645   current_function_decl = decl1;
13646
13647   /* Save the parm names or decls from this function's declarator
13648      where store_parm_decls will find them.  */
13649   current_function_parms = last_function_parms;
13650   current_function_parm_tags = last_function_parm_tags;
13651
13652   /* Make sure the parameter and return types are reasonable.  When
13653      you declare a function, these types can be incomplete, but they
13654      must be complete when you define the function.  */
13655   if (! processing_template_decl)
13656     check_function_type (decl1);
13657
13658   /* Build the return declaration for the function.  */
13659   restype = TREE_TYPE (fntype);
13660   if (!processing_template_decl)
13661     {
13662       if (!DECL_RESULT (decl1))
13663         {
13664           DECL_RESULT (decl1)
13665             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13666           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13667                                       DECL_RESULT (decl1));
13668         }
13669     }
13670   else
13671     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13672     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13673
13674   /* Initialize RTL machinery.  We cannot do this until
13675      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13676      even when processing a template; this is how we get
13677      CFUN set up, and our per-function variables initialized.  */
13678   bl = current_binding_level;
13679   init_function_start (decl1, input_filename, lineno);
13680   current_binding_level = bl;
13681   expanding_p = (flags & SF_EXPAND) != 0;
13682
13683   /* Even though we're inside a function body, we still don't want to
13684      call expand_expr to calculate the size of a variable-sized array.
13685      We haven't necessarily assigned RTL to all variables yet, so it's
13686      not safe to try to expand expressions involving them.  */
13687   immediate_size_expand = 0;
13688   cfun->x_dont_save_pending_sizes_p = 1;
13689
13690   /* If we're building a statement-tree, start the tree now.  */
13691   if (processing_template_decl || !expanding_p)
13692     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13693
13694   /* Let the user know we're compiling this function.  */
13695   announce_function (decl1);
13696
13697   /* Record the decl so that the function name is defined.
13698      If we already have a decl for this name, and it is a FUNCTION_DECL,
13699      use the old decl.  */
13700   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13701     {
13702       /* A specialization is not used to guide overload resolution.  */
13703       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13704           && ! DECL_FUNCTION_MEMBER_P (decl1))
13705         decl1 = pushdecl (decl1);
13706       else
13707         {
13708           /* We need to set the DECL_CONTEXT. */
13709           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13710             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13711           /* And make sure we have enough default args.  */
13712           check_default_args (decl1);
13713         }
13714       fntype = TREE_TYPE (decl1);
13715     }
13716
13717   /* Reset these in case the call to pushdecl changed them.  */
13718   current_function_decl = decl1;
13719   cfun->decl = decl1;
13720
13721   /* Initialize the per-function data.  */
13722   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13723     {
13724       /* If we already parsed this function, and we're just expanding it
13725          now, restore saved state.  */
13726       struct binding_level *bl = current_binding_level;
13727       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13728       current_binding_level = bl;
13729
13730       /* This function is being processed in whole-function mode; we
13731          already did semantic analysis.  */
13732       cfun->x_whole_function_mode_p = 1;
13733
13734       /* If we decided that we didn't want to inline this function,
13735          make sure the back-end knows that.  */
13736       if (!current_function_cannot_inline)
13737         current_function_cannot_inline = cp_function_chain->cannot_inline;
13738
13739       /* We don't need the saved data anymore.  */
13740       free (DECL_SAVED_FUNCTION_DATA (decl1));
13741       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13742     }
13743   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13744     {
13745       /* We know that this was set up by `grokclassfn'.  We do not
13746          wait until `store_parm_decls', since evil parse errors may
13747          never get us to that point.  Here we keep the consistency
13748          between `current_class_type' and `current_class_ptr'.  */
13749       tree t = DECL_ARGUMENTS (decl1);
13750
13751       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13752                           162);
13753       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13754                           19990811);
13755
13756       cp_function_chain->x_current_class_ref
13757         = build_indirect_ref (t, NULL_PTR);
13758       cp_function_chain->x_current_class_ptr = t;
13759
13760       /* Constructors and destructors need to know whether they're "in
13761          charge" of initializing virtual base classes.  */
13762       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13763         current_in_charge_parm = TREE_CHAIN (t);
13764     }
13765
13766   if (DECL_INTERFACE_KNOWN (decl1))
13767     {
13768       tree ctx = decl_function_context (decl1);
13769
13770       if (DECL_NOT_REALLY_EXTERN (decl1))
13771         DECL_EXTERNAL (decl1) = 0;
13772
13773       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13774           && TREE_PUBLIC (ctx))
13775         /* This is a function in a local class in an extern inline
13776            function.  */
13777         comdat_linkage (decl1);
13778     }
13779   /* If this function belongs to an interface, it is public.
13780      If it belongs to someone else's interface, it is also external.
13781      This only affects inlines and template instantiations.  */
13782   else if (interface_unknown == 0
13783            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13784                || flag_alt_external_templates))
13785     {
13786       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13787           || processing_template_decl)
13788         {
13789           DECL_EXTERNAL (decl1)
13790             = (interface_only
13791                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13792                    && !DECL_VINDEX (decl1)));
13793
13794           /* For WIN32 we also want to put these in linkonce sections.  */
13795           maybe_make_one_only (decl1);
13796         }
13797       else
13798         DECL_EXTERNAL (decl1) = 0;
13799       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13800       DECL_INTERFACE_KNOWN (decl1) = 1;
13801     }
13802   else if (interface_unknown && interface_only
13803            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13804                || flag_alt_external_templates))
13805     {
13806       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13807          interface, we will have interface_only set but not
13808          interface_known.  In that case, we don't want to use the normal
13809          heuristics because someone will supply a #pragma implementation
13810          elsewhere, and deducing it here would produce a conflict.  */
13811       comdat_linkage (decl1);
13812       DECL_EXTERNAL (decl1) = 0;
13813       DECL_INTERFACE_KNOWN (decl1) = 1;
13814       DECL_DEFER_OUTPUT (decl1) = 1;
13815     }
13816   else
13817     {
13818       /* This is a definition, not a reference.
13819          So clear DECL_EXTERNAL.  */
13820       DECL_EXTERNAL (decl1) = 0;
13821
13822       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13823           && ! DECL_INTERFACE_KNOWN (decl1)
13824           /* Don't try to defer nested functions for now.  */
13825           && ! decl_function_context (decl1))
13826         DECL_DEFER_OUTPUT (decl1) = 1;
13827       else
13828         DECL_INTERFACE_KNOWN (decl1) = 1;
13829     }
13830
13831   if (doing_semantic_analysis_p ())
13832     {
13833       pushlevel (0);
13834       current_binding_level->parm_flag = 1;
13835     }
13836
13837   if (attrs)
13838     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13839
13840   if (!building_stmt_tree ())
13841     GNU_xref_function (decl1, current_function_parms);
13842
13843   /* We need to do this even if we aren't expanding yet so that
13844      assemble_external works.  */
13845   make_function_rtl (decl1);
13846
13847   /* Promote the value to int before returning it.  */
13848   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13849     restype = type_promotes_to (restype);
13850
13851   /* If this fcn was already referenced via a block-scope `extern' decl
13852      (or an implicit decl), propagate certain information about the usage.  */
13853   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13854     TREE_ADDRESSABLE (decl1) = 1;
13855
13856   if (DECL_RESULT (decl1) == NULL_TREE)
13857     {
13858       DECL_RESULT (decl1)
13859         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13860       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13861       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13862     }
13863
13864   ++function_depth;
13865
13866   if (DECL_DESTRUCTOR_P (decl1))
13867     {
13868       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13869       DECL_CONTEXT (dtor_label) = current_function_decl;
13870     }
13871   /* Under the old ABI we return `this' from constructors, so we make
13872      ordinary `return' statements in constructors jump to CTOR_LABEL;
13873      from there we return `this'.  Under the new ABI, we don't bother
13874      with any of this.  By not setting CTOR_LABEL the remainder of the
13875      machinery is automatically disabled.  */
13876   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13877     {
13878       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13879       DECL_CONTEXT (ctor_label) = current_function_decl;
13880     }
13881
13882   return 1;
13883 }
13884 \f
13885 /* Called after store_parm_decls for a function-try-block.  */
13886
13887 void
13888 expand_start_early_try_stmts ()
13889 {
13890   expand_start_try_stmts ();
13891 }
13892
13893 /* Store the parameter declarations into the current function declaration.
13894    This is called after parsing the parameter declarations, before
13895    digesting the body of the function.
13896
13897    Also install to binding contour return value identifier, if any.  */
13898
13899 void
13900 store_parm_decls ()
13901 {
13902   register tree fndecl = current_function_decl;
13903   register tree parm;
13904   int parms_have_cleanups = 0;
13905   tree cleanups = NULL_TREE;
13906
13907   /* This is a list of types declared among parms in a prototype.  */
13908   tree parmtags = current_function_parm_tags;
13909
13910   /* This is a chain of any other decls that came in among the parm
13911      declarations.  If a parm is declared with  enum {foo, bar} x;
13912      then CONST_DECLs for foo and bar are put here.  */
13913   tree nonparms = NULL_TREE;
13914
13915   /* Create a binding level for the parms.  */
13916   if (!building_stmt_tree ())
13917     expand_start_bindings (2);
13918
13919   if (current_function_parms)
13920     {
13921       /* This case is when the function was defined with an ANSI prototype.
13922          The parms already have decls, so we need not do anything here
13923          except record them as in effect
13924          and complain if any redundant old-style parm decls were written.  */
13925
13926       tree specparms = current_function_parms;
13927       tree next;
13928
13929       if (doing_semantic_analysis_p ())
13930         {
13931           /* Must clear this because it might contain TYPE_DECLs declared
13932              at class level.  */
13933           storedecls (NULL_TREE);
13934
13935           /* If we're doing semantic analysis, then we'll call pushdecl
13936              for each of these.  We must do them in reverse order so that
13937              they end in the correct forward order.  */
13938           specparms = nreverse (specparms);
13939         }
13940
13941       for (parm = specparms; parm; parm = next)
13942         {
13943           next = TREE_CHAIN (parm);
13944           if (TREE_CODE (parm) == PARM_DECL)
13945             {
13946               tree type = TREE_TYPE (parm);
13947
13948               if (doing_semantic_analysis_p ())
13949                 {
13950                   tree cleanup;
13951
13952                   if (DECL_NAME (parm) == NULL_TREE
13953                       || TREE_CODE (parm) != VOID_TYPE)
13954                     pushdecl (parm);
13955                   else
13956                     cp_error ("parameter `%D' declared void", parm);
13957
13958                   cleanup = (processing_template_decl
13959                              ? NULL_TREE
13960                              : maybe_build_cleanup (parm));
13961
13962                   if (cleanup)
13963                     cleanups = tree_cons (parm, cleanup, cleanups);
13964                 }
13965               else if (type != error_mark_node
13966                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13967                 parms_have_cleanups = 1;
13968             }
13969           else
13970             {
13971               /* If we find an enum constant or a type tag,
13972                  put it aside for the moment.  */
13973               TREE_CHAIN (parm) = NULL_TREE;
13974               nonparms = chainon (nonparms, parm);
13975             }
13976         }
13977
13978       if (doing_semantic_analysis_p ())
13979         {
13980           /* Get the decls in their original chain order
13981              and record in the function.  This is all and only the
13982              PARM_DECLs that were pushed into scope by the loop above.  */
13983           DECL_ARGUMENTS (fndecl) = getdecls ();
13984           storetags (chainon (parmtags, gettags ()));
13985         }
13986     }
13987   else
13988     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13989
13990   /* Now store the final chain of decls for the arguments
13991      as the decl-chain of the current lexical scope.
13992      Put the enumerators in as well, at the front so that
13993      DECL_ARGUMENTS is not modified.  */
13994   if (doing_semantic_analysis_p ())
13995     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13996
13997   /* Initialize the RTL code for the function.  */
13998   DECL_SAVED_INSNS (fndecl) = 0;
13999   if (! building_stmt_tree ())
14000     expand_function_start (fndecl, parms_have_cleanups);
14001
14002   current_function_parms_stored = 1;
14003
14004   /* If this function is `main', emit a call to `__main'
14005      to run global initializers, etc.  */
14006   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
14007     expand_main_function ();
14008
14009   /* Now that we have initialized the parms, we can start their
14010      cleanups.  We cannot do this before, since expand_decl_cleanup
14011      should not be called before the parm can be used.  */
14012   while (cleanups)
14013     {
14014       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14015                            TREE_VALUE (cleanups));
14016       cleanups = TREE_CHAIN (cleanups);
14017     }
14018
14019   /* Create a binding contour which can be used to catch
14020      cleanup-generated temporaries.  Also, if the return value needs or
14021      has initialization, deal with that now.  */
14022   if (parms_have_cleanups)
14023     {
14024       pushlevel (0);
14025       if (!building_stmt_tree ())
14026         expand_start_bindings (2);
14027     }
14028
14029   /* Do the starting of the exception specifications, if we have any.  */
14030   if (flag_exceptions && !processing_template_decl
14031       && flag_enforce_eh_specs
14032       && building_stmt_tree ()
14033       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14034     current_eh_spec_try_block = expand_start_eh_spec ();
14035 }
14036
14037 /* Bind a name and initialization to the return value of
14038    the current function.  */
14039
14040 void
14041 store_return_init (decl)
14042      tree decl;
14043 {
14044   /* If this named return value comes in a register, put it in a
14045      pseudo-register.  */
14046   if (DECL_REGISTER (decl))
14047     {
14048       original_result_rtx = DECL_RTL (decl);
14049       /* Note that the mode of the old DECL_RTL may be wider than the
14050          mode of DECL_RESULT, depending on the calling conventions for
14051          the processor.  For example, on the Alpha, a 32-bit integer
14052          is returned in a DImode register -- the DECL_RESULT has
14053          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14054          here, we use the mode the back-end has already assigned for
14055          the return value.  */
14056       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14057       if (TREE_ADDRESSABLE (decl))
14058         put_var_into_stack (decl);
14059     }
14060 }
14061
14062 \f
14063 /* We have finished doing semantic analysis on DECL, but have not yet
14064    generated RTL for its body.  Save away our current state, so that
14065    when we want to generate RTL later we know what to do.  */
14066
14067 static void
14068 save_function_data (decl)
14069      tree decl;
14070 {
14071   struct language_function *f;
14072
14073   /* Save the language-specific per-function data so that we can
14074      get it back when we really expand this function.  */
14075   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14076                       19990908);
14077
14078   /* Make a copy.  */
14079   f = ((struct language_function *)
14080        xmalloc (sizeof (struct language_function)));
14081   bcopy ((char *) cp_function_chain, (char *) f,
14082          sizeof (struct language_function));
14083   DECL_SAVED_FUNCTION_DATA (decl) = f;
14084
14085   /* Clear out the bits we don't need.  */
14086   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14087   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14088   f->x_result_rtx = NULL_RTX;
14089   f->x_named_label_uses = NULL;
14090   f->bindings = NULL;
14091
14092   /* When we get back here again, we will be expanding.  */
14093   f->x_expanding_p = 1;
14094
14095   /* If we've already decided that we cannot inline this function, we
14096      must remember that fact when we actually go to expand the
14097      function.  */
14098   f->cannot_inline = current_function_cannot_inline;
14099 }
14100
14101 /* At the end of every constructor we generate to code to return
14102    `this'.  Do that now.  */
14103
14104 static void
14105 finish_constructor_body ()
14106 {
14107   /* Any return from a constructor will end up here.  */
14108   if (ctor_label)
14109     add_tree (build_stmt (LABEL_STMT, ctor_label));
14110
14111   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14112      generate the return, rather than a goto to CTOR_LABEL.  */
14113   ctor_label = NULL_TREE;
14114   /* In check_return_expr we translate an empty return from a
14115      constructor to a return of `this'.  */
14116   finish_return_stmt (NULL_TREE);
14117   /* Mark the end of the constructor.  */
14118   add_tree (build_stmt (CTOR_STMT));
14119 }
14120
14121 /* At the end of every destructor we generate code to restore virtual
14122    function tables to the values desired by base classes and to call
14123    to base class destructors.  Do that now.  */
14124
14125 static void
14126 finish_destructor_body ()
14127 {
14128   tree compound_stmt;
14129   tree virtual_size;
14130   tree exprstmt;
14131   tree if_stmt;
14132
14133   /* Create a block to contain all the extra code.  */
14134   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14135
14136   /* Any return from a destructor will end up here.  */
14137   add_tree (build_stmt (LABEL_STMT, dtor_label));
14138
14139   /* Generate the code to call destructor on base class.  If this
14140      destructor belongs to a class with virtual functions, then set
14141      the virtual function table pointer to represent the type of our
14142      base class.  */
14143
14144   /* This side-effect makes call to `build_delete' generate the code
14145      we have to have at the end of this destructor.  `build_delete'
14146      will set the flag again.  */
14147   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14148
14149   exprstmt = build_delete (current_class_type,
14150                            current_class_ref,
14151                            sfk_base_destructor,
14152                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14153                            0);
14154
14155   if (exprstmt != error_mark_node
14156       && (TREE_CODE (exprstmt) != NOP_EXPR
14157           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14158           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14159     {
14160       if (exprstmt != void_zero_node)
14161         /* Don't call `expand_expr_stmt' if we're not going to do
14162            anything, since -Wall will give a diagnostic.  */
14163         finish_expr_stmt (exprstmt);
14164
14165       /* Run destructors for all virtual baseclasses.  */
14166       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14167         {
14168           tree vbases;
14169           tree if_stmt;
14170
14171           if_stmt = begin_if_stmt ();
14172           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14173                                       current_in_charge_parm,
14174                                       integer_two_node),
14175                                if_stmt);
14176
14177           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14178           /* The CLASSTYPE_VBASECLASSES list is in initialization
14179              order, so we have to march through it in reverse order.  */
14180           for (vbases = nreverse (copy_list (vbases));
14181                vbases;
14182                vbases = TREE_CHAIN (vbases))
14183             {
14184               tree vbase = TREE_VALUE (vbases);
14185
14186               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14187                 {
14188                   tree vb = get_vbase
14189                     (BINFO_TYPE (vbase),
14190                      TYPE_BINFO (current_class_type));
14191                   finish_expr_stmt
14192                     (build_scoped_method_call
14193                      (current_class_ref, vb, base_dtor_identifier,
14194                       NULL_TREE));
14195                 }
14196             }
14197
14198           finish_then_clause (if_stmt);
14199           finish_if_stmt ();
14200         }
14201     }
14202
14203   virtual_size = c_sizeof (current_class_type);
14204
14205   /* At the end, call delete if that's what's requested.  */
14206
14207   /* FDIS sez: At the point of definition of a virtual destructor
14208      (including an implicit definition), non-placement operator delete
14209      shall be looked up in the scope of the destructor's class and if
14210      found shall be accessible and unambiguous.
14211
14212      This is somewhat unclear, but I take it to mean that if the class
14213      only defines placement deletes we don't do anything here.  So we
14214      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14215      they ever try to delete one of these.  */
14216   exprstmt = build_op_delete_call
14217     (DELETE_EXPR, current_class_ptr, virtual_size,
14218      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14219
14220   if_stmt = begin_if_stmt ();
14221   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14222                               current_in_charge_parm,
14223                               integer_one_node),
14224                        if_stmt);
14225   finish_expr_stmt (exprstmt);
14226   finish_then_clause (if_stmt);
14227   finish_if_stmt ();
14228
14229   /* Close the block we started above.  */
14230   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14231 }
14232
14233 /* Finish up a function declaration and compile that function
14234    all the way to assembler language output.  The free the storage
14235    for the function definition.
14236
14237    FLAGS is a bitwise or of the following values:
14238      1 - CALL_POPLEVEL
14239        An extra call to poplevel (and expand_end_bindings) must be
14240        made to take care of the binding contour for the base
14241        initializers.  This is only relevant for constructors.
14242      2 - INCLASS_INLINE
14243        We just finished processing the body of an in-class inline
14244        function definition.  (This processing will have taken place
14245        after the class definition is complete.)  */
14246
14247 tree
14248 finish_function (flags)
14249      int flags;
14250 {
14251   register tree fndecl = current_function_decl;
14252   tree fntype, ctype = NULL_TREE;
14253   /* Label to use if this function is supposed to return a value.  */
14254   tree no_return_label = NULL_TREE;
14255   int call_poplevel = (flags & 1) != 0;
14256   int inclass_inline = (flags & 2) != 0;
14257   int expand_p;
14258   int nested;
14259   int current_line = lineno;
14260
14261   /* When we get some parse errors, we can end up without a
14262      current_function_decl, so cope.  */
14263   if (fndecl == NULL_TREE)
14264     return error_mark_node;
14265
14266   nested = function_depth > 1;
14267   fntype = TREE_TYPE (fndecl);
14268
14269   /*  TREE_READONLY (fndecl) = 1;
14270       This caused &foo to be of type ptr-to-const-function
14271       which then got a warning when stored in a ptr-to-function variable.  */
14272
14273   /* This happens on strange parse errors.  */
14274   if (! current_function_parms_stored)
14275     {
14276       call_poplevel = 0;
14277       store_parm_decls ();
14278     }
14279
14280   /* For a cloned function, we've already got all the code we need;
14281      there's no need to add any extra bits.  */
14282   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14283     ;
14284   else if (building_stmt_tree ())
14285     {
14286       if (DECL_CONSTRUCTOR_P (fndecl))
14287         {
14288           finish_constructor_body ();
14289           if (call_poplevel)
14290             do_poplevel ();
14291         }
14292       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14293         finish_destructor_body ();
14294       else if (DECL_MAIN_P (fndecl))
14295         {
14296           /* Make it so that `main' always returns 0 by default.  */
14297 #ifdef VMS
14298           finish_return_stmt (integer_one_node);
14299 #else
14300           finish_return_stmt (integer_zero_node);
14301 #endif
14302         }
14303
14304       /* Finish dealing with exception specifiers.  */
14305       if (flag_exceptions && !processing_template_decl
14306           && flag_enforce_eh_specs
14307           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14308         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14309                             (TREE_TYPE (current_function_decl)),
14310                             current_eh_spec_try_block);
14311     }
14312   else
14313     {
14314 #if 0
14315       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14316         {
14317           /* Keep this code around in case we later want to control debug info
14318              based on whether a type is "used".  (jason 1999-11-11) */
14319
14320           tree ttype = target_type (fntype);
14321           tree parmdecl;
14322
14323           if (IS_AGGR_TYPE (ttype))
14324             /* Let debugger know it should output info for this type.  */
14325             note_debug_info_needed (ttype);
14326
14327           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14328             {
14329               ttype = target_type (TREE_TYPE (parmdecl));
14330               if (IS_AGGR_TYPE (ttype))
14331                 /* Let debugger know it should output info for this type.  */
14332                 note_debug_info_needed (ttype);
14333             }
14334         }
14335 #endif
14336
14337       /* Clean house because we will need to reorder insns here.  */
14338       do_pending_stack_adjust ();
14339
14340       if (dtor_label)
14341         ;
14342       else if (DECL_CONSTRUCTOR_P (fndecl))
14343         {
14344           if (call_poplevel)
14345             do_poplevel ();
14346         }
14347       else if (return_label != NULL_RTX
14348                && flag_this_is_variable <= 0
14349                && current_function_return_value == NULL_TREE
14350                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14351         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14352
14353       if (flag_exceptions)
14354         expand_exception_blocks ();
14355
14356       /* If this function is supposed to return a value, ensure that
14357          we do not fall into the cleanups by mistake.  The end of our
14358          function will look like this:
14359
14360          user code (may have return stmt somewhere)
14361          goto no_return_label
14362          cleanup_label:
14363          cleanups
14364          goto return_label
14365          no_return_label:
14366          NOTE_INSN_FUNCTION_END
14367          return_label:
14368          things for return
14369
14370          If the user omits a return stmt in the USER CODE section, we
14371          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14372          Otherwise, we won't.  */
14373       if (no_return_label)
14374         {
14375           DECL_CONTEXT (no_return_label) = fndecl;
14376           DECL_INITIAL (no_return_label) = error_mark_node;
14377           DECL_SOURCE_FILE (no_return_label) = input_filename;
14378           DECL_SOURCE_LINE (no_return_label) = current_line;
14379           expand_goto (no_return_label);
14380         }
14381
14382       if (cleanup_label)
14383         {
14384           /* Remove the binding contour which is used
14385              to catch cleanup-generated temporaries.  */
14386           expand_end_bindings (0, 0, 0);
14387           poplevel (0, 0, 0);
14388
14389           /* Emit label at beginning of cleanup code for parameters.  */
14390           emit_label (cleanup_label);
14391         }
14392
14393       /* Get return value into register if that's where it's supposed
14394          to be.  */
14395       if (original_result_rtx)
14396         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14397
14398       /* Finish building code that will trigger warnings if users forget
14399          to make their functions return values.  */
14400       if (no_return_label || cleanup_label)
14401         emit_jump (return_label);
14402       if (no_return_label)
14403         {
14404           /* We don't need to call `expand_*_return' here because we
14405              don't need any cleanups here--this path of code is only
14406              for error checking purposes.  */
14407           expand_label (no_return_label);
14408         }
14409
14410       /* We hard-wired immediate_size_expand to zero in
14411          start_function.  Expand_function_end will decrement this
14412          variable.  So, we set the variable to one here, so that after
14413          the decrement it will remain zero.  */
14414       immediate_size_expand = 1;
14415
14416       /* Generate rtl for function exit.  */
14417       expand_function_end (input_filename, current_line, 1);
14418     }
14419
14420   /* We have to save this value here in case
14421      maybe_end_member_template_processing decides to pop all the
14422      template parameters.  */
14423   expand_p = !building_stmt_tree ();
14424
14425   /* If we're saving up tree structure, tie off the function now.  */
14426   if (!expand_p)
14427     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14428
14429   /* This must come after expand_function_end because cleanups might
14430      have declarations (from inline functions) that need to go into
14431      this function's blocks.  */
14432   if (doing_semantic_analysis_p ())
14433     {
14434       if (current_binding_level->parm_flag != 1)
14435         my_friendly_abort (122);
14436       poplevel (1, 0, 1);
14437     }
14438
14439   /* Remember that we were in class scope.  */
14440   if (current_class_name)
14441     ctype = current_class_type;
14442
14443   /* Must mark the RESULT_DECL as being in this function.  */
14444   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14445
14446   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14447      to the FUNCTION_DECL node itself.  */
14448   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14449
14450   /* Save away current state, if appropriate.  */
14451   if (!expanding_p && !processing_template_decl)
14452     save_function_data (fndecl);
14453
14454   /* If this function calls `setjmp' it cannot be inlined.  When
14455      `longjmp' is called it is not guaranteed to restore the value of
14456      local variables that have been modified since the call to
14457      `setjmp'.  So, if were to inline this function into some caller
14458      `c', then when we `longjmp', we might not restore all variables
14459      in `c'.  (It might seem, at first blush, that there's no way for
14460      this function to modify local variables in `c', but their
14461      addresses may have been stored somewhere accessible to this
14462      function.)  */
14463   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14464     DECL_UNINLINABLE (fndecl) = 1;
14465
14466   if (expand_p)
14467     {
14468       int returns_null;
14469       int returns_value;
14470
14471       /* So we can tell if jump_optimize sets it to 1.  */
14472       can_reach_end = 0;
14473
14474       /* Before we call rest_of_compilation (which will pop the
14475          CURRENT_FUNCTION), we must save these values.  */
14476       returns_null = current_function_returns_null;
14477       returns_value = current_function_returns_value;
14478
14479       /* If this is a nested function (like a template instantiation
14480          that we're compiling in the midst of compiling something
14481          else), push a new GC context.  That will keep local variables
14482          on the stack from being collected while we're doing the
14483          compilation of this function.  */
14484       if (function_depth > 1)
14485         ggc_push_context ();
14486
14487       /* Run the optimizers and output the assembler code for this
14488          function.  */
14489       rest_of_compilation (fndecl);
14490
14491       /* Undo the call to ggc_push_context above.  */
14492       if (function_depth > 1)
14493         ggc_pop_context ();
14494
14495       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14496         {
14497           /* Set DECL_EXTERNAL so that assemble_external will be called as
14498              necessary.  We'll clear it again in finish_file.  */
14499           if (! DECL_EXTERNAL (fndecl))
14500             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14501           DECL_EXTERNAL (fndecl) = 1;
14502           defer_fn (fndecl);
14503         }
14504
14505 #if 0
14506       /* Keep this code around in case we later want to control debug info
14507          based on whether a type is "used".  (jason 1999-11-11) */
14508
14509       if (ctype && TREE_ASM_WRITTEN (fndecl))
14510         note_debug_info_needed (ctype);
14511 #endif
14512
14513       /* If this function is marked with the constructor attribute,
14514          add it to the list of functions to be called along with
14515          constructors from static duration objects.  */
14516       if (DECL_STATIC_CONSTRUCTOR (fndecl))
14517         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14518
14519       /* If this function is marked with the destructor attribute,
14520          add it to the list of functions to be called along with
14521          destructors from static duration objects.  */
14522       if (DECL_STATIC_DESTRUCTOR (fndecl))
14523         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14524
14525       if (DECL_NAME (DECL_RESULT (fndecl)))
14526         returns_value |= can_reach_end;
14527       else
14528         returns_null |= can_reach_end;
14529
14530       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14531         warning ("`noreturn' function does return");
14532       else if (returns_null
14533                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14534         {
14535           /* Always complain if there's just no return statement.  */
14536           if (!returns_value)
14537             warning ("no return statement in function returning non-void");
14538           else if (warn_return_type || pedantic)
14539             /* If this function returns non-void and control can drop through,
14540                complain.  */
14541             warning ("control reaches end of non-void function");
14542         }
14543     }
14544   else
14545     {
14546       /* Clear out memory we no longer need.  */
14547       free_after_parsing (cfun);
14548       /* Since we never call rest_of_compilation, we never clear
14549          CFUN.  Do so explicitly.  */
14550       free_after_compilation (cfun);
14551       cfun = NULL;
14552     }
14553
14554   /* If this is a in-class inline definition, we may have to pop the
14555      bindings for the template parameters that we added in
14556      maybe_begin_member_template_processing when start_function was
14557      called.  */
14558   if (inclass_inline)
14559     maybe_end_member_template_processing ();
14560
14561   /* Leave the scope of the class.  */
14562   if (ctype)
14563     pop_nested_class ();
14564
14565   --function_depth;
14566
14567   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14568       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14569     {
14570       tree t;
14571
14572       /* Stop pointing to the local nodes about to be freed.  */
14573       /* But DECL_INITIAL must remain nonzero so we know this
14574          was an actual function definition.  */
14575       DECL_INITIAL (fndecl) = error_mark_node;
14576       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14577         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14578     }
14579
14580   /* Clean up.  */
14581   if (! nested)
14582     {
14583       /* Let the error reporting routines know that we're outside a
14584          function.  For a nested function, this value is used in
14585          pop_cp_function_context and then reset via pop_function_context.  */
14586       current_function_decl = NULL_TREE;
14587       /* We don't really care about obstacks, but the middle-end
14588          sometimes cares on what obstck things are located.  */
14589       permanent_allocation (1);
14590     }
14591
14592   return fndecl;
14593 }
14594 \f
14595 /* Create the FUNCTION_DECL for a function definition.
14596    DECLSPECS and DECLARATOR are the parts of the declaration;
14597    they describe the return type and the name of the function,
14598    but twisted together in a fashion that parallels the syntax of C.
14599
14600    This function creates a binding context for the function body
14601    as well as setting up the FUNCTION_DECL in current_function_decl.
14602
14603    Returns a FUNCTION_DECL on success.
14604
14605    If the DECLARATOR is not suitable for a function (it defines a datum
14606    instead), we return 0, which tells yyparse to report a parse error.
14607
14608    May return void_type_node indicating that this method is actually
14609    a friend.  See grokfield for more details.
14610
14611    Came here with a `.pushlevel' .
14612
14613    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14614    CHANGES TO CODE IN `grokfield'.  */
14615
14616 tree
14617 start_method (declspecs, declarator, attrlist)
14618      tree declarator, declspecs, attrlist;
14619 {
14620   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14621                                 attrlist);
14622
14623   /* Something too ugly to handle.  */
14624   if (fndecl == NULL_TREE)
14625     return NULL_TREE;
14626
14627   /* Pass friends other than inline friend functions back.  */
14628   if (fndecl == void_type_node)
14629     return fndecl;
14630
14631   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14632     /* Not a function, tell parser to report parse error.  */
14633     return NULL_TREE;
14634
14635   if (DECL_IN_AGGR_P (fndecl))
14636     {
14637       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14638         {
14639           if (DECL_CONTEXT (fndecl)
14640               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14641             cp_error ("`%D' is already defined in class `%T'", fndecl,
14642                       DECL_CONTEXT (fndecl));
14643         }
14644       return void_type_node;
14645     }
14646
14647   check_template_shadow (fndecl);
14648
14649   DECL_THIS_INLINE (fndecl) = 1;
14650
14651   if (flag_default_inline)
14652     DECL_INLINE (fndecl) = 1;
14653
14654   /* We process method specializations in finish_struct_1.  */
14655   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14656     fndecl = push_template_decl (fndecl);
14657
14658   if (! DECL_FRIEND_P (fndecl))
14659     {
14660       if (TREE_CHAIN (fndecl))
14661         {
14662           fndecl = copy_node (fndecl);
14663           TREE_CHAIN (fndecl) = NULL_TREE;
14664         }
14665
14666       if (DECL_CONSTRUCTOR_P (fndecl))
14667         {
14668           if (! grok_ctor_properties (current_class_type, fndecl))
14669             return void_type_node;
14670         }
14671       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14672         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14673     }
14674
14675   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14676
14677   /* Make a place for the parms */
14678   pushlevel (0);
14679   current_binding_level->parm_flag = 1;
14680
14681   DECL_IN_AGGR_P (fndecl) = 1;
14682   return fndecl;
14683 }
14684
14685 /* Go through the motions of finishing a function definition.
14686    We don't compile this method until after the whole class has
14687    been processed.
14688
14689    FINISH_METHOD must return something that looks as though it
14690    came from GROKFIELD (since we are defining a method, after all).
14691
14692    This is called after parsing the body of the function definition.
14693    STMTS is the chain of statements that makes up the function body.
14694
14695    DECL is the ..._DECL that `start_method' provided.  */
14696
14697 tree
14698 finish_method (decl)
14699      tree decl;
14700 {
14701   register tree fndecl = decl;
14702   tree old_initial;
14703
14704   register tree link;
14705
14706   if (decl == void_type_node)
14707     return decl;
14708
14709   old_initial = DECL_INITIAL (fndecl);
14710
14711   /* Undo the level for the parms (from start_method).
14712      This is like poplevel, but it causes nothing to be
14713      saved.  Saving information here confuses symbol-table
14714      output routines.  Besides, this information will
14715      be correctly output when this method is actually
14716      compiled.  */
14717
14718   /* Clear out the meanings of the local variables of this level;
14719      also record in each decl which block it belongs to.  */
14720
14721   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14722     {
14723       if (DECL_NAME (link) != NULL_TREE)
14724         pop_binding (DECL_NAME (link), link);
14725       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14726       DECL_CONTEXT (link) = NULL_TREE;
14727     }
14728
14729   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14730                       (HOST_WIDE_INT) current_binding_level->level_chain,
14731                       current_binding_level->parm_flag,
14732                       current_binding_level->keep);
14733
14734   poplevel (0, 0, 0);
14735
14736   DECL_INITIAL (fndecl) = old_initial;
14737
14738   /* We used to check if the context of FNDECL was different from
14739      current_class_type as another way to get inside here.  This didn't work
14740      for String.cc in libg++.  */
14741   if (DECL_FRIEND_P (fndecl))
14742     {
14743       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14744         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14745       decl = void_type_node;
14746     }
14747
14748   return decl;
14749 }
14750 \f
14751 /* Called when a new struct TYPE is defined.
14752    If this structure or union completes the type of any previous
14753    variable declaration, lay it out and output its rtl.  */
14754
14755 void
14756 hack_incomplete_structures (type)
14757      tree type;
14758 {
14759   tree *list;
14760   struct binding_level *level;
14761
14762   if (!type) /* Don't do this for class templates.  */
14763     return;
14764
14765   if (namespace_bindings_p ())
14766     {
14767       level = 0;
14768       list = &namespace_scope_incomplete;
14769     }
14770   else
14771     {
14772       level = innermost_nonclass_level ();
14773       list = &level->incomplete;
14774     }
14775
14776   while (1)
14777     {
14778       while (*list)
14779         {
14780           tree decl = TREE_VALUE (*list);
14781           if ((decl && TREE_TYPE (decl) == type)
14782               || (TREE_TYPE (decl)
14783                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14784                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14785             {
14786               int toplevel = toplevel_bindings_p ();
14787               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14788                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14789                 layout_type (TREE_TYPE (decl));
14790               layout_decl (decl, 0);
14791               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14792               if (! toplevel)
14793                 {
14794                   tree cleanup;
14795                   expand_decl (decl);
14796                   cleanup = maybe_build_cleanup (decl);
14797                   expand_decl_init (decl);
14798                   if (! expand_decl_cleanup (decl, cleanup))
14799                     cp_error ("parser lost in parsing declaration of `%D'",
14800                               decl);
14801                 }
14802               *list = TREE_CHAIN (*list);
14803             }
14804           else
14805             list = &TREE_CHAIN (*list);
14806         }
14807
14808       /* Keep looking through artificial binding levels generated
14809          for local variables.  */
14810       if (level && level->keep == 2)
14811         {
14812           level = level->level_chain;
14813           list = &level->incomplete;
14814         }
14815       else
14816         break;
14817     }
14818 }
14819
14820 /* If DECL is of a type which needs a cleanup, build that cleanup
14821    here.  */
14822
14823 tree
14824 maybe_build_cleanup (decl)
14825      tree decl;
14826 {
14827   tree type = TREE_TYPE (decl);
14828
14829   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14830     {
14831       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14832       tree rval;
14833
14834       if (TREE_CODE (type) == ARRAY_TYPE)
14835         rval = decl;
14836       else
14837         {
14838           mark_addressable (decl);
14839           rval = build_unary_op (ADDR_EXPR, decl, 0);
14840         }
14841
14842       /* Optimize for space over speed here.  */
14843       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14844           || flag_expensive_optimizations)
14845         flags |= LOOKUP_NONVIRTUAL;
14846
14847       rval = build_delete (TREE_TYPE (rval), rval,
14848                            sfk_complete_destructor, flags, 0);
14849
14850       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14851           && ! TYPE_HAS_DESTRUCTOR (type))
14852         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14853                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14854
14855       return rval;
14856     }
14857   return 0;
14858 }
14859 \f
14860 /* Expand a C++ expression at the statement level.
14861    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14862    The C++ type checker should get all of these out when
14863    expressions are combined with other, type-providing, expressions,
14864    leaving only orphan expressions, such as:
14865
14866    &class::bar;         / / takes its address, but does nothing with it.  */
14867
14868 void
14869 cplus_expand_expr_stmt (exp)
14870      tree exp;
14871 {
14872 #if 0
14873   /* We should do this eventually, but right now this causes regex.o from
14874      libg++ to miscompile, and tString to core dump.  */
14875   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14876 #endif
14877
14878   /* If we don't do this, we end up down inside expand_expr
14879      trying to do TYPE_MODE on the ERROR_MARK, and really
14880      go outside the bounds of the type.  */
14881   if (exp != error_mark_node)
14882     expand_expr_stmt (exp);
14883 }
14884
14885 /* When a stmt has been parsed, this function is called.  */
14886
14887 void
14888 finish_stmt ()
14889 {
14890   /* Always assume this statement was not an expression statement.  If
14891      it actually was an expression statement, its our callers
14892      responsibility to fix this up.  */
14893   last_expr_type = NULL_TREE;
14894 }
14895
14896 /* DECL was originally constructed as a non-static member function,
14897    but turned out to be static.  Update it accordingly.  */
14898
14899 void
14900 revert_static_member_fn (decl)
14901      tree decl;
14902 {
14903   tree tmp;
14904   tree function = TREE_TYPE (decl);
14905   tree args = TYPE_ARG_TYPES (function);
14906
14907   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14908       != TYPE_UNQUALIFIED)
14909     cp_error ("static member function `%#D' declared with type qualifiers",
14910               *decl);
14911
14912   args = TREE_CHAIN (args);
14913   tmp = build_function_type (TREE_TYPE (function), args);
14914   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14915   tmp = build_exception_variant (tmp,
14916                                  TYPE_RAISES_EXCEPTIONS (function));
14917   TREE_TYPE (decl) = tmp;
14918   if (DECL_ARGUMENTS (decl))
14919     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14920   DECL_STATIC_FUNCTION_P (decl) = 1;
14921 }
14922
14923 /* Initialize the variables used during compilation of a C++
14924    function.  */
14925
14926 static void
14927 push_cp_function_context (f)
14928      struct function *f;
14929 {
14930   struct language_function *p
14931     = ((struct language_function *)
14932        xcalloc (1, sizeof (struct language_function)));
14933   f->language = p;
14934
14935   /* It takes an explicit call to expand_body to generate RTL for a
14936      function.  */
14937   expanding_p = 0;
14938
14939   /* Whenever we start a new function, we destroy temporaries in the
14940      usual way.  */
14941   current_stmt_tree->stmts_are_full_exprs_p = 1;
14942 }
14943
14944 /* Free the language-specific parts of F, now that we've finished
14945    compiling the function.  */
14946
14947 static void
14948 pop_cp_function_context (f)
14949      struct function *f;
14950 {
14951   if (f->language)
14952     free (f->language);
14953   f->language = 0;
14954 }
14955
14956 /* Mark P for GC.  */
14957
14958 static void
14959 mark_lang_function (p)
14960      struct language_function *p;
14961 {
14962   if (!p)
14963     return;
14964
14965   ggc_mark_tree (p->x_ctor_label);
14966   ggc_mark_tree (p->x_dtor_label);
14967   ggc_mark_tree (p->x_current_class_ptr);
14968   ggc_mark_tree (p->x_current_class_ref);
14969   ggc_mark_tree (p->x_eh_spec_try_block);
14970   ggc_mark_tree (p->x_scope_stmt_stack);
14971
14972   ggc_mark_rtx (p->x_result_rtx);
14973
14974   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14975   mark_stmt_tree (&p->x_stmt_tree);
14976   mark_binding_level (&p->bindings);
14977 }
14978
14979 /* Mark the language-specific data in F for GC.  */
14980
14981 static void
14982 mark_cp_function_context (f)
14983      struct function *f;
14984 {
14985   mark_lang_function (f->language);
14986 }
14987
14988 void
14989 lang_mark_false_label_stack (l)
14990      struct label_node *l;
14991 {
14992   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14993   my_friendly_assert (l == NULL, 19990904);
14994 }
14995
14996 void
14997 lang_mark_tree (t)
14998      tree t;
14999 {
15000   enum tree_code code = TREE_CODE (t);
15001   if (code == IDENTIFIER_NODE)
15002     {
15003       struct lang_identifier *li = (struct lang_identifier *) t;
15004       struct lang_id2 *li2 = li->x;
15005       ggc_mark_tree (li->namespace_bindings);
15006       ggc_mark_tree (li->bindings);
15007       ggc_mark_tree (li->class_value);
15008       ggc_mark_tree (li->class_template_info);
15009
15010       if (li2)
15011         {
15012           ggc_mark_tree (li2->label_value);
15013           ggc_mark_tree (li2->implicit_decl);
15014           ggc_mark_tree (li2->error_locus);
15015         }
15016     }
15017   else if (code == CPLUS_BINDING)
15018     {
15019       if (BINDING_HAS_LEVEL_P (t))
15020         mark_binding_level (&BINDING_LEVEL (t));
15021       else
15022         ggc_mark_tree (BINDING_SCOPE (t));
15023       ggc_mark_tree (BINDING_VALUE (t));
15024     }
15025   else if (code == OVERLOAD)
15026     ggc_mark_tree (OVL_FUNCTION (t));
15027   else if (code == TEMPLATE_PARM_INDEX)
15028     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15029   else if (TREE_CODE_CLASS (code) == 'd')
15030     {
15031       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15032
15033       if (ld)
15034         {
15035           ggc_mark (ld);
15036           if (!DECL_GLOBAL_CTOR_P (t)
15037               && !DECL_GLOBAL_DTOR_P (t)
15038               && !DECL_THUNK_P (t))
15039             ggc_mark_tree (ld->decl_flags.u2.access);
15040           else if (DECL_THUNK_P (t))
15041             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15042           ggc_mark_tree (ld->decl_flags.context);
15043           if (TREE_CODE (t) != NAMESPACE_DECL)
15044             ggc_mark_tree (ld->decl_flags.u.template_info);
15045           else
15046             mark_binding_level (&NAMESPACE_LEVEL (t));
15047           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15048             {
15049               ggc_mark_tree (ld->befriending_classes);
15050               ggc_mark_tree (ld->saved_tree);
15051               ggc_mark_tree (ld->cloned_function);
15052               if (!DECL_OVERLOADED_OPERATOR_P (t))
15053                 ggc_mark_tree (ld->u2.vtt_parm);
15054               if (TREE_CODE (t) == TYPE_DECL)
15055                 ggc_mark_tree (ld->u.sorted_fields);
15056               else if (TREE_CODE (t) == FUNCTION_DECL
15057                        && !DECL_PENDING_INLINE_P (t))
15058                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15059             }
15060         }
15061     }
15062   else if (TREE_CODE_CLASS (code) == 't')
15063     {
15064       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15065
15066       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15067                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15068         {
15069           ggc_mark (lt);
15070           ggc_mark_tree (lt->primary_base);
15071           ggc_mark_tree (lt->vfields);
15072           ggc_mark_tree (lt->vbases);
15073           ggc_mark_tree (lt->tags);
15074           ggc_mark_tree (lt->size);
15075           ggc_mark_tree (lt->pure_virtuals);
15076           ggc_mark_tree (lt->friend_classes);
15077           ggc_mark_tree (lt->rtti);
15078           ggc_mark_tree (lt->methods);
15079           ggc_mark_tree (lt->template_info);
15080           ggc_mark_tree (lt->befriending_classes);
15081         }
15082       else if (lt)
15083         /* In the case of pointer-to-member function types, the
15084            TYPE_LANG_SPECIFIC is really just a tree.  */
15085         ggc_mark_tree ((tree) lt);
15086     }
15087 }