gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* Process declarations and symbol lookup for C front end.
  24    Also constructs types; the standard scalar types at initialization,
  25    and structure, union, array and enum types when they are declared.  */
  26
  27 /* ??? not all decl nodes are given the most useful possible
  28    line numbers.  For example, the CONST_DECLs for enum values.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "tree.h"
  33 #include "rtl.h"
  34 #include "flags.h"
  35 #include "cp-tree.h"
  36 #include "decl.h"
  37 #include "lex.h"
  38 #include <signal.h>
  39 #include "obstack.h"
  40 #include "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45
  46 #define obstack_chunk_alloc xmalloc
  47 #define obstack_chunk_free free
  48
  49 extern tree builtin_return_address_fndecl;
  50
  51 extern struct obstack permanent_obstack;
  52 extern struct obstack* saveable_obstack;
  53
  54 extern int current_class_depth;
  55
  56 extern tree static_ctors, static_dtors;
  57
  58 extern int static_labelno;
  59
  60 extern tree current_namespace;
  61 extern tree global_namespace;
  62
  63 extern void (*print_error_function) PROTO((char *));
  64
  65 /* Stack of places to restore the search obstack back to.  */
  66
  67 /* Obstack used for remembering local class declarations (like
  68    enums and static (const) members.  */
  69 #include "stack.h"
  70 struct obstack decl_obstack;
  71 static struct stack_level *decl_stack;
  72
  73 #ifndef CHAR_TYPE_SIZE
  74 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  75 #endif
  76
  77 #ifndef SHORT_TYPE_SIZE
  78 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
  79 #endif
  80
  81 #ifndef INT_TYPE_SIZE
  82 #define INT_TYPE_SIZE BITS_PER_WORD
  83 #endif
  84
  85 #ifndef LONG_TYPE_SIZE
  86 #define LONG_TYPE_SIZE BITS_PER_WORD
  87 #endif
  88
  89 #ifndef LONG_LONG_TYPE_SIZE
  90 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
  91 #endif
  92
  93 #ifndef WCHAR_UNSIGNED
  94 #define WCHAR_UNSIGNED 0
  95 #endif
  96
  97 #ifndef FLOAT_TYPE_SIZE
  98 #define FLOAT_TYPE_SIZE BITS_PER_WORD
  99 #endif
 100
 101 #ifndef DOUBLE_TYPE_SIZE
 102 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 103 #endif
 104
 105 #ifndef LONG_DOUBLE_TYPE_SIZE
 106 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 107 #endif
 108
 109 #ifndef BOOL_TYPE_SIZE
 110 #ifdef SLOW_BYTE_ACCESS
 111 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
 112 #else
 113 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
 114 #endif
 115 #endif
 116
 117 /* We let tm.h override the types used here, to handle trivial differences
 118    such as the choice of unsigned int or long unsigned int for size_t.
 119    When machines start needing nontrivial differences in the size type,
 120    it would be best to do something here to figure out automatically
 121    from other information what type to use.  */
 122
 123 #ifndef SIZE_TYPE
 124 #define SIZE_TYPE "long unsigned int"
 125 #endif
 126
 127 #ifndef PTRDIFF_TYPE
 128 #define PTRDIFF_TYPE "long int"
 129 #endif
 130
 131 #ifndef WCHAR_TYPE
 132 #define WCHAR_TYPE "int"
 133 #endif
 134
 135 static tree grokparms                           PROTO((tree, int));
 136 static tree lookup_nested_type                  PROTO((tree, tree));
 137 static const char *redeclaration_error_message  PROTO((tree, tree));
 138
 139 static struct stack_level *push_decl_level PROTO((struct stack_level *,
 140                                                   struct obstack *));
 141 static void push_binding_level PROTO((struct binding_level *, int,
 142                                       int));
 143 static void pop_binding_level PROTO((void));
 144 static void suspend_binding_level PROTO((void));
 145 static void resume_binding_level PROTO((struct binding_level *));
 146 static struct binding_level *make_binding_level PROTO((void));
 147 static void declare_namespace_level PROTO((void));
 148 static void signal_catch PROTO((int)) ATTRIBUTE_NORETURN;
 149 static void storedecls PROTO((tree));
 150 static void storetags PROTO((tree));
 151 static void require_complete_types_for_parms PROTO((tree));
 152 static void push_overloaded_decl_1 PROTO((tree));
 153 static int ambi_op_p PROTO((tree));
 154 static int unary_op_p PROTO((tree));
 155 static tree store_bindings PROTO((tree, tree));
 156 static tree lookup_tag_reverse PROTO((tree, tree));
 157 static tree obscure_complex_init PROTO((tree, tree));
 158 static tree maybe_build_cleanup_1 PROTO((tree, tree));
 159 static tree lookup_name_real PROTO((tree, int, int, int));
 160 static void warn_extern_redeclared_static PROTO((tree, tree));
 161 static void grok_reference_init PROTO((tree, tree, tree));
 162 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
 163                               enum overload_flags, tree,
 164                               tree, tree, int, int, int, int, int, int, tree));
 165 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
 166 static tree lookup_tag PROTO((enum tree_code, tree,
 167                               struct binding_level *, int));
 168 static void set_identifier_type_value_with_scope
 169         PROTO((tree, tree, struct binding_level *));
 170 static void record_builtin_type PROTO((enum rid, const char *, tree));
 171 static void record_unknown_type PROTO((tree, const char *));
 172 static int member_function_or_else PROTO((tree, tree, const char *));
 173 static void bad_specifiers PROTO((tree, const char *, int, int, int, int,
 174                                   int));
 175 static void lang_print_error_function PROTO((char *));
 176 static tree maybe_process_template_type_declaration PROTO((tree, int, struct binding_level*));
 177 static void check_for_uninitialized_const_var PROTO((tree));
 178 static unsigned long typename_hash PROTO((hash_table_key));
 179 static boolean typename_compare PROTO((hash_table_key, hash_table_key));
 180 static void push_binding PROTO((tree, tree, struct binding_level*));
 181 static int add_binding PROTO((tree, tree));
 182 static void pop_binding PROTO((tree, tree));
 183 static tree local_variable_p PROTO((tree));
 184 static tree find_binding PROTO((tree, tree));
 185 static tree select_decl PROTO((tree, int));
 186 static tree unqualified_namespace_lookup PROTO((tree, int));
 187 static int lookup_flags PROTO((int, int));
 188 static tree qualify_lookup PROTO((tree, int));
 189 static tree record_builtin_java_type PROTO((const char *, int));
 190 static const char *tag_name PROTO((enum tag_types code));
 191 static void find_class_binding_level PROTO((void));
 192 static struct binding_level *innermost_nonclass_level PROTO((void));
 193
 194 #if defined (DEBUG_CP_BINDING_LEVELS)
 195 static void indent PROTO((void));
 196 #endif
 197
 198 /* A node which has tree code ERROR_MARK, and whose type is itself.
 199    All erroneous expressions are replaced with this node.  All functions
 200    that accept nodes as arguments should avoid generating error messages
 201    if this node is one of the arguments, since it is undesirable to get
 202    multiple error messages from one error in the input.  */
 203
 204 tree error_mark_node;
 205
 206 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 207 tree error_mark_list;
 208
 209 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
 210
 211 tree short_integer_type_node;
 212 tree integer_type_node;
 213 tree long_integer_type_node;
 214 tree long_long_integer_type_node;
 215
 216 tree short_unsigned_type_node;
 217 tree unsigned_type_node;
 218 tree long_unsigned_type_node;
 219 tree long_long_unsigned_type_node;
 220
 221 tree ptrdiff_type_node;
 222
 223 tree unsigned_char_type_node;
 224 tree signed_char_type_node;
 225 tree char_type_node;
 226 tree wchar_type_node;
 227 tree signed_wchar_type_node;
 228 tree unsigned_wchar_type_node;
 229
 230 tree wchar_decl_node;
 231
 232 tree float_type_node;
 233 tree double_type_node;
 234 tree long_double_type_node;
 235
 236 tree complex_integer_type_node;
 237 tree complex_float_type_node;
 238 tree complex_double_type_node;
 239 tree complex_long_double_type_node;
 240
 241 tree intQI_type_node;
 242 tree intHI_type_node;
 243 tree intSI_type_node;
 244 tree intDI_type_node;
 245 #if HOST_BITS_PER_WIDE_INT >= 64
 246 tree intTI_type_node;
 247 #endif
 248
 249 tree unsigned_intQI_type_node;
 250 tree unsigned_intHI_type_node;
 251 tree unsigned_intSI_type_node;
 252 tree unsigned_intDI_type_node;
 253 #if HOST_BITS_PER_WIDE_INT >= 64
 254 tree unsigned_intTI_type_node;
 255 #endif
 256
 257 tree java_byte_type_node;
 258 tree java_short_type_node;
 259 tree java_int_type_node;
 260 tree java_long_type_node;
 261 tree java_float_type_node;
 262 tree java_double_type_node;
 263 tree java_char_type_node;
 264 tree java_boolean_type_node;
 265
 266 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST.  */
 267
 268 tree void_type_node, void_list_node;
 269 tree void_zero_node;
 270
 271 /* Nodes for types `void *' and `const void *'.  */
 272
 273 tree ptr_type_node;
 274 tree const_ptr_type_node;
 275
 276 /* Nodes for types `char *' and `const char *'.  */
 277
 278 tree string_type_node, const_string_type_node;
 279
 280 /* Type `char[256]' or something like it.
 281    Used when an array of char is needed and the size is irrelevant.  */
 282
 283 tree char_array_type_node;
 284
 285 /* Type `int[256]' or something like it.
 286    Used when an array of int needed and the size is irrelevant.  */
 287
 288 tree int_array_type_node;
 289
 290 /* Type `wchar_t[256]' or something like it.
 291    Used when a wide string literal is created.  */
 292
 293 tree wchar_array_type_node;
 294
 295 /* The bool data type, and constants */
 296 tree boolean_type_node, boolean_true_node, boolean_false_node;
 297
 298 /* Type `int ()' -- used for implicit declaration of functions.  */
 299
 300 tree default_function_type;
 301
 302 /* Function types `double (double)' and `double (double, double)', etc.  */
 303
 304 static tree double_ftype_double, double_ftype_double_double;
 305 static tree int_ftype_int, long_ftype_long;
 306 static tree float_ftype_float;
 307 static tree ldouble_ftype_ldouble;
 308
 309 /* Function type `int (const void *, const void *, size_t)' */
 310 static tree int_ftype_cptr_cptr_sizet;
 311
 312 /* C++ extensions */
 313 tree vtable_entry_type;
 314 tree delta_type_node;
 315 #if 0
 316 /* Old rtti stuff.  */
 317 tree __baselist_desc_type_node;
 318 tree __i_desc_type_node, __m_desc_type_node;
 319 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 320 #endif
 321 tree __t_desc_type_node;
 322 #if 0
 323 tree __tp_desc_type_node;
 324 #endif
 325 tree __access_mode_type_node;
 326 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
 327 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
 328 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
 329 #if 0
 330 /* Not needed yet?  May be needed one day?  */
 331 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 332 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 333 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 334 #endif
 335
 336 /* Indicates that there is a type value in some namespace, although
 337    that is not necessarily in scope at the moment. */
 338
 339 static tree global_type_node;
 340
 341 tree class_star_type_node;
 342 tree class_type_node, record_type_node, union_type_node, enum_type_node;
 343 tree unknown_type_node;
 344 tree opaque_type_node, signature_type_node;
 345 tree sigtable_entry_type;
 346
 347 /* Array type `vtable_entry_type[]' */
 348 tree vtbl_type_node;
 349 tree vtbl_ptr_type_node;
 350
 351 /* namespace std */
 352 tree std_node;
 353 int in_std = 0;
 354
 355 /* Expect only namespace names now. */
 356 static int only_namespace_names;
 357
 358 /* In a destructor, the point at which all derived class destroying
 359    has been done, just before any base class destroying will be done.  */
 360
 361 tree dtor_label;
 362
 363 /* In a destructor, the last insn emitted after the start of the
 364    function and the parms.  */
 365
 366 static rtx last_dtor_insn;
 367
 368 /* In a constructor, the last insn emitted after the start of the
 369    function and the parms, the exception specification and any
 370    function-try-block.  The constructor initializers are emitted after
 371    this insn.  */
 372
 373 static rtx last_parm_cleanup_insn;
 374
 375 /* In a constructor, the point at which we are ready to return
 376    the pointer to the initialized object.  */
 377
 378 tree ctor_label;
 379
 380 /* A FUNCTION_DECL which can call `abort'.  Not necessarily the
 381    one that the user will declare, but sufficient to be called
 382    by routines that want to abort the program.  */
 383
 384 tree abort_fndecl;
 385
 386 /* A FUNCTION_DECL for the default `::operator delete'.  */
 387
 388 tree global_delete_fndecl;
 389
 390 extern rtx cleanup_label, return_label;
 391
 392 /* If original DECL_RESULT of current function was a register,
 393    but due to being an addressable named return value, would up
 394    on the stack, this variable holds the named return value's
 395    original location.  */
 396 static rtx original_result_rtx;
 397
 398 /* Sequence of insns which represents base initialization.  */
 399 tree base_init_expr;
 400
 401 /* C++: Keep these around to reduce calls to `get_identifier'.
 402    Identifiers for `this' in member functions and the auto-delete
 403    parameter for destructors.  */
 404 tree this_identifier, in_charge_identifier;
 405 tree ctor_identifier, dtor_identifier;
 406 /* Used in pointer to member functions, in vtables, and in sigtables.  */
 407 tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
 408 tree pfn_or_delta2_identifier, tag_identifier;
 409 tree vt_off_identifier;
 410
 411 struct named_label_list
 412 {
 413   struct binding_level *binding_level;
 414   tree names_in_scope;
 415   tree label_decl;
 416   char *filename_o_goto;
 417   int lineno_o_goto;
 418   struct named_label_list *next;
 419 };
 420
 421 /* A list (chain of TREE_LIST nodes) of named label uses.
 422    The TREE_PURPOSE field is the list of variables defined
 423    in the label's scope defined at the point of use.
 424    The TREE_VALUE field is the LABEL_DECL used.
 425    The TREE_TYPE field holds `current_binding_level' at the
 426    point of the label's use.
 427
 428    BWAHAHAAHAHahhahahahaah.  No, no, no, said the little chicken.
 429
 430    Look at the pretty struct named_label_list. See the pretty struct
 431    with the pretty named fields that describe what they do. See the
 432    pretty lack of gratuitous casts. Notice the code got a lot cleaner.
 433
 434    Used only for jumps to as-yet undefined labels, since
 435    jumps to defined labels can have their validity checked
 436    by stmt.c.  */
 437
 438 static struct named_label_list *named_label_uses = NULL;
 439
 440 /* A list of objects which have constructors or destructors
 441    which reside in the global scope.  The decl is stored in
 442    the TREE_VALUE slot and the initializer is stored
 443    in the TREE_PURPOSE slot.  */
 444 tree static_aggregates;
 445
 446 /* -- end of C++ */
 447
 448 /* Two expressions that are constants with value zero.
 449    The first is of type `int', the second of type `void *'.  */
 450
 451 tree integer_zero_node;
 452 tree null_pointer_node;
 453
 454 /* The value for __null (NULL), namely, a zero of an integer type with
 455    the same number of bits as a pointer.  */
 456 tree null_node;
 457
 458 /* A node for the integer constants 1, 2, and 3.  */
 459
 460 tree integer_one_node, integer_two_node, integer_three_node;
 461
 462 /* While defining an enum type, this is 1 plus the last enumerator
 463    constant value.  */
 464
 465 static tree enum_next_value;
 466
 467 /* Nonzero means that there was overflow computing enum_next_value.  */
 468
 469 static int enum_overflow;
 470
 471 /* Parsing a function declarator leaves a list of parameter names
 472    or a chain or parameter decls here.  */
 473
 474 tree last_function_parms;
 475
 476 /* Parsing a function declarator leaves here a chain of structure
 477    and enum types declared in the parmlist.  */
 478
 479 static tree last_function_parm_tags;
 480
 481 /* After parsing the declarator that starts a function definition,
 482    `start_function' puts here the list of parameter names or chain of decls.
 483    `store_parm_decls' finds it here.  */
 484
 485 static tree current_function_parms;
 486
 487 /* Similar, for last_function_parm_tags.  */
 488 static tree current_function_parm_tags;
 489
 490 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 491    that have names.  Here so we can clear out their names' definitions
 492    at the end of the function.  */
 493
 494 static tree named_labels;
 495
 496 /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
 497
 498 static tree shadowed_labels;
 499
 500 /* The FUNCTION_DECL for the function currently being compiled,
 501    or 0 if between functions.  */
 502 tree current_function_decl;
 503
 504 /* Set to 0 at beginning of a function definition, set to 1 if
 505    a return statement that specifies a return value is seen.  */
 506
 507 int current_function_returns_value;
 508
 509 /* Set to 0 at beginning of a function definition, set to 1 if
 510    a return statement with no argument is seen.  */
 511
 512 int current_function_returns_null;
 513
 514 /* Set to 0 at beginning of a function definition, and whenever
 515    a label (case or named) is defined.  Set to value of expression
 516    returned from function when that value can be transformed into
 517    a named return value.  */
 518
 519 tree current_function_return_value;
 520
 521 /* Nonzero means give `double' the same size as `float'.  */
 522
 523 extern int flag_short_double;
 524
 525 /* Nonzero means don't recognize any builtin functions.  */
 526
 527 extern int flag_no_builtin;
 528
 529 /* Nonzero means don't recognize the non-ANSI builtin functions.
 530    -ansi sets this.  */
 531
 532 extern int flag_no_nonansi_builtin;
 533
 534 /* Nonzero means enable obscure ANSI features and disable GNU extensions
 535    that might cause ANSI-compliant code to be miscompiled.  */
 536
 537 extern int flag_ansi;
 538
 539 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 540    objects.  */
 541 extern int flag_huge_objects;
 542
 543 /* Nonzero if we want to conserve space in the .o files.  We do this
 544    by putting uninitialized data and runtime initialized data into
 545    .common instead of .data at the expense of not flagging multiple
 546    definitions.  */
 547 extern int flag_conserve_space;
 548
 549 /* Pointers to the base and current top of the language name stack.  */
 550
 551 extern tree *current_lang_base, *current_lang_stack;
 552 \f
 553 /* C and C++ flags are in decl2.c.  */
 554
 555 /* Set to 0 at beginning of a constructor, set to 1
 556    if that function does an allocation before referencing its
 557    instance variable.  */
 558 static int current_function_assigns_this;
 559 int current_function_just_assigned_this;
 560
 561 /* Set to 0 at beginning of a function.  Set non-zero when
 562    store_parm_decls is called.  Don't call store_parm_decls
 563    if this flag is non-zero!  */
 564 int current_function_parms_stored;
 565
 566 /* Flag used when debugging spew.c */
 567
 568 extern int spew_debug;
 569
 570 /* This is a copy of the class_shadowed list of the previous class binding
 571    contour when at global scope.  It's used to reset IDENTIFIER_CLASS_VALUEs
 572    when entering another class scope (i.e. a cache miss).  */
 573 extern tree previous_class_values;
 574
 575 /* A expression of value 0 with the same precision as a sizetype
 576    node, but signed.  */
 577 tree signed_size_zero_node;
 578
 579 /* The name of the anonymous namespace, throughout this translation
 580    unit.  */
 581 tree anonymous_namespace_name;
 582
 583 \f
 584 /* Allocate a level of searching.  */
 585
 586 static
 587 struct stack_level *
 588 push_decl_level (stack, obstack)
 589      struct stack_level *stack;
 590      struct obstack *obstack;
 591 {
 592   struct stack_level tem;
 593   tem.prev = stack;
 594
 595   return push_stack_level (obstack, (char *)&tem, sizeof (tem));
 596 }
 597 \f
 598 /* For each binding contour we allocate a binding_level structure
 599    which records the names defined in that contour.
 600    Contours include:
 601     0) the global one
 602     1) one for each function definition,
 603        where internal declarations of the parameters appear.
 604     2) one for each compound statement,
 605        to record its declarations.
 606
 607    The current meaning of a name can be found by searching the levels
 608    from the current one out to the global one.
 609
 610    Off to the side, may be the class_binding_level.  This exists only
 611    to catch class-local declarations.  It is otherwise nonexistent.
 612
 613    Also there may be binding levels that catch cleanups that must be
 614    run when exceptions occur.  Thus, to see whether a name is bound in
 615    the current scope, it is not enough to look in the
 616    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 617    instead.  */
 618
 619 /* Note that the information in the `names' component of the global contour
 620    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 621
 622 struct binding_level
 623   {
 624     /* A chain of _DECL nodes for all variables, constants, functions,
 625        and typedef types.  These are in the reverse of the order
 626        supplied.  There may be OVERLOADs on this list, too, but they
 627        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 628     tree names;
 629
 630     /* A list of structure, union and enum definitions, for looking up
 631        tag names.
 632        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 633        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 634        or ENUMERAL_TYPE node.
 635
 636        C++: the TREE_VALUE nodes can be simple types for
 637        component_bindings.  */
 638     tree tags;
 639
 640     /* A list of USING_DECL nodes. */
 641     tree usings;
 642
 643     /* A list of used namespaces. PURPOSE is the namespace,
 644        VALUE the common ancestor with this binding_level's namespace. */
 645     tree using_directives;
 646
 647     /* If this binding level is the binding level for a class, then
 648        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 649        is the name of an entity bound in the class; the TREE_VALUE is
 650        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 651        when leaving class scope, we can restore the
 652        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 653        the DECL bound by this name in the class.  */
 654     tree class_shadowed;
 655
 656     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 657        is used for all binding levels.  */
 658     tree type_shadowed;
 659
 660     /* For each level (except not the global one),
 661        a chain of BLOCK nodes for all the levels
 662        that were entered and exited one level down.  */
 663     tree blocks;
 664
 665     /* The BLOCK node for this level, if one has been preallocated.
 666        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 667     tree this_block;
 668
 669     /* The binding level which this one is contained in (inherits from).  */
 670     struct binding_level *level_chain;
 671
 672     /* List of decls in `names' that have incomplete
 673        structure or union types.  */
 674     tree incomplete;
 675
 676     /* List of VAR_DECLS saved from a previous for statement.
 677        These would be dead in ANSI-conforming code, but might
 678        be referenced in ARM-era code.  These are stored in a
 679        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 680     tree dead_vars_from_for;
 681
 682     /* 1 for the level that holds the parameters of a function.
 683        2 for the level that holds a class declaration.
 684        3 for levels that hold parameter declarations.  */
 685     unsigned parm_flag : 4;
 686
 687     /* 1 means make a BLOCK for this level regardless of all else.
 688        2 for temporary binding contours created by the compiler.  */
 689     unsigned keep : 3;
 690
 691     /* Nonzero if this level "doesn't exist" for tags.  */
 692     unsigned tag_transparent : 1;
 693
 694     /* Nonzero if this level can safely have additional
 695        cleanup-needing variables added to it.  */
 696     unsigned more_cleanups_ok : 1;
 697     unsigned have_cleanups : 1;
 698
 699     /* Nonzero if this level is for storing the decls for template
 700        parameters and generic decls; these decls will be discarded and
 701        replaced with a TEMPLATE_DECL.  */
 702     unsigned pseudo_global : 1;
 703
 704     /* This is set for a namespace binding level.  */
 705     unsigned namespace_p : 1;
 706
 707     /* True if this level is that of a for-statement where we need to
 708        worry about ambiguous (ARM or ANSI) scope rules.  */
 709     unsigned is_for_scope : 1;
 710
 711     /* Two bits left for this word.  */
 712
 713 #if defined(DEBUG_CP_BINDING_LEVELS)
 714     /* Binding depth at which this level began.  */
 715     unsigned binding_depth;
 716 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 717   };
 718
 719 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 720
 721 /* The binding level currently in effect.  */
 722
 723 static struct binding_level *current_binding_level;
 724
 725 /* The binding level of the current class, if any.  */
 726
 727 static struct binding_level *class_binding_level;
 728
 729 /* A chain of binding_level structures awaiting reuse.  */
 730
 731 static struct binding_level *free_binding_level;
 732
 733 /* The outermost binding level, for names of file scope.
 734    This is created when the compiler is started and exists
 735    through the entire run.  */
 736
 737 static struct binding_level *global_binding_level;
 738
 739 /* Binding level structures are initialized by copying this one.  */
 740
 741 static struct binding_level clear_binding_level;
 742
 743 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 744
 745 static int keep_next_level_flag;
 746
 747 #if defined(DEBUG_CP_BINDING_LEVELS)
 748 static int binding_depth = 0;
 749 static int is_class_level = 0;
 750
 751 static void
 752 indent ()
 753 {
 754   register unsigned i;
 755
 756   for (i = 0; i < binding_depth*2; i++)
 757     putc (' ', stderr);
 758 }
 759 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 760
 761 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
 762
 763 static void
 764 push_binding_level (newlevel, tag_transparent, keep)
 765      struct binding_level *newlevel;
 766      int tag_transparent, keep;
 767 {
 768   /* Add this level to the front of the chain (stack) of levels that
 769      are active.  */
 770   *newlevel = clear_binding_level;
 771   newlevel->level_chain = current_binding_level;
 772   current_binding_level = newlevel;
 773   newlevel->tag_transparent = tag_transparent;
 774   newlevel->more_cleanups_ok = 1;
 775   newlevel->keep = keep;
 776 #if defined(DEBUG_CP_BINDING_LEVELS)
 777   newlevel->binding_depth = binding_depth;
 778   indent ();
 779   fprintf (stderr, "push %s level 0x%08x line %d\n",
 780            (is_class_level) ? "class" : "block", newlevel, lineno);
 781   is_class_level = 0;
 782   binding_depth++;
 783 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 784 }
 785
 786 /* Find the innermost enclosing class scope, and reset
 787    CLASS_BINDING_LEVEL appropriately.  */
 788
 789 static void
 790 find_class_binding_level ()
 791 {
 792   struct binding_level *level = current_binding_level;
 793
 794   while (level && level->parm_flag != 2)
 795     level = level->level_chain;
 796   if (level && level->parm_flag == 2)
 797     class_binding_level = level;
 798   else
 799     class_binding_level = 0;
 800 }
 801
 802 static void
 803 pop_binding_level ()
 804 {
 805   if (global_binding_level)
 806     {
 807       /* Cannot pop a level, if there are none left to pop.  */
 808       if (current_binding_level == global_binding_level)
 809         my_friendly_abort (123);
 810     }
 811   /* Pop the current level, and free the structure for reuse.  */
 812 #if defined(DEBUG_CP_BINDING_LEVELS)
 813   binding_depth--;
 814   indent ();
 815   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 816           (is_class_level) ? "class" : "block",
 817           current_binding_level, lineno);
 818   if (is_class_level != (current_binding_level == class_binding_level))
 819     {
 820       indent ();
 821       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 822     }
 823   is_class_level = 0;
 824 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 825   {
 826     register struct binding_level *level = current_binding_level;
 827     current_binding_level = current_binding_level->level_chain;
 828     level->level_chain = free_binding_level;
 829 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 830     if (level->binding_depth != binding_depth)
 831       abort ();
 832 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 833     free_binding_level = level;
 834     find_class_binding_level ();
 835   }
 836 }
 837
 838 static void
 839 suspend_binding_level ()
 840 {
 841   if (class_binding_level)
 842     current_binding_level = class_binding_level;
 843
 844   if (global_binding_level)
 845     {
 846       /* Cannot suspend a level, if there are none left to suspend.  */
 847       if (current_binding_level == global_binding_level)
 848         my_friendly_abort (123);
 849     }
 850   /* Suspend the current level.  */
 851 #if defined(DEBUG_CP_BINDING_LEVELS)
 852   binding_depth--;
 853   indent ();
 854   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 855           (is_class_level) ? "class" : "block",
 856           current_binding_level, lineno);
 857   if (is_class_level != (current_binding_level == class_binding_level))
 858     {
 859       indent ();
 860       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 861     }
 862   is_class_level = 0;
 863 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 864   current_binding_level = current_binding_level->level_chain;
 865   find_class_binding_level ();
 866 }
 867
 868 static void
 869 resume_binding_level (b)
 870      struct binding_level *b;
 871 {
 872   /* Resuming binding levels is meant only for namespaces,
 873      and those cannot nest into classes. */
 874   my_friendly_assert(!class_binding_level, 386);
 875   /* Also, resuming a non-directly nested namespace is a no-no.  */
 876   my_friendly_assert(b->level_chain == current_binding_level, 386);
 877   current_binding_level = b;
 878 #if defined(DEBUG_CP_BINDING_LEVELS)
 879   b->binding_depth = binding_depth;
 880   indent ();
 881   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 882            (is_class_level) ? "class" : "block", b, lineno);
 883   is_class_level = 0;
 884   binding_depth++;
 885 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 886 }
 887 \f
 888 /* Create a new `struct binding_level'.  */
 889
 890 static
 891 struct binding_level *
 892 make_binding_level ()
 893 {
 894   /* NOSTRICT */
 895   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 896 }
 897
 898 /* Nonzero if we are currently in the global binding level.  */
 899
 900 int
 901 global_bindings_p ()
 902 {
 903   return current_binding_level == global_binding_level;
 904 }
 905
 906 /* Return the innermost binding level that is not for a class scope.  */
 907
 908 static struct binding_level *
 909 innermost_nonclass_level ()
 910 {
 911   struct binding_level *b;
 912
 913   b = current_binding_level;
 914   while (b->parm_flag == 2)
 915     b = b->level_chain;
 916
 917   return b;
 918 }
 919
 920 /* Nonzero if we are currently in a toplevel binding level.  This
 921    means either the global binding level or a namespace in a toplevel
 922    binding level.  Since there are no non-toplevel namespace levels,
 923    this really means any namespace or pseudo-global level.  We also
 924    include a class whose context is toplevel.  */
 925
 926 int
 927 toplevel_bindings_p ()
 928 {
 929   struct binding_level *b = innermost_nonclass_level ();
 930
 931   return b->namespace_p || b->pseudo_global;
 932 }
 933
 934 /* Nonzero if this is a namespace scope, or if we are defining a class
 935    which is itself at namespace scope, or whose enclosing class is
 936    such a class, etc.  */
 937
 938 int
 939 namespace_bindings_p ()
 940 {
 941   struct binding_level *b = innermost_nonclass_level ();
 942
 943   return b->namespace_p;
 944 }
 945
 946 void
 947 keep_next_level ()
 948 {
 949   keep_next_level_flag = 1;
 950 }
 951
 952 /* Nonzero if the current level needs to have a BLOCK made.  */
 953
 954 int
 955 kept_level_p ()
 956 {
 957   return (current_binding_level->blocks != NULL_TREE
 958           || current_binding_level->keep
 959           || current_binding_level->names != NULL_TREE
 960           || (current_binding_level->tags != NULL_TREE
 961               && !current_binding_level->tag_transparent));
 962 }
 963
 964 /* Identify this binding level as a level of parameters.  */
 965
 966 void
 967 declare_parm_level ()
 968 {
 969   current_binding_level->parm_flag = 1;
 970 }
 971
 972 void
 973 declare_pseudo_global_level ()
 974 {
 975   current_binding_level->pseudo_global = 1;
 976 }
 977
 978 static void
 979 declare_namespace_level ()
 980 {
 981   current_binding_level->namespace_p = 1;
 982 }
 983
 984 int
 985 pseudo_global_level_p ()
 986 {
 987   struct binding_level *b = innermost_nonclass_level ();
 988
 989   return b->pseudo_global;
 990 }
 991
 992 void
 993 set_class_shadows (shadows)
 994      tree shadows;
 995 {
 996   class_binding_level->class_shadowed = shadows;
 997 }
 998
 999 /* Enter a new binding level.
1000    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
1001    not for that of tags.  */
1002
1003 void
1004 pushlevel (tag_transparent)
1005      int tag_transparent;
1006 {
1007   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
1008
1009   /* If this is the top level of a function,
1010      just make sure that NAMED_LABELS is 0.
1011      They should have been set to 0 at the end of the previous function.  */
1012
1013   if (current_binding_level == global_binding_level)
1014     my_friendly_assert (named_labels == NULL_TREE, 134);
1015
1016   /* Reuse or create a struct for this binding level.  */
1017
1018 #if defined(DEBUG_CP_BINDING_LEVELS)
1019   if (0)
1020 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1021   if (free_binding_level)
1022 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1023     {
1024       newlevel = free_binding_level;
1025       free_binding_level = free_binding_level->level_chain;
1026     }
1027   else
1028     {
1029       newlevel = make_binding_level ();
1030     }
1031
1032   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
1033   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
1034   keep_next_level_flag = 0;
1035 }
1036
1037 void
1038 note_level_for_for ()
1039 {
1040   current_binding_level->is_for_scope = 1;
1041 }
1042
1043 void
1044 pushlevel_temporary (tag_transparent)
1045      int tag_transparent;
1046 {
1047   pushlevel (tag_transparent);
1048   current_binding_level->keep = 2;
1049   clear_last_expr ();
1050
1051   /* Note we don't call push_momentary() here.  Otherwise, it would cause
1052      cleanups to be allocated on the momentary obstack, and they will be
1053      overwritten by the next statement.  */
1054
1055   expand_start_bindings (0);
1056 }
1057
1058 /* For a binding between a name and an entity at a block scope,
1059    this is the `struct binding_level' for the block.  */
1060 #define BINDING_LEVEL(NODE) \
1061    (((struct tree_binding*)NODE)->scope.level)
1062
1063 /* These are currently unused, but permanent, CPLUS_BINDING nodes.
1064    They are kept here because they are allocated from the permanent
1065    obstack and cannot be easily freed.  */
1066 static tree free_binding_nodes;
1067
1068 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
1069    level at which this declaration is being bound.  */
1070
1071 static void
1072 push_binding (id, decl, level)
1073      tree id;
1074      tree decl;
1075      struct binding_level* level;
1076 {
1077   tree binding;
1078
1079   if (!free_binding_nodes)
1080     {
1081       /* There are no free nodes, so we must build one here.  */
1082       push_obstacks_nochange ();
1083       end_temporary_allocation ();
1084       binding = make_node (CPLUS_BINDING);
1085       pop_obstacks ();
1086     }
1087   else
1088     {
1089       /* There are nodes on the free list.  Grab the first one.  */
1090       binding = free_binding_nodes;
1091
1092       /* And update the free list.  */
1093       free_binding_nodes = TREE_CHAIN (free_binding_nodes);
1094     }
1095
1096   /* Now, fill in the binding information.  */
1097   BINDING_VALUE (binding) = decl;
1098   BINDING_TYPE (binding) = NULL_TREE;
1099   BINDING_LEVEL (binding) = level;
1100   INHERITED_VALUE_BINDING_P (binding) = 0;
1101   LOCAL_BINDING_P (binding) = (level != class_binding_level);
1102
1103   /* And put it on the front of the list of bindings for ID.  */
1104   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
1105   IDENTIFIER_BINDING (id) = binding;
1106 }
1107
1108 /* ID is already bound in the current scope.  But, DECL is an
1109    additional binding for ID in the same scope.  This is the `struct
1110    stat' hack whereby a non-typedef class-name or enum-name can be
1111    bound at the same level as some other kind of entity.  It's the
1112    responsibility of the caller to check that inserting this name is
1113    legal here.  Returns nonzero if the new binding was successful.  */
1114 static int
1115 add_binding (id, decl)
1116      tree id;
1117      tree decl;
1118 {
1119   tree binding = IDENTIFIER_BINDING (id);
1120   int ok = 1;
1121
1122   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1123     /* The new name is the type name.  */
1124     BINDING_TYPE (binding) = decl;
1125   else if (!BINDING_VALUE (binding))
1126     /* This situation arises when push_class_level_binding moves an
1127        inherited type-binding out of the way to make room for a new
1128        value binding.  */
1129     BINDING_VALUE (binding) = decl;
1130   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1131            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1132     {
1133       /* The old binding was a type name.  It was placed in
1134          BINDING_VALUE because it was thought, at the point it was
1135          declared, to be the only entity with such a name.  Move the
1136          type name into the type slot; it is now hidden by the new
1137          binding.  */
1138       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1139       BINDING_VALUE (binding) = decl;
1140       INHERITED_VALUE_BINDING_P (binding) = 0;
1141     }
1142   else
1143     {
1144       cp_error ("declaration of `%#D'", decl);
1145       cp_error_at ("conflicts with previous declaration `%#D'",
1146                    BINDING_VALUE (binding));
1147       ok = 0;
1148     }
1149
1150   return ok;
1151 }
1152
1153 /* Bind DECL to ID in the current_binding_level.
1154    If PUSH_USING is set in FLAGS, we know that DECL doesn't really belong
1155    to this binding level, that it got here through a using-declaration.  */
1156
1157 void
1158 push_local_binding (id, decl, flags)
1159      tree id;
1160      tree decl;
1161      int flags;
1162 {
1163   struct binding_level *b;
1164
1165   /* Skip over any local classes.  This makes sense if we call
1166      push_local_binding with a friend decl of a local class.  */
1167   b = current_binding_level;
1168   while (b->parm_flag == 2)
1169     b = b->level_chain;
1170
1171   if (lookup_name_current_level (id))
1172     {
1173       /* Supplement the existing binding.  */
1174       if (!add_binding (id, decl))
1175         /* It didn't work.  Something else must be bound at this
1176            level.  Do not add DECL to the list of things to pop
1177            later.  */
1178         return;
1179     }
1180   else
1181     /* Create a new binding.  */
1182     push_binding (id, decl, b);
1183
1184   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1185     /* We must put the OVERLOAD into a TREE_LIST since the
1186        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1187        decls that got here through a using-declaration.  */
1188     decl = build_tree_list (NULL_TREE, decl);
1189
1190   /* And put DECL on the list of things declared by the current
1191      binding level.  */
1192   TREE_CHAIN (decl) = b->names;
1193   b->names = decl;
1194 }
1195
1196 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1197    binding was successful.  */
1198
1199 int
1200 push_class_binding (id, decl)
1201      tree id;
1202      tree decl;
1203 {
1204   int result = 1;
1205   tree binding = IDENTIFIER_BINDING (id);
1206   tree context;
1207
1208   /* Note that we declared this value so that we can issue an error if
1209      this an illegal redeclaration of a name already used for some
1210      other purpose.  */
1211   note_name_declared_in_class (id, decl);
1212
1213   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1214     /* Supplement the existing binding.  */
1215     result = add_binding (id, decl);
1216   else
1217     /* Create a new binding.  */
1218     push_binding (id, decl, class_binding_level);
1219
1220   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1221      class-level declaration.  Note that we do not use DECL here
1222      because of the possibility of the `struct stat' hack; if DECL is
1223      a class-name or enum-name we might prefer a field-name, or some
1224      such.  */
1225   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1226
1227   /* If this is a binding from a base class, mark it as such.  */
1228   binding = IDENTIFIER_BINDING (id);
1229   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1230     {
1231       if (TREE_CODE (decl) == OVERLOAD)
1232         context = DECL_REAL_CONTEXT (OVL_CURRENT (decl));
1233       else
1234         {
1235           my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1236                               0);
1237           context = DECL_REAL_CONTEXT (decl);
1238         }
1239
1240       if (is_properly_derived_from (current_class_type, context))
1241         INHERITED_VALUE_BINDING_P (binding) = 1;
1242       else
1243         INHERITED_VALUE_BINDING_P (binding) = 0;
1244     }
1245   else if (BINDING_VALUE (binding) == decl)
1246     /* We only encounter a TREE_LIST when push_class_decls detects an
1247        ambiguity.  Such an ambiguity can be overridden by a definition
1248        in this class.  */
1249     INHERITED_VALUE_BINDING_P (binding) = 1;
1250
1251   return result;
1252 }
1253
1254 /* Remove the binding for DECL which should be the innermost binding
1255    for ID.  */
1256
1257 static void
1258 pop_binding (id, decl)
1259      tree id;
1260      tree decl;
1261 {
1262   tree binding;
1263
1264   if (id == NULL_TREE)
1265     /* It's easiest to write the loops that call this function without
1266        checking whether or not the entities involved have names.  We
1267        get here for such an entity.  */
1268     return;
1269
1270   /* Get the innermost binding for ID.  */
1271   binding = IDENTIFIER_BINDING (id);
1272
1273   /* The name should be bound.  */
1274   my_friendly_assert (binding != NULL_TREE, 0);
1275
1276   /* The DECL will be either the ordinary binding or the type
1277      binding for this identifier.  Remove that binding.  */
1278   if (BINDING_VALUE (binding) == decl)
1279     BINDING_VALUE (binding) = NULL_TREE;
1280   else if (BINDING_TYPE (binding) == decl)
1281     BINDING_TYPE (binding) = NULL_TREE;
1282   else
1283     my_friendly_abort (0);
1284
1285   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1286     {
1287       /* We're completely done with the innermost binding for this
1288          identifier.  Unhook it from the list of bindings.  */
1289       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1290
1291       /* And place it on the free list.  */
1292       TREE_CHAIN (binding) = free_binding_nodes;
1293       free_binding_nodes = binding;
1294     }
1295 }
1296
1297 /* Exit a binding level.
1298    Pop the level off, and restore the state of the identifier-decl mappings
1299    that were in effect when this level was entered.
1300
1301    If KEEP == 1, this level had explicit declarations, so
1302    and create a "block" (a BLOCK node) for the level
1303    to record its declarations and subblocks for symbol table output.
1304
1305    If FUNCTIONBODY is nonzero, this level is the body of a function,
1306    so create a block as if KEEP were set and also clear out all
1307    label names.
1308
1309    If REVERSE is nonzero, reverse the order of decls before putting
1310    them into the BLOCK.  */
1311
1312 tree
1313 poplevel (keep, reverse, functionbody)
1314      int keep;
1315      int reverse;
1316      int functionbody;
1317 {
1318   register tree link;
1319   /* The chain of decls was accumulated in reverse order.
1320      Put it into forward order, just for cleanliness.  */
1321   tree decls;
1322   int tmp = functionbody;
1323   int real_functionbody = current_binding_level->keep == 2
1324     ? ((functionbody = 0), tmp) : functionbody;
1325   tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
1326   tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1327   tree block = NULL_TREE;
1328   tree decl;
1329   int block_previously_created;
1330   int leaving_for_scope;
1331
1332   if (current_binding_level->parm_flag == 2
1333       || current_binding_level->class_shadowed)
1334     /* We should not be using poplevel to pop a class binding level.
1335        Use poplevel_class instead.  */
1336     my_friendly_abort (0);
1337
1338   /* We used to use KEEP == 2 to indicate that the new block should go
1339      at the beginning of the list of blocks at this binding level,
1340      rather than the end.  This hack is no longer used.  */
1341   my_friendly_assert (keep == 0 || keep == 1, 0);
1342
1343   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1344                       (HOST_WIDE_INT) current_binding_level->level_chain,
1345                       current_binding_level->parm_flag,
1346                       current_binding_level->keep);
1347
1348   if (current_binding_level->keep == 1)
1349     keep = 1;
1350
1351   /* Get the decls in the order they were written.
1352      Usually current_binding_level->names is in reverse order.
1353      But parameter decls were previously put in forward order.  */
1354
1355   if (reverse)
1356     current_binding_level->names
1357       = decls = nreverse (current_binding_level->names);
1358   else
1359     decls = current_binding_level->names;
1360
1361   /* Output any nested inline functions within this block
1362      if they weren't already output.  */
1363
1364   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1365     if (TREE_CODE (decl) == FUNCTION_DECL
1366         && ! TREE_ASM_WRITTEN (decl)
1367         && DECL_INITIAL (decl) != NULL_TREE
1368         && TREE_ADDRESSABLE (decl)
1369         && decl_function_context (decl) == current_function_decl)
1370       {
1371         /* If this decl was copied from a file-scope decl
1372            on account of a block-scope extern decl,
1373            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1374         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1375           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1376         else
1377           {
1378             push_function_context ();
1379             output_inline_function (decl);
1380             pop_function_context ();
1381           }
1382       }
1383
1384   /* If there were any declarations or structure tags in that level,
1385      or if this level is a function body,
1386      create a BLOCK to record them for the life of this function.  */
1387
1388   block = NULL_TREE;
1389   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1390   if (block_previously_created)
1391     block = current_binding_level->this_block;
1392   else if (keep == 1 || functionbody)
1393     block = make_node (BLOCK);
1394   if (block != NULL_TREE)
1395     {
1396       if (block_previously_created)
1397         {
1398           if (decls || tags || subblocks)
1399             {
1400               if (BLOCK_VARS (block) || BLOCK_TYPE_TAGS (block))
1401                 warning ("internal compiler error: debugging info corrupted");
1402
1403               BLOCK_VARS (block) = decls;
1404               BLOCK_TYPE_TAGS (block) = tags;
1405
1406               /* We can have previous subblocks and new subblocks when
1407                  doing fixup_gotos with complex cleanups.  We chain the new
1408                  subblocks onto the end of any pre-existing subblocks.  */
1409               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1410                                                  subblocks);
1411             }
1412           /* If we created the block earlier on, and we are just
1413              diddling it now, then it already should have a proper
1414              BLOCK_END_NOTE value associated with it.  */
1415         }
1416       else
1417         {
1418           BLOCK_VARS (block) = decls;
1419           BLOCK_TYPE_TAGS (block) = tags;
1420           BLOCK_SUBBLOCKS (block) = subblocks;
1421           /* Otherwise, for a new block, install a new BLOCK_END_NOTE
1422              value.  */
1423           remember_end_note (block);
1424         }
1425     }
1426
1427   /* In each subblock, record that this is its superior.  */
1428
1429   if (keep >= 0)
1430     for (link = subblocks; link; link = TREE_CHAIN (link))
1431       BLOCK_SUPERCONTEXT (link) = block;
1432
1433   /* We still support the old for-scope rules, whereby the variables
1434      in a for-init statement were in scope after the for-statement
1435      ended.  We only use the new rules in flag_new_for_scope is
1436      nonzero.  */
1437   leaving_for_scope
1438     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1439
1440   /* Remove declarations for all the DECLs in this level.  */
1441   for (link = decls; link; link = TREE_CHAIN (link))
1442     {
1443       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1444         {
1445           tree outer_binding
1446             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1447           tree ns_binding;
1448
1449           if (!outer_binding)
1450             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1451           else
1452             ns_binding = NULL_TREE;
1453
1454           if (outer_binding
1455               && (BINDING_LEVEL (outer_binding)
1456                   == current_binding_level->level_chain))
1457             /* We have something like:
1458
1459                  int i;
1460                  for (int i; ;);
1461
1462                and we are leaving the `for' scope.  There's no reason to
1463                keep the binding of the inner `i' in this case.  */
1464             pop_binding (DECL_NAME (link), link);
1465           else if ((outer_binding
1466                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1467                         == TYPE_DECL))
1468                    || (ns_binding
1469                        && TREE_CODE (ns_binding) == TYPE_DECL))
1470             /* Here, we have something like:
1471
1472                  typedef int I;
1473
1474                  void f () {
1475                    for (int I; ;);
1476                  }
1477
1478                We must pop the for-scope binding so we know what's a
1479                type and what isn't.  */
1480             pop_binding (DECL_NAME (link), link);
1481           else
1482             {
1483               /* Mark this VAR_DECL as dead so that we can tell we left it
1484                  there only for backward compatibility.  */
1485               DECL_DEAD_FOR_LOCAL (link) = 1;
1486
1487               /* Keep track of what should of have happenned when we
1488                  popped the binding.  */
1489               if (outer_binding && BINDING_VALUE (outer_binding))
1490                 DECL_SHADOWED_FOR_VAR (link)
1491                   = BINDING_VALUE (outer_binding);
1492
1493               /* Add it to the list of dead variables in the next
1494                  outermost binding to that we can remove these when we
1495                  leave that binding.  */
1496               current_binding_level->level_chain->dead_vars_from_for
1497                 = tree_cons (NULL_TREE, link,
1498                              current_binding_level->level_chain->
1499                              dead_vars_from_for);
1500
1501               /* Although we don't pop the CPLUS_BINDING, we do clear
1502                  its BINDING_LEVEL since the level is going away now.  */
1503               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1504                 = 0;
1505             }
1506         }
1507       else
1508         {
1509           /* Remove the binding.  */
1510           decl = link;
1511           if (TREE_CODE (decl) == TREE_LIST)
1512             decl = TREE_VALUE (decl);
1513           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1514             pop_binding (DECL_NAME (decl), decl);
1515           else if (TREE_CODE (decl) == OVERLOAD)
1516             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1517           else
1518             my_friendly_abort (0);
1519         }
1520     }
1521
1522   /* Remove declarations for any `for' variables from inner scopes
1523      that we kept around.  */
1524   for (link = current_binding_level->dead_vars_from_for;
1525        link; link = TREE_CHAIN (link))
1526     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1527
1528   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1529   for (link = current_binding_level->type_shadowed;
1530        link; link = TREE_CHAIN (link))
1531     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1532
1533   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1534      list if a `using' declaration put them there.  The debugging
1535      back-ends won't understand OVERLOAD, so we remove them here.
1536      Because the BLOCK_VARS are (temporarily) shared with
1537      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1538      popped all the bindings.  */
1539   if (block)
1540     {
1541       tree* d;
1542
1543       for (d = &BLOCK_VARS (block); *d; )
1544         {
1545           if (TREE_CODE (*d) == TREE_LIST)
1546             *d = TREE_CHAIN (*d);
1547           else
1548             d = &TREE_CHAIN (*d);
1549         }
1550     }
1551
1552   /* If the level being exited is the top level of a function,
1553      check over all the labels.  */
1554
1555   if (functionbody)
1556     {
1557       /* If this is the top level block of a function,
1558          the vars are the function's parameters.
1559          Don't leave them in the BLOCK because they are
1560          found in the FUNCTION_DECL instead.  */
1561
1562       BLOCK_VARS (block) = 0;
1563
1564       /* Clear out the definitions of all label names,
1565          since their scopes end here.  */
1566
1567       for (link = named_labels; link; link = TREE_CHAIN (link))
1568         {
1569           register tree label = TREE_VALUE (link);
1570
1571           if (DECL_INITIAL (label) == NULL_TREE)
1572             {
1573               cp_error_at ("label `%D' used but not defined", label);
1574               /* Avoid crashing later.  */
1575               define_label (input_filename, 1, DECL_NAME (label));
1576             }
1577           else if (warn_unused && !TREE_USED (label))
1578             cp_warning_at ("label `%D' defined but not used", label);
1579           SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1580
1581           /* Put the labels into the "variables" of the
1582              top-level block, so debugger can see them.  */
1583           TREE_CHAIN (label) = BLOCK_VARS (block);
1584           BLOCK_VARS (block) = label;
1585         }
1586
1587       named_labels = NULL_TREE;
1588     }
1589
1590   /* Any uses of undefined labels now operate under constraints
1591      of next binding contour.  */
1592   {
1593     struct binding_level *level_chain;
1594     level_chain = current_binding_level->level_chain;
1595     if (level_chain)
1596       {
1597         struct named_label_list *labels;
1598         for (labels = named_label_uses; labels; labels = labels->next)
1599           if (labels->binding_level == current_binding_level)
1600             {
1601               labels->binding_level = level_chain;
1602               labels->names_in_scope = level_chain->names;
1603             }
1604       }
1605   }
1606
1607   tmp = current_binding_level->keep;
1608
1609   pop_binding_level ();
1610   if (functionbody)
1611     DECL_INITIAL (current_function_decl) = block;
1612   else if (block)
1613     {
1614       if (!block_previously_created)
1615         current_binding_level->blocks
1616           = chainon (current_binding_level->blocks, block);
1617     }
1618   /* If we did not make a block for the level just exited,
1619      any blocks made for inner levels
1620      (since they cannot be recorded as subblocks in that level)
1621      must be carried forward so they will later become subblocks
1622      of something else.  */
1623   else if (subblocks)
1624     current_binding_level->blocks
1625       = chainon (current_binding_level->blocks, subblocks);
1626
1627   /* Take care of compiler's internal binding structures.  */
1628   if (tmp == 2)
1629     {
1630       expand_end_bindings (getdecls (), keep, 1);
1631       /* Each and every BLOCK node created here in `poplevel' is important
1632          (e.g. for proper debugging information) so if we created one
1633          earlier, mark it as "used".  */
1634       if (block)
1635         TREE_USED (block) = 1;
1636       block = poplevel (keep, reverse, real_functionbody);
1637     }
1638
1639   /* Each and every BLOCK node created here in `poplevel' is important
1640      (e.g. for proper debugging information) so if we created one
1641      earlier, mark it as "used".  */
1642   if (block)
1643     TREE_USED (block) = 1;
1644   return block;
1645 }
1646
1647 /* Delete the node BLOCK from the current binding level.
1648    This is used for the block inside a stmt expr ({...})
1649    so that the block can be reinserted where appropriate.  */
1650
1651 void
1652 delete_block (block)
1653      tree block;
1654 {
1655   tree t;
1656   if (current_binding_level->blocks == block)
1657     current_binding_level->blocks = TREE_CHAIN (block);
1658   for (t = current_binding_level->blocks; t;)
1659     {
1660       if (TREE_CHAIN (t) == block)
1661         TREE_CHAIN (t) = TREE_CHAIN (block);
1662       else
1663         t = TREE_CHAIN (t);
1664     }
1665   TREE_CHAIN (block) = NULL_TREE;
1666   /* Clear TREE_USED which is always set by poplevel.
1667      The flag is set again if insert_block is called.  */
1668   TREE_USED (block) = 0;
1669 }
1670
1671 /* Insert BLOCK at the end of the list of subblocks of the
1672    current binding level.  This is used when a BIND_EXPR is expanded,
1673    to handle the BLOCK node inside the BIND_EXPR.  */
1674
1675 void
1676 insert_block (block)
1677      tree block;
1678 {
1679   TREE_USED (block) = 1;
1680   current_binding_level->blocks
1681     = chainon (current_binding_level->blocks, block);
1682 }
1683
1684 /* Set the BLOCK node for the innermost scope
1685    (the one we are currently in).  */
1686
1687 void
1688 set_block (block)
1689     register tree block;
1690 {
1691   current_binding_level->this_block = block;
1692 }
1693
1694 /* Do a pushlevel for class declarations.  */
1695
1696 void
1697 pushlevel_class ()
1698 {
1699   register struct binding_level *newlevel;
1700
1701   /* Reuse or create a struct for this binding level.  */
1702 #if defined(DEBUG_CP_BINDING_LEVELS)
1703   if (0)
1704 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1705   if (free_binding_level)
1706 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1707     {
1708       newlevel = free_binding_level;
1709       free_binding_level = free_binding_level->level_chain;
1710     }
1711   else
1712     newlevel = make_binding_level ();
1713
1714 #if defined(DEBUG_CP_BINDING_LEVELS)
1715   is_class_level = 1;
1716 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1717
1718   push_binding_level (newlevel, 0, 0);
1719
1720   decl_stack = push_decl_level (decl_stack, &decl_obstack);
1721   class_binding_level = current_binding_level;
1722   class_binding_level->parm_flag = 2;
1723 }
1724
1725 /* ...and a poplevel for class declarations.  FORCE is used to force
1726    clearing out of CLASS_VALUEs after a class definition.  */
1727
1728 tree
1729 poplevel_class (force)
1730      int force;
1731 {
1732   register struct binding_level *level = class_binding_level;
1733   tree block = NULL_TREE;
1734   tree shadowed;
1735
1736   my_friendly_assert (level != 0, 354);
1737
1738   decl_stack = pop_stack_level (decl_stack);
1739   /* If we're leaving a toplevel class, don't bother to do the setting
1740      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1741      shouldn't even be used when current_class_type isn't set, and second,
1742      if we don't touch it here, we're able to use the cache effect if the
1743      next time we're entering a class scope, it is the same class.  */
1744   if (current_class_depth != 1 || force)
1745     {
1746       struct binding_level* b;
1747
1748       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1749       for (shadowed = level->class_shadowed;
1750            shadowed;
1751            shadowed = TREE_CHAIN (shadowed))
1752         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1753
1754       /* Find the next enclosing class, and recreate
1755          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1756       b = level->level_chain;
1757       while (b && b->parm_flag != 2)
1758         b = b->level_chain;
1759
1760       if (b)
1761         for (shadowed = b->class_shadowed;
1762              shadowed;
1763              shadowed = TREE_CHAIN (shadowed))
1764           {
1765             tree t;
1766
1767             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1768             while (t && BINDING_LEVEL (t) != b)
1769               t = TREE_CHAIN (t);
1770
1771             if (t)
1772               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1773                 = BINDING_VALUE (t);
1774           }
1775     }
1776   else
1777     /* Remember to save what IDENTIFIER's were bound in this scope so we
1778        can recover from cache misses.  */
1779     {
1780       previous_class_type = current_class_type;
1781       previous_class_values = class_binding_level->class_shadowed;
1782     }
1783   for (shadowed = level->type_shadowed;
1784        shadowed;
1785        shadowed = TREE_CHAIN (shadowed))
1786     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1787
1788   /* Remove the bindings for all of the class-level declarations.  */
1789   for (shadowed = level->class_shadowed;
1790        shadowed;
1791        shadowed = TREE_CHAIN (shadowed))
1792     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1793
1794   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1795                       (HOST_WIDE_INT) class_binding_level->level_chain,
1796                       class_binding_level->parm_flag,
1797                       class_binding_level->keep);
1798
1799   /* Now, pop out of the binding level which we created up in the
1800      `pushlevel_class' routine.  */
1801 #if defined(DEBUG_CP_BINDING_LEVELS)
1802   is_class_level = 1;
1803 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1804
1805   pop_binding_level ();
1806
1807   return block;
1808 }
1809
1810 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1811    for any names in enclosing classes.  */
1812
1813 void
1814 clear_identifier_class_values ()
1815 {
1816   tree t;
1817
1818   if (!class_binding_level)
1819     return;
1820
1821   for (t = class_binding_level->class_shadowed;
1822        t;
1823        t = TREE_CHAIN (t))
1824     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1825 }
1826
1827 \f
1828 /* For debugging.  */
1829 static int no_print_functions = 0;
1830 static int no_print_builtins = 0;
1831
1832 void
1833 print_binding_level (lvl)
1834      struct binding_level *lvl;
1835 {
1836   tree t;
1837   int i = 0, len;
1838   fprintf (stderr, " blocks=");
1839   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1840   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1841            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1842   if (lvl->tag_transparent)
1843     fprintf (stderr, " tag-transparent");
1844   if (lvl->more_cleanups_ok)
1845     fprintf (stderr, " more-cleanups-ok");
1846   if (lvl->have_cleanups)
1847     fprintf (stderr, " have-cleanups");
1848   fprintf (stderr, "\n");
1849   if (lvl->names)
1850     {
1851       fprintf (stderr, " names:\t");
1852       /* We can probably fit 3 names to a line?  */
1853       for (t = lvl->names; t; t = TREE_CHAIN (t))
1854         {
1855           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1856             continue;
1857           if (no_print_builtins
1858               && (TREE_CODE (t) == TYPE_DECL)
1859               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1860             continue;
1861
1862           /* Function decls tend to have longer names.  */
1863           if (TREE_CODE (t) == FUNCTION_DECL)
1864             len = 3;
1865           else
1866             len = 2;
1867           i += len;
1868           if (i > 6)
1869             {
1870               fprintf (stderr, "\n\t");
1871               i = len;
1872             }
1873           print_node_brief (stderr, "", t, 0);
1874           if (t == error_mark_node)
1875             break;
1876         }
1877       if (i)
1878         fprintf (stderr, "\n");
1879     }
1880   if (lvl->tags)
1881     {
1882       fprintf (stderr, " tags:\t");
1883       i = 0;
1884       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1885         {
1886           if (TREE_PURPOSE (t) == NULL_TREE)
1887             len = 3;
1888           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1889             len = 2;
1890           else
1891             len = 4;
1892           i += len;
1893           if (i > 5)
1894             {
1895               fprintf (stderr, "\n\t");
1896               i = len;
1897             }
1898           if (TREE_PURPOSE (t) == NULL_TREE)
1899             {
1900               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1901               fprintf (stderr, ">");
1902             }
1903           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1904             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1905           else
1906             {
1907               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1908               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1909               fprintf (stderr, ">");
1910             }
1911         }
1912       if (i)
1913         fprintf (stderr, "\n");
1914     }
1915   if (lvl->class_shadowed)
1916     {
1917       fprintf (stderr, " class-shadowed:");
1918       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1919         {
1920           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1921         }
1922       fprintf (stderr, "\n");
1923     }
1924   if (lvl->type_shadowed)
1925     {
1926       fprintf (stderr, " type-shadowed:");
1927       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1928         {
1929           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1930         }
1931       fprintf (stderr, "\n");
1932     }
1933 }
1934
1935 void
1936 print_other_binding_stack (stack)
1937      struct binding_level *stack;
1938 {
1939   struct binding_level *level;
1940   for (level = stack; level != global_binding_level; level = level->level_chain)
1941     {
1942       fprintf (stderr, "binding level ");
1943       fprintf (stderr, HOST_PTR_PRINTF, level);
1944       fprintf (stderr, "\n");
1945       print_binding_level (level);
1946     }
1947 }
1948
1949 void
1950 print_binding_stack ()
1951 {
1952   struct binding_level *b;
1953   fprintf (stderr, "current_binding_level=");
1954   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1955   fprintf (stderr, "\nclass_binding_level=");
1956   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1957   fprintf (stderr, "\nglobal_binding_level=");
1958   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1959   fprintf (stderr, "\n");
1960   if (class_binding_level)
1961     {
1962       for (b = class_binding_level; b; b = b->level_chain)
1963         if (b == current_binding_level)
1964           break;
1965       if (b)
1966         b = class_binding_level;
1967       else
1968         b = current_binding_level;
1969     }
1970   else
1971     b = current_binding_level;
1972   print_other_binding_stack (b);
1973   fprintf (stderr, "global:\n");
1974   print_binding_level (global_binding_level);
1975 }
1976
1977 /* Namespace binding access routines: The namespace_bindings field of
1978    the identifier is polymorphic, with three possible values:
1979    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1980    indicating the BINDING_VALUE of global_namespace. */
1981
1982 /* Check whether the a binding for the name to scope is known.
1983    Assumes that the bindings of the name are already a list
1984    of bindings. Returns the binding found, or NULL_TREE. */
1985
1986 static tree
1987 find_binding (name, scope)
1988      tree name;
1989      tree scope;
1990 {
1991   tree iter, prev = NULL_TREE;
1992
1993   scope = ORIGINAL_NAMESPACE (scope);
1994
1995   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
1996        iter = TREE_CHAIN (iter))
1997     {
1998       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
1999       if (BINDING_SCOPE (iter) == scope)
2000         {
2001           /* Move binding found to the fron of the list, so
2002              subsequent lookups will find it faster. */
2003           if (prev)
2004             {
2005               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2006               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2007               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2008             }
2009           return iter;
2010         }
2011       prev = iter;
2012     }
2013   return NULL_TREE;
2014 }
2015
2016 /* Always returns a binding for name in scope. If the
2017    namespace_bindings is not a list, convert it to one first.
2018    If no binding is found, make a new one. */
2019
2020 tree
2021 binding_for_name (name, scope)
2022      tree name;
2023      tree scope;
2024 {
2025   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2026   tree result;
2027
2028   scope = ORIGINAL_NAMESPACE (scope);
2029
2030   if (b && TREE_CODE (b) != CPLUS_BINDING)
2031     {
2032       /* Get rid of optimization for global scope. */
2033       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2034       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2035       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2036     }
2037   if (b && (result = find_binding (name, scope)))
2038     return result;
2039   /* Not found, make a new permanent one. */
2040   push_obstacks (&permanent_obstack, &permanent_obstack);
2041   result = make_node (CPLUS_BINDING);
2042   TREE_CHAIN (result) = b;
2043   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2044   BINDING_SCOPE (result) = scope;
2045   BINDING_TYPE (result) = NULL_TREE;
2046   BINDING_VALUE (result) = NULL_TREE;
2047   pop_obstacks ();
2048   return result;
2049 }
2050
2051 /* Return the binding value for name in scope, considering that
2052    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2053
2054 tree
2055 namespace_binding (name, scope)
2056      tree name;
2057      tree scope;
2058 {
2059   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2060   if (b == NULL_TREE)
2061     return NULL_TREE;
2062   if (scope == NULL_TREE)
2063     scope = global_namespace;
2064   if (TREE_CODE (b) != CPLUS_BINDING)
2065     return (scope == global_namespace) ? b : NULL_TREE;
2066   name = find_binding (name,scope);
2067   if (name == NULL_TREE)
2068     return name;
2069   return BINDING_VALUE (name);
2070 }
2071
2072 /* Set the binding value for name in scope. If modifying the binding
2073    of global_namespace is attempted, try to optimize it. */
2074
2075 void
2076 set_namespace_binding (name, scope, val)
2077      tree name;
2078      tree scope;
2079      tree val;
2080 {
2081   tree b;
2082
2083   if (scope == NULL_TREE)
2084     scope = global_namespace;
2085
2086   if (scope == global_namespace)
2087     {
2088       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2089       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2090         {
2091           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2092           return;
2093         }
2094     }
2095   b = binding_for_name (name, scope);
2096   BINDING_VALUE (b) = val;
2097 }
2098
2099 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2100    select a name that is unique to this compilation unit.  */
2101
2102 void
2103 push_namespace (name)
2104      tree name;
2105 {
2106   tree d = NULL_TREE;
2107   int need_new = 1;
2108   int implicit_use = 0;
2109   int global = 0;
2110   if (!global_namespace)
2111     {
2112       /* This must be ::. */
2113       my_friendly_assert (name == get_identifier ("::"), 377);
2114       global = 1;
2115     }
2116   else if (!name)
2117     {
2118       /* The name of anonymous namespace is unique for the translation
2119          unit.  */
2120       if (!anonymous_namespace_name)
2121         anonymous_namespace_name = get_file_function_name ('N');
2122       name = anonymous_namespace_name;
2123       d = IDENTIFIER_NAMESPACE_VALUE (name);
2124       if (d)
2125         /* Reopening anonymous namespace.  */
2126         need_new = 0;
2127       implicit_use = 1;
2128     }
2129   else if (current_namespace == global_namespace
2130            && name == DECL_NAME (std_node))
2131     {
2132       in_std++;
2133       return;
2134     }
2135   else
2136     {
2137       /* Check whether this is an extended namespace definition. */
2138       d = IDENTIFIER_NAMESPACE_VALUE (name);
2139       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2140         {
2141           need_new = 0;
2142           if (DECL_NAMESPACE_ALIAS (d))
2143             {
2144               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2145                         d, DECL_NAMESPACE_ALIAS (d));
2146               d = DECL_NAMESPACE_ALIAS (d);
2147             }
2148         }
2149     }
2150
2151   if (need_new)
2152     {
2153       /* Make a new namespace, binding the name to it. */
2154       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2155       /* The global namespace is not pushed, and the global binding
2156          level is set elsewhere.  */
2157       if (!global)
2158         {
2159           d = pushdecl (d);
2160           pushlevel (0);
2161           declare_namespace_level ();
2162           NAMESPACE_LEVEL (d) = current_binding_level;
2163         }
2164     }
2165   else
2166     resume_binding_level (NAMESPACE_LEVEL (d));
2167
2168   if (implicit_use)
2169     do_using_directive (d);
2170   /* Enter the name space. */
2171   current_namespace = d;
2172 }
2173
2174 /* Pop from the scope of the current namespace.  */
2175
2176 void
2177 pop_namespace ()
2178 {
2179   if (current_namespace == global_namespace)
2180     {
2181       my_friendly_assert (in_std>0, 980421);
2182       in_std--;
2183       return;
2184     }
2185   current_namespace = CP_DECL_CONTEXT (current_namespace);
2186   /* The binding level is not popped, as it might be re-opened later.  */
2187   suspend_binding_level ();
2188 }
2189
2190 /* Concatenate the binding levels of all namespaces. */
2191
2192 void
2193 cat_namespace_levels()
2194 {
2195   tree current;
2196   tree last;
2197   struct binding_level *b;
2198
2199   last = NAMESPACE_LEVEL (global_namespace) -> names;
2200   /* The nested namespaces appear in the names list of their ancestors. */
2201   for (current = last; current; current = TREE_CHAIN (current))
2202     {
2203       /* Catch simple infinite loops.  */
2204       if (TREE_CHAIN (current) == current)
2205         my_friendly_abort (990126);
2206
2207       if (TREE_CODE (current) != NAMESPACE_DECL
2208           || DECL_NAMESPACE_ALIAS (current))
2209         continue;
2210       if (!DECL_LANG_SPECIFIC (current))
2211         {
2212           /* Hmm. std. */
2213           my_friendly_assert (current == std_node, 393);
2214           continue;
2215         }
2216       b = NAMESPACE_LEVEL (current);
2217       while (TREE_CHAIN (last))
2218         last = TREE_CHAIN (last);
2219       TREE_CHAIN (last) = NAMESPACE_LEVEL (current) -> names;
2220     }
2221 }
2222 \f
2223 /* Subroutines for reverting temporarily to top-level for instantiation
2224    of templates and such.  We actually need to clear out the class- and
2225    local-value slots of all identifiers, so that only the global values
2226    are at all visible.  Simply setting current_binding_level to the global
2227    scope isn't enough, because more binding levels may be pushed.  */
2228 struct saved_scope {
2229   struct binding_level *old_binding_level;
2230   tree old_bindings;
2231   tree old_namespace;
2232   struct saved_scope *prev;
2233   tree class_name, class_type;
2234   tree access_specifier;
2235   tree function_decl;
2236   struct binding_level *class_bindings;
2237   tree *lang_base, *lang_stack, lang_name;
2238   int lang_stacksize;
2239   int minimal_parse_mode;
2240   tree last_function_parms;
2241   tree template_parms;
2242   HOST_WIDE_INT processing_template_decl;
2243   tree previous_class_type, previous_class_values;
2244   int processing_specialization;
2245   int processing_explicit_instantiation;
2246 };
2247 static struct saved_scope *current_saved_scope;
2248
2249 /* A chain of the binding vecs created by store_bindings.  We create a
2250    whole bunch of these during compilation, on permanent_obstack, so we
2251    can't just throw them away.  */
2252 static tree free_binding_vecs;
2253
2254 static tree
2255 store_bindings (names, old_bindings)
2256      tree names, old_bindings;
2257 {
2258   tree t;
2259   for (t = names; t; t = TREE_CHAIN (t))
2260     {
2261       tree binding, t1, id;
2262
2263       if (TREE_CODE (t) == TREE_LIST)
2264         id = TREE_PURPOSE (t);
2265       else
2266         id = DECL_NAME (t);
2267
2268       if (!id
2269           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2270              we have no IDENTIFIER_BINDING if we have left the class
2271              scope, but cached the class-level declarations.  */
2272           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2273         continue;
2274
2275       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2276         if (TREE_VEC_ELT (t1, 0) == id)
2277           goto skip_it;
2278
2279       if (free_binding_vecs)
2280         {
2281           binding = free_binding_vecs;
2282           free_binding_vecs = TREE_CHAIN (free_binding_vecs);
2283         }
2284       else
2285         binding = make_tree_vec (4);
2286
2287       if (id)
2288         {
2289           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2290           TREE_VEC_ELT (binding, 0) = id;
2291           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2292           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2293           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2294           IDENTIFIER_BINDING (id) = NULL_TREE;
2295           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2296         }
2297       TREE_CHAIN (binding) = old_bindings;
2298       old_bindings = binding;
2299     skip_it:
2300       ;
2301     }
2302   return old_bindings;
2303 }
2304
2305 void
2306 maybe_push_to_top_level (pseudo)
2307      int pseudo;
2308 {
2309   extern int current_lang_stacksize;
2310   struct saved_scope *s
2311     = (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
2312   struct binding_level *b = current_binding_level;
2313   tree old_bindings = NULL_TREE;
2314
2315   push_cp_function_context (NULL_TREE);
2316
2317   if (previous_class_type)
2318     old_bindings = store_bindings (previous_class_values, old_bindings);
2319
2320   /* Have to include global_binding_level, because class-level decls
2321      aren't listed anywhere useful.  */
2322   for (; b; b = b->level_chain)
2323     {
2324       tree t;
2325
2326       /* Template IDs are inserted into the global level. If they were
2327          inserted into namespace level, finish_file wouldn't find them
2328          when doing pending instantiations. Therefore, don't stop at
2329          namespace level, but continue until :: .  */
2330       if (b == global_binding_level || (pseudo && b->pseudo_global))
2331         break;
2332
2333       old_bindings = store_bindings (b->names, old_bindings);
2334       /* We also need to check class_shadowed to save class-level type
2335          bindings, since pushclass doesn't fill in b->names.  */
2336       if (b->parm_flag == 2)
2337         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2338
2339       /* Unwind type-value slots back to top level.  */
2340       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2341         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2342     }
2343
2344   s->old_binding_level = current_binding_level;
2345   current_binding_level = b;
2346
2347   s->old_namespace = current_namespace;
2348   s->class_name = current_class_name;
2349   s->class_type = current_class_type;
2350   s->access_specifier = current_access_specifier;
2351   s->function_decl = current_function_decl;
2352   s->class_bindings = class_binding_level;
2353   s->lang_stack = current_lang_stack;
2354   s->lang_base = current_lang_base;
2355   s->lang_stacksize = current_lang_stacksize;
2356   s->lang_name = current_lang_name;
2357   s->minimal_parse_mode = minimal_parse_mode;
2358   s->last_function_parms = last_function_parms;
2359   s->template_parms = current_template_parms;
2360   s->processing_template_decl = processing_template_decl;
2361   s->previous_class_type = previous_class_type;
2362   s->previous_class_values = previous_class_values;
2363   s->processing_specialization = processing_specialization;
2364   s->processing_explicit_instantiation = processing_explicit_instantiation;
2365
2366   current_class_name = current_class_type = NULL_TREE;
2367   current_function_decl = NULL_TREE;
2368   class_binding_level = (struct binding_level *)0;
2369   current_lang_stacksize = 10;
2370   current_lang_stack = current_lang_base
2371     = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
2372   current_lang_name = lang_name_cplusplus;
2373   strict_prototype = strict_prototypes_lang_cplusplus;
2374   named_labels = NULL_TREE;
2375   shadowed_labels = NULL_TREE;
2376   minimal_parse_mode = 0;
2377   previous_class_type = previous_class_values = NULL_TREE;
2378   processing_specialization = 0;
2379   processing_explicit_instantiation = 0;
2380   current_template_parms = NULL_TREE;
2381   processing_template_decl = 0;
2382   current_namespace = global_namespace;
2383
2384   s->prev = current_saved_scope;
2385   s->old_bindings = old_bindings;
2386   current_saved_scope = s;
2387
2388   push_obstacks (&permanent_obstack, &permanent_obstack);
2389 }
2390
2391 void
2392 push_to_top_level ()
2393 {
2394   maybe_push_to_top_level (0);
2395 }
2396
2397 void
2398 pop_from_top_level ()
2399 {
2400   extern int current_lang_stacksize;
2401   struct saved_scope *s = current_saved_scope;
2402   tree t;
2403
2404   /* Clear out class-level bindings cache.  */
2405   if (previous_class_type)
2406     invalidate_class_lookup_cache ();
2407
2408   pop_obstacks ();
2409
2410   current_binding_level = s->old_binding_level;
2411   current_saved_scope = s->prev;
2412   for (t = s->old_bindings; t; )
2413     {
2414       tree save = t;
2415       tree id = TREE_VEC_ELT (t, 0);
2416       if (id)
2417         {
2418           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2419           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2420           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2421         }
2422       t = TREE_CHAIN (t);
2423       TREE_CHAIN (save) = free_binding_vecs;
2424       free_binding_vecs = save;
2425     }
2426   current_namespace = s->old_namespace;
2427   current_class_name = s->class_name;
2428   current_class_type = s->class_type;
2429   current_access_specifier = s->access_specifier;
2430   current_function_decl = s->function_decl;
2431   class_binding_level = s->class_bindings;
2432   free (current_lang_base);
2433   current_lang_base = s->lang_base;
2434   current_lang_stack = s->lang_stack;
2435   current_lang_name = s->lang_name;
2436   current_lang_stacksize = s->lang_stacksize;
2437   if (current_lang_name == lang_name_cplusplus)
2438     strict_prototype = strict_prototypes_lang_cplusplus;
2439   else if (current_lang_name == lang_name_c)
2440     strict_prototype = strict_prototypes_lang_c;
2441   minimal_parse_mode = s->minimal_parse_mode;
2442   last_function_parms = s->last_function_parms;
2443   current_template_parms = s->template_parms;
2444   processing_template_decl = s->processing_template_decl;
2445   previous_class_type = s->previous_class_type;
2446   previous_class_values = s->previous_class_values;
2447   processing_specialization = s->processing_specialization;
2448   processing_explicit_instantiation = s->processing_explicit_instantiation;
2449
2450   free (s);
2451
2452   pop_cp_function_context (NULL_TREE);
2453 }
2454 \f
2455 /* Push a definition of struct, union or enum tag "name".
2456    into binding_level "b".   "type" should be the type node,
2457    We assume that the tag "name" is not already defined.
2458
2459    Note that the definition may really be just a forward reference.
2460    In that case, the TYPE_SIZE will be a NULL_TREE.
2461
2462    C++ gratuitously puts all these tags in the name space.  */
2463
2464 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2465    record the shadowed value for this binding contour.  TYPE is
2466    the type that ID maps to.  */
2467
2468 static void
2469 set_identifier_type_value_with_scope (id, type, b)
2470      tree id;
2471      tree type;
2472      struct binding_level *b;
2473 {
2474   if (!b->namespace_p)
2475     {
2476       /* Shadow the marker, not the real thing, so that the marker
2477          gets restored later. */
2478       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2479       b->type_shadowed
2480         = tree_cons (id, old_type_value, b->type_shadowed);
2481     }
2482   else
2483     {
2484       tree binding = binding_for_name (id, current_namespace);
2485       BINDING_TYPE (binding) = type;
2486       /* Store marker instead of real type. */
2487       type = global_type_node;
2488     }
2489   SET_IDENTIFIER_TYPE_VALUE (id, type);
2490 }
2491
2492 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2493
2494 void
2495 set_identifier_type_value (id, type)
2496      tree id;
2497      tree type;
2498 {
2499   set_identifier_type_value_with_scope (id, type, current_binding_level);
2500 }
2501
2502 /* Return the type associated with id. */
2503
2504 tree
2505 identifier_type_value (id)
2506      tree id;
2507 {
2508   /* There is no type with that name, anywhere. */
2509   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2510     return NULL_TREE;
2511   /* This is not the type marker, but the real thing. */
2512   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2513     return REAL_IDENTIFIER_TYPE_VALUE (id);
2514   /* Have to search for it. It must be on the global level, now.
2515      Ask lookup_name not to return non-types. */
2516   id = lookup_name_real (id, 2, 1, 0);
2517   if (id)
2518     return TREE_TYPE (id);
2519   return NULL_TREE;
2520 }
2521
2522 /* Pop off extraneous binding levels left over due to syntax errors.
2523
2524    We don't pop past namespaces, as they might be valid.  */
2525
2526 void
2527 pop_everything ()
2528 {
2529 #ifdef DEBUG_CP_BINDING_LEVELS
2530   fprintf (stderr, "XXX entering pop_everything ()\n");
2531 #endif
2532   while (!toplevel_bindings_p ())
2533     {
2534       if (current_binding_level->parm_flag == 2)
2535         pop_nested_class (1);
2536       else
2537         poplevel (0, 0, 0);
2538     }
2539 #ifdef DEBUG_CP_BINDING_LEVELS
2540   fprintf (stderr, "XXX leaving pop_everything ()\n");
2541 #endif
2542 }
2543
2544 /* The type TYPE is being declared.  If it is a class template, or a
2545    specialization of a class template, do any processing required and
2546    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2547    being declared a friend.  B is the binding level at which this TYPE
2548    should be bound.
2549
2550    Returns the TYPE_DECL for TYPE, which may have been altered by this
2551    processing.  */
2552
2553 static tree
2554 maybe_process_template_type_declaration (type, globalize, b)
2555      tree type;
2556      int globalize;
2557      struct binding_level* b;
2558 {
2559   tree decl = TYPE_NAME (type);
2560
2561   if (processing_template_parmlist)
2562     /* You can't declare a new template type in a template parameter
2563        list.  But, you can declare a non-template type:
2564
2565          template <class A*> struct S;
2566
2567        is a forward-declaration of `A'.  */
2568     ;
2569   else
2570     {
2571       maybe_check_template_type (type);
2572
2573       my_friendly_assert (IS_AGGR_TYPE (type)
2574                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2575
2576
2577       if (/* If !GLOBALIZE then we are looking at a definition.
2578              It may not be a primary template.  (For example, in:
2579
2580                template <class T>
2581                struct S1 { class S2 {}; }
2582
2583              we have to push_template_decl for S2.)  */
2584           (processing_template_decl && !globalize)
2585           /* If we are declaring a friend template class, we will
2586              have GLOBALIZE set, since something like:
2587
2588                template <class T>
2589                struct S1 {
2590                  template <class U>
2591                  friend class S2;
2592                };
2593
2594              declares S2 to be at global scope.  */
2595           || PROCESSING_REAL_TEMPLATE_DECL_P ())
2596         {
2597           /* This may change after the call to
2598              push_template_decl_real, but we want the original value.  */
2599           tree name = DECL_NAME (decl);
2600
2601           decl = push_template_decl_real (decl, globalize);
2602           /* If the current binding level is the binding level for the
2603              template parameters (see the comment in
2604              begin_template_parm_list) and the enclosing level is a class
2605              scope, and we're not looking at a friend, push the
2606              declaration of the member class into the class scope.  In the
2607              friend case, push_template_decl will already have put the
2608              friend into global scope, if appropriate.  */
2609           if (TREE_CODE (type) != ENUMERAL_TYPE
2610               && !globalize && b->pseudo_global
2611               && b->level_chain->parm_flag == 2)
2612             {
2613               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2614               /* Put this tag on the list of tags for the class, since
2615                  that won't happen below because B is not the class
2616                  binding level, but is instead the pseudo-global level.  */
2617               b->level_chain->tags =
2618                 saveable_tree_cons (name, type, b->level_chain->tags);
2619               TREE_NONLOCAL_FLAG (type) = 1;
2620               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2621                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2622             }
2623         }
2624     }
2625
2626   return decl;
2627 }
2628
2629 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2630    Normally put it into the inner-most non-tag-transparent scope,
2631    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2632    The latter is needed for implicit declarations.  */
2633
2634 void
2635 pushtag (name, type, globalize)
2636      tree name, type;
2637      int globalize;
2638 {
2639   register struct binding_level *b;
2640   tree context = 0;
2641   tree c_decl = 0;
2642
2643   b = current_binding_level;
2644   while (b->tag_transparent
2645          || (globalize && b->parm_flag == 2))
2646     b = b->level_chain;
2647
2648   if (toplevel_bindings_p ())
2649     b->tags = perm_tree_cons (name, type, b->tags);
2650   else
2651     b->tags = saveable_tree_cons (name, type, b->tags);
2652
2653   if (name)
2654     {
2655       context = type ? TYPE_CONTEXT (type) : NULL_TREE;
2656       if (! context)
2657         {
2658           tree cs = current_scope ();
2659
2660           if (! globalize)
2661             context = cs;
2662           else if (cs != NULL_TREE
2663                    && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2664             /* When declaring a friend class of a local class, we want
2665                to inject the newly named class into the scope
2666                containing the local class, not the namespace scope.  */
2667             context = hack_decl_function_context (get_type_decl (cs));
2668         }
2669       if (context)
2670         c_decl = TREE_CODE (context) == FUNCTION_DECL
2671           ? context : TYPE_MAIN_DECL (context);
2672
2673       if (!context)
2674         context = current_namespace;
2675
2676       /* Do C++ gratuitous typedefing.  */
2677       if (IDENTIFIER_TYPE_VALUE (name) != type)
2678         {
2679           register tree d = NULL_TREE;
2680           int newdecl = 0, in_class = 0;
2681
2682           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2683               || b->parm_flag == 2)
2684             in_class = 1;
2685           else
2686             d = lookup_nested_type (type, c_decl);
2687
2688           if (d == NULL_TREE)
2689             {
2690               newdecl = 1;
2691               d = build_decl (TYPE_DECL, name, type);
2692               if (current_lang_name == lang_name_java)
2693                 TYPE_FOR_JAVA (type) = 1;
2694               SET_DECL_ARTIFICIAL (d);
2695               if (! in_class)
2696                 set_identifier_type_value_with_scope (name, type, b);
2697             }
2698           else
2699             d = TYPE_MAIN_DECL (d);
2700
2701           TYPE_NAME (type) = d;
2702           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2703
2704           d = maybe_process_template_type_declaration (type,
2705                                                        globalize, b);
2706
2707           if (b->parm_flag == 2)
2708             {
2709               if (newdecl && !PROCESSING_REAL_TEMPLATE_DECL_P ())
2710                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2711                    class.  But if it's a member template class, we
2712                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2713                    is done later.  */
2714                 finish_member_declaration (d);
2715               else
2716                 pushdecl_class_level (d);
2717             }
2718           else
2719             d = pushdecl_with_scope (d, b);
2720
2721           if (newdecl)
2722             {
2723               if (ANON_AGGRNAME_P (name))
2724                 DECL_IGNORED_P (d) = 1;
2725
2726               TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2727               DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2728               if (!uses_template_parms (type))
2729                 DECL_ASSEMBLER_NAME (d)
2730                   = get_identifier (build_overload_name (type, 1, 1));
2731             }
2732         }
2733       if (b->parm_flag == 2)
2734         {
2735           TREE_NONLOCAL_FLAG (type) = 1;
2736           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2737             CLASSTYPE_TAGS (current_class_type) = b->tags;
2738         }
2739     }
2740
2741   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2742     /* Use the canonical TYPE_DECL for this node.  */
2743     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2744   else
2745     {
2746       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2747          will be the tagged type we just added to the current
2748          binding level.  This fake NULL-named TYPE_DECL node helps
2749          dwarfout.c to know when it needs to output a
2750          representation of a tagged type, and it also gives us a
2751          convenient place to record the "scope start" address for
2752          the tagged type.  */
2753
2754       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2755       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2756     }
2757 }
2758
2759 /* Counter used to create anonymous type names.  */
2760
2761 static int anon_cnt = 0;
2762
2763 /* Return an IDENTIFIER which can be used as a name for
2764    anonymous structs and unions.  */
2765
2766 tree
2767 make_anon_name ()
2768 {
2769   char buf[32];
2770
2771   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2772   return get_identifier (buf);
2773 }
2774
2775 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2776    This keeps dbxout from getting confused.  */
2777
2778 void
2779 clear_anon_tags ()
2780 {
2781   register struct binding_level *b;
2782   register tree tags;
2783   static int last_cnt = 0;
2784
2785   /* Fast out if no new anon names were declared.  */
2786   if (last_cnt == anon_cnt)
2787     return;
2788
2789   b = current_binding_level;
2790   while (b->tag_transparent)
2791     b = b->level_chain;
2792   tags = b->tags;
2793   while (tags)
2794     {
2795       /* A NULL purpose means we have already processed all tags
2796          from here to the end of the list.  */
2797       if (TREE_PURPOSE (tags) == NULL_TREE)
2798         break;
2799       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2800         TREE_PURPOSE (tags) = NULL_TREE;
2801       tags = TREE_CHAIN (tags);
2802     }
2803   last_cnt = anon_cnt;
2804 }
2805 \f
2806 /* Subroutine of duplicate_decls: return truthvalue of whether
2807    or not types of these decls match.
2808
2809    For C++, we must compare the parameter list so that `int' can match
2810    `int&' in a parameter position, but `int&' is not confused with
2811    `const int&'.  */
2812
2813 int
2814 decls_match (newdecl, olddecl)
2815      tree newdecl, olddecl;
2816 {
2817   int types_match;
2818
2819   if (newdecl == olddecl)
2820     return 1;
2821
2822   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2823     /* If the two DECLs are not even the same kind of thing, we're not
2824        interested in their types.  */
2825     return 0;
2826
2827   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2828     {
2829       tree f1 = TREE_TYPE (newdecl);
2830       tree f2 = TREE_TYPE (olddecl);
2831       tree p1 = TYPE_ARG_TYPES (f1);
2832       tree p2 = TYPE_ARG_TYPES (f2);
2833
2834       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2835           && ! (DECL_LANGUAGE (newdecl) == lang_c
2836                 && DECL_LANGUAGE (olddecl) == lang_c))
2837         return 0;
2838
2839       /* When we parse a static member function definition,
2840          we put together a FUNCTION_DECL which thinks its type
2841          is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
2842          proceed.  */
2843       if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2844         revert_static_member_fn (&newdecl, &f1, &p1);
2845       else if (TREE_CODE (f2) == METHOD_TYPE
2846                && DECL_STATIC_FUNCTION_P (newdecl))
2847         revert_static_member_fn (&olddecl, &f2, &p2);
2848
2849       /* Here we must take care of the case where new default
2850          parameters are specified.  Also, warn if an old
2851          declaration becomes ambiguous because default
2852          parameters may cause the two to be ambiguous.  */
2853       if (TREE_CODE (f1) != TREE_CODE (f2))
2854         {
2855           if (TREE_CODE (f1) == OFFSET_TYPE)
2856             cp_compiler_error ("`%D' redeclared as member function", newdecl);
2857           else
2858             cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2859           return 0;
2860         }
2861
2862       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2863         {
2864           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2865               && p2 == NULL_TREE)
2866             {
2867               types_match = self_promoting_args_p (p1);
2868               if (p1 == void_list_node)
2869                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2870             }
2871           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2872                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2873             {
2874               types_match = self_promoting_args_p (p2);
2875               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2876             }
2877           else
2878             types_match = compparms (p1, p2);
2879         }
2880       else
2881         types_match = 0;
2882     }
2883   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2884     {
2885       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2886                                 DECL_TEMPLATE_PARMS (olddecl)))
2887         return 0;
2888
2889       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2890         types_match = 1;
2891       else
2892         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2893                                    DECL_TEMPLATE_RESULT (newdecl));
2894     }
2895   else
2896     {
2897       if (TREE_TYPE (newdecl) == error_mark_node)
2898         types_match = TREE_TYPE (olddecl) == error_mark_node;
2899       else if (TREE_TYPE (olddecl) == NULL_TREE)
2900         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2901       else if (TREE_TYPE (newdecl) == NULL_TREE)
2902         types_match = 0;
2903       else
2904         types_match = comptypes (TREE_TYPE (newdecl),
2905                                  TREE_TYPE (olddecl),
2906                                  COMPARE_REDECLARATION);
2907     }
2908
2909   return types_match;
2910 }
2911
2912 /* If NEWDECL is `static' and an `extern' was seen previously,
2913    warn about it.  (OLDDECL may be NULL_TREE; NAME contains
2914    information about previous usage as an `extern'.)
2915
2916    Note that this does not apply to the C++ case of declaring
2917    a variable `extern const' and then later `const'.
2918
2919    Don't complain about built-in functions, since they are beyond
2920    the user's control.  */
2921
2922 static void
2923 warn_extern_redeclared_static (newdecl, olddecl)
2924      tree newdecl, olddecl;
2925 {
2926   tree name;
2927
2928   static const char *explicit_extern_static_warning
2929     = "`%D' was declared `extern' and later `static'";
2930   static const char *implicit_extern_static_warning
2931     = "`%D' was declared implicitly `extern' and later `static'";
2932
2933   if (TREE_CODE (newdecl) == TYPE_DECL)
2934     return;
2935
2936   name = DECL_ASSEMBLER_NAME (newdecl);
2937   if (TREE_PUBLIC (name) && DECL_THIS_STATIC (newdecl))
2938     {
2939       /* It's okay to redeclare an ANSI built-in function as static,
2940          or to declare a non-ANSI built-in function as anything.  */
2941       if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2942              && olddecl != NULL_TREE
2943              && TREE_CODE (olddecl) == FUNCTION_DECL
2944              && (DECL_BUILT_IN (olddecl)
2945                  || DECL_BUILT_IN_NONANSI (olddecl))))
2946         {
2947           cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2948                       ? implicit_extern_static_warning
2949                       : explicit_extern_static_warning, newdecl);
2950           if (olddecl != NULL_TREE)
2951             cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2952         }
2953     }
2954 }
2955
2956 /* Handle when a new declaration NEWDECL has the same name as an old
2957    one OLDDECL in the same binding contour.  Prints an error message
2958    if appropriate.
2959
2960    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2961    Otherwise, return 0.  */
2962
2963 int
2964 duplicate_decls (newdecl, olddecl)
2965      tree newdecl, olddecl;
2966 {
2967   extern struct obstack permanent_obstack;
2968   unsigned olddecl_uid = DECL_UID (olddecl);
2969   int olddecl_friend = 0, types_match = 0;
2970   int new_defines_function = 0;
2971
2972   if (newdecl == olddecl)
2973     return 1;
2974
2975   types_match = decls_match (newdecl, olddecl);
2976
2977   /* If either the type of the new decl or the type of the old decl is an
2978      error_mark_node, then that implies that we have already issued an
2979      error (earlier) for some bogus type specification, and in that case,
2980      it is rather pointless to harass the user with yet more error message
2981      about the same declaration, so just pretend the types match here.  */
2982   if (TREE_TYPE (newdecl) == error_mark_node
2983       || TREE_TYPE (olddecl) == error_mark_node)
2984     types_match = 1;
2985
2986   /* Check for redeclaration and other discrepancies. */
2987   if (TREE_CODE (olddecl) == FUNCTION_DECL
2988       && DECL_ARTIFICIAL (olddecl)
2989       && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
2990     {
2991       /* If you declare a built-in or predefined function name as static,
2992          the old definition is overridden, but optionally warn this was a
2993          bad choice of name.  Ditto for overloads.  */
2994       if (! TREE_PUBLIC (newdecl)
2995           || (TREE_CODE (newdecl) == FUNCTION_DECL
2996               && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2997         {
2998           if (warn_shadow)
2999             cp_warning ("shadowing %s function `%#D'",
3000                         DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3001                         olddecl);
3002           /* Discard the old built-in function.  */
3003           return 0;
3004         }
3005       else if (! types_match)
3006         {
3007           if (TREE_CODE (newdecl) != FUNCTION_DECL)
3008             {
3009               /* If the built-in is not ansi, then programs can override
3010                  it even globally without an error.  */
3011               if (! DECL_BUILT_IN (olddecl))
3012                 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3013                             olddecl, newdecl);
3014               else
3015                 {
3016                   cp_error ("declaration of `%#D'", newdecl);
3017                   cp_error ("conflicts with built-in declaration `%#D'",
3018                             olddecl);
3019                 }
3020               return 0;
3021             }
3022
3023           cp_warning ("declaration of `%#D'", newdecl);
3024           cp_warning ("conflicts with built-in declaration `%#D'",
3025                       olddecl);
3026         }
3027     }
3028   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3029     {
3030       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3031            && TREE_CODE (newdecl) != TYPE_DECL
3032            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3033                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3034           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3035               && TREE_CODE (olddecl) != TYPE_DECL
3036               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3037                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3038                         == TYPE_DECL))))
3039         {
3040           /* We do nothing special here, because C++ does such nasty
3041              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3042              get shadowed, and know that if we need to find a TYPE_DECL
3043              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3044              slot of the identifier.  */
3045           return 0;
3046         }
3047
3048       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3049            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3050           || (TREE_CODE (olddecl) == FUNCTION_DECL
3051               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3052         return 0;
3053
3054       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3055       if (TREE_CODE (olddecl) == TREE_LIST)
3056         olddecl = TREE_VALUE (olddecl);
3057       cp_error_at ("previous declaration of `%#D'", olddecl);
3058
3059       /* New decl is completely inconsistent with the old one =>
3060          tell caller to replace the old one.  */
3061
3062       return 0;
3063     }
3064   else if (!types_match)
3065     {
3066       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl))
3067         /* These are certainly not duplicate declarations; they're
3068            from different scopes.  */
3069         return 0;
3070
3071       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3072         {
3073           /* The name of a class template may not be declared to refer to
3074              any other template, class, function, object, namespace, value,
3075              or type in the same scope.  */
3076           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3077               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3078             {
3079               cp_error ("declaration of template `%#D'", newdecl);
3080               cp_error_at ("conflicts with previous declaration `%#D'",
3081                            olddecl);
3082             }
3083           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3084                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3085                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3086                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3087                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3088                                            DECL_TEMPLATE_PARMS (olddecl)))
3089             {
3090               cp_error ("new declaration `%#D'", newdecl);
3091               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3092             }
3093           return 0;
3094         }
3095       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3096         {
3097           if (DECL_LANGUAGE (newdecl) == lang_c
3098               && DECL_LANGUAGE (olddecl) == lang_c)
3099             {
3100               cp_error ("declaration of C function `%#D' conflicts with",
3101                         newdecl);
3102               cp_error_at ("previous declaration `%#D' here", olddecl);
3103             }
3104           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3105                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3106             {
3107               cp_error ("new declaration `%#D'", newdecl);
3108               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3109             }
3110           else
3111             return 0;
3112         }
3113
3114       /* Already complained about this, so don't do so again.  */
3115       else if (current_class_type == NULL_TREE
3116           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3117         {
3118           cp_error ("conflicting types for `%#D'", newdecl);
3119           cp_error_at ("previous declaration as `%#D'", olddecl);
3120         }
3121     }
3122   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3123             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3124                  && (!DECL_TEMPLATE_INFO (newdecl)
3125                      || (DECL_TI_TEMPLATE (newdecl)
3126                          != DECL_TI_TEMPLATE (olddecl))))
3127                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3128                     && (!DECL_TEMPLATE_INFO (olddecl)
3129                         || (DECL_TI_TEMPLATE (olddecl)
3130                             != DECL_TI_TEMPLATE (newdecl))))))
3131     /* It's OK to have a template specialization and a non-template
3132        with the same type, or to have specializations of two
3133        different templates with the same type.  Note that if one is a
3134        specialization, and the other is an instantiation of the same
3135        template, that we do not exit at this point.  That situation
3136        can occur if we instantiate a template class, and then
3137        specialize one of its methods.  This situation is legal, but
3138        the declarations must be merged in the usual way.  */
3139     return 0;
3140   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3141            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3142                 && !DECL_USE_TEMPLATE (newdecl))
3143                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3144                    && !DECL_USE_TEMPLATE (olddecl))))
3145     /* One of the declarations is a template instantiation, and the
3146        other is not a template at all.  That's OK.  */
3147     return 0;
3148   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3149            && DECL_NAMESPACE_ALIAS (newdecl)
3150            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3151     /* Redeclaration of namespace alias, ignore it. */
3152     return 1;
3153   else
3154     {
3155       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3156       if (errmsg)
3157         {
3158           cp_error (errmsg, newdecl);
3159           if (DECL_NAME (olddecl) != NULL_TREE)
3160             cp_error_at ((DECL_INITIAL (olddecl)
3161                           && namespace_bindings_p ())
3162                          ? "`%#D' previously defined here"
3163                          : "`%#D' previously declared here", olddecl);
3164         }
3165       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3166                && DECL_INITIAL (olddecl) != NULL_TREE
3167                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3168                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3169         {
3170           /* Prototype decl follows defn w/o prototype.  */
3171           cp_warning_at ("prototype for `%#D'", newdecl);
3172           cp_warning_at ("follows non-prototype definition here", olddecl);
3173         }
3174       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3175                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3176         {
3177           /* extern "C" int foo ();
3178              int foo () { bar (); }
3179              is OK.  */
3180           if (current_lang_stack == current_lang_base)
3181             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3182           else
3183             {
3184               cp_error_at ("previous declaration of `%#D' with %L linkage",
3185                            olddecl, DECL_LANGUAGE (olddecl));
3186               cp_error ("conflicts with new declaration with %L linkage",
3187                         DECL_LANGUAGE (newdecl));
3188             }
3189         }
3190
3191       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3192         ;
3193       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3194         {
3195           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3196           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3197           int i = 1;
3198
3199           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3200             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3201
3202           for (; t1 && t1 != void_list_node;
3203                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3204             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3205               {
3206                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3207                                            TREE_PURPOSE (t2)))
3208                   {
3209                     if (pedantic)
3210                       {
3211                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3212                                     i, newdecl);
3213                         cp_pedwarn_at ("after previous specification in `%#D'",
3214                                        olddecl);
3215                       }
3216                   }
3217                 else
3218                   {
3219                     cp_error ("default argument given for parameter %d of `%#D'",
3220                               i, newdecl);
3221                     cp_error_at ("after previous specification in `%#D'",
3222                                  olddecl);
3223                   }
3224               }
3225
3226           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3227               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3228             {
3229               cp_warning ("`%#D' was used before it was declared inline",
3230                           newdecl);
3231               cp_warning_at ("previous non-inline declaration here",
3232                              olddecl);
3233             }
3234         }
3235     }
3236
3237   /* If new decl is `static' and an `extern' was seen previously,
3238      warn about it.  */
3239   warn_extern_redeclared_static (newdecl, olddecl);
3240
3241   /* We have committed to returning 1 at this point.  */
3242   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3243     {
3244       /* Now that functions must hold information normally held
3245          by field decls, there is extra work to do so that
3246          declaration information does not get destroyed during
3247          definition.  */
3248       if (DECL_VINDEX (olddecl))
3249         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3250       if (DECL_CONTEXT (olddecl))
3251         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3252       if (DECL_CLASS_CONTEXT (olddecl))
3253         DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
3254       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3255         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3256       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3257       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3258       DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
3259       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3260       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3261       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3262
3263       /* Optionally warn about more than one declaration for the same
3264          name, but don't warn about a function declaration followed by a
3265          definition.  */
3266       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3267           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3268           /* Don't warn about extern decl followed by definition. */
3269           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3270           /* Don't warn about friends, let add_friend take care of it. */
3271           && ! DECL_FRIEND_P (newdecl))
3272         {
3273           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3274           cp_warning_at ("previous declaration of `%D'", olddecl);
3275         }
3276     }
3277
3278   /* Deal with C++: must preserve virtual function table size.  */
3279   if (TREE_CODE (olddecl) == TYPE_DECL)
3280     {
3281       register tree newtype = TREE_TYPE (newdecl);
3282       register tree oldtype = TREE_TYPE (olddecl);
3283
3284       if (newtype != error_mark_node && oldtype != error_mark_node
3285           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3286         {
3287           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3288           CLASSTYPE_FRIEND_CLASSES (newtype)
3289             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3290         }
3291     }
3292
3293   /* Copy all the DECL_... slots specified in the new decl
3294      except for any that we copy here from the old type.  */
3295   DECL_MACHINE_ATTRIBUTES (newdecl)
3296     = merge_machine_decl_attributes (olddecl, newdecl);
3297
3298   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3299     {
3300       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3301                              DECL_TEMPLATE_RESULT (olddecl)))
3302         cp_error ("invalid redeclaration of %D", newdecl);
3303       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3304       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3305         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3306                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3307
3308       return 1;
3309     }
3310
3311   if (types_match)
3312     {
3313       /* Automatically handles default parameters.  */
3314       tree oldtype = TREE_TYPE (olddecl);
3315       tree newtype;
3316
3317       /* Make sure we put the new type in the same obstack as the old one.  */
3318       if (oldtype)
3319         push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
3320       else
3321         {
3322           push_obstacks_nochange ();
3323           end_temporary_allocation ();
3324         }
3325
3326       /* Merge the data types specified in the two decls.  */
3327       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3328
3329       if (TREE_CODE (newdecl) == VAR_DECL)
3330         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3331       /* Do this after calling `common_type' so that default
3332          parameters don't confuse us.  */
3333       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3334           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3335               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3336         {
3337           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3338                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3339           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3340                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3341
3342           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3343               && DECL_SOURCE_LINE (olddecl) != 0
3344               && flag_exceptions
3345               && ! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
3346             {
3347               cp_pedwarn ("declaration of `%D' throws different exceptions",
3348                         newdecl);
3349               cp_pedwarn_at ("previous declaration here", olddecl);
3350             }
3351         }
3352       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3353
3354       /* Lay the type out, unless already done.  */
3355       if (! same_type_p (newtype, oldtype)
3356           && TREE_TYPE (newdecl) != error_mark_node
3357           && !(processing_template_decl && uses_template_parms (newdecl)))
3358         layout_type (TREE_TYPE (newdecl));
3359
3360       if ((TREE_CODE (newdecl) == VAR_DECL
3361            || TREE_CODE (newdecl) == PARM_DECL
3362            || TREE_CODE (newdecl) == RESULT_DECL
3363            || TREE_CODE (newdecl) == FIELD_DECL
3364            || TREE_CODE (newdecl) == TYPE_DECL)
3365           && !(processing_template_decl && uses_template_parms (newdecl)))
3366         layout_decl (newdecl, 0);
3367
3368       /* Merge the type qualifiers.  */
3369       if (TREE_READONLY (newdecl))
3370         TREE_READONLY (olddecl) = 1;
3371       if (TREE_THIS_VOLATILE (newdecl))
3372         TREE_THIS_VOLATILE (olddecl) = 1;
3373
3374       /* Merge the initialization information.  */
3375       if (DECL_INITIAL (newdecl) == NULL_TREE
3376           && DECL_INITIAL (olddecl) != NULL_TREE)
3377         {
3378           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3379           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3380           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3381           if (DECL_LANG_SPECIFIC (newdecl)
3382               && DECL_LANG_SPECIFIC (olddecl))
3383             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3384         }
3385
3386       /* Merge the section attribute.
3387          We want to issue an error if the sections conflict but that must be
3388          done later in decl_attributes since we are called before attributes
3389          are assigned.  */
3390       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3391         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3392
3393       /* Keep the old rtl since we can safely use it, unless it's the
3394          call to abort() used for abstract virtuals.  */
3395       if ((DECL_LANG_SPECIFIC (olddecl)
3396            && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
3397           || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
3398         DECL_RTL (newdecl) = DECL_RTL (olddecl);
3399
3400       pop_obstacks ();
3401     }
3402   /* If cannot merge, then use the new type and qualifiers,
3403      and don't preserve the old rtl.  */
3404   else
3405     {
3406       /* Clean out any memory we had of the old declaration.  */
3407       tree oldstatic = value_member (olddecl, static_aggregates);
3408       if (oldstatic)
3409         TREE_VALUE (oldstatic) = error_mark_node;
3410
3411       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3412       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3413       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3414       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3415     }
3416
3417   /* Merge the storage class information.  */
3418   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3419   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3420   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3421   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3422   if (! DECL_EXTERNAL (olddecl))
3423     DECL_EXTERNAL (newdecl) = 0;
3424
3425   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3426     {
3427       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3428       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3429       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3430       DECL_TEMPLATE_INSTANTIATED (newdecl)
3431         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3432       /* Don't really know how much of the language-specific
3433          values we should copy from old to new.  */
3434       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3435       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3436       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3437       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3438       olddecl_friend = DECL_FRIEND_P (olddecl);
3439
3440       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3441       if (TREE_CODE (newdecl) == FUNCTION_DECL
3442           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3443         DECL_BEFRIENDING_CLASSES (newdecl)
3444           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3445                      DECL_BEFRIENDING_CLASSES (olddecl));
3446     }
3447
3448   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3449     {
3450       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3451           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3452         {
3453           /* If newdecl is not a specialization, then it is not a
3454              template-related function at all.  And that means that we
3455              shoud have exited above, returning 0.  */
3456           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3457                               0);
3458
3459           if (TREE_USED (olddecl))
3460             /* From [temp.expl.spec]:
3461
3462                If a template, a member template or the member of a class
3463                template is explicitly specialized then that
3464                specialization shall be declared before the first use of
3465                that specialization that would cause an implicit
3466                instantiation to take place, in every translation unit in
3467                which such a use occurs.  */
3468             cp_error ("explicit specialization of %D after first use",
3469                       olddecl);
3470
3471           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3472         }
3473       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3474
3475       /* If either decl says `inline', this fn is inline, unless its
3476          definition was passed already.  */
3477       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3478         DECL_INLINE (olddecl) = 1;
3479       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3480
3481       if (! types_match)
3482         {
3483           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3484           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3485           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3486         }
3487       if (! types_match || new_defines_function)
3488         {
3489           /* These need to be copied so that the names are available.  */
3490           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3491           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3492         }
3493       if (new_defines_function)
3494         /* If defining a function declared with other language
3495            linkage, use the previously declared language linkage.  */
3496         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3497       else
3498         {
3499           /* If redeclaring a builtin function, and not a definition,
3500              it stays built in.  */
3501           if (DECL_BUILT_IN (olddecl))
3502             {
3503               DECL_BUILT_IN (newdecl) = 1;
3504               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3505               /* If we're keeping the built-in definition, keep the rtl,
3506                  regardless of declaration matches.  */
3507               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3508             }
3509           else
3510             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3511
3512           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3513           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3514             /* Previously saved insns go together with
3515                the function's previous definition.  */
3516             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3517           /* Don't clear out the arguments if we're redefining a function.  */
3518           if (DECL_ARGUMENTS (olddecl))
3519             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3520         }
3521       if (DECL_LANG_SPECIFIC (olddecl))
3522         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3523     }
3524
3525   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3526     {
3527       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3528     }
3529
3530   /* Now preserve various other info from the definition.  */
3531   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3532   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3533   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3534   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3535
3536   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3537     {
3538       int function_size;
3539       struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
3540       struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
3541
3542       function_size = sizeof (struct tree_decl);
3543
3544       bcopy ((char *) newdecl + sizeof (struct tree_common),
3545              (char *) olddecl + sizeof (struct tree_common),
3546              function_size - sizeof (struct tree_common));
3547
3548       /* Can we safely free the storage used by newdecl?  */
3549
3550 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3551                   & ~ obstack_alignment_mask (&permanent_obstack))
3552
3553       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3554         {
3555           /* If newdecl is a template instantiation, it is possible that
3556              the following sequence of events has occurred:
3557
3558              o A friend function was declared in a class template.  The
3559              class template was instantiated.
3560
3561              o The instantiation of the friend declaration was
3562              recorded on the instantiation list, and is newdecl.
3563
3564              o Later, however, instantiate_class_template called pushdecl
3565              on the newdecl to perform name injection.  But, pushdecl in
3566              turn called duplicate_decls when it discovered that another
3567              declaration of a global function with the same name already
3568              existed.
3569
3570              o Here, in duplicate_decls, we decided to clobber newdecl.
3571
3572              If we're going to do that, we'd better make sure that
3573              olddecl, and not newdecl, is on the list of
3574              instantiations so that if we try to do the instantiation
3575              again we won't get the clobbered declaration.  */
3576
3577           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3578           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3579
3580           for (; decls; decls = TREE_CHAIN (decls))
3581             if (TREE_VALUE (decls) == newdecl)
3582               TREE_VALUE (decls) = olddecl;
3583         }
3584
3585       if (((char *)newdecl + ROUND (function_size) == (char *)nl
3586            && ((char *)newdecl + ROUND (function_size)
3587                + ROUND (sizeof (struct lang_decl))
3588                == obstack_next_free (&permanent_obstack)))
3589           || ((char *)newdecl + ROUND (function_size)
3590               == obstack_next_free (&permanent_obstack)))
3591         {
3592           DECL_MAIN_VARIANT (newdecl) = olddecl;
3593           DECL_LANG_SPECIFIC (olddecl) = ol;
3594           bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
3595
3596           obstack_free (&permanent_obstack, newdecl);
3597         }
3598       else if (LANG_DECL_PERMANENT (ol) && ol != nl)
3599         {
3600           if (DECL_MAIN_VARIANT (olddecl) == olddecl)
3601             {
3602               /* Save these lang_decls that would otherwise be lost.  */
3603               extern tree free_lang_decl_chain;
3604               tree free_lang_decl = (tree) ol;
3605
3606               if (DECL_LANG_SPECIFIC (olddecl) == ol)
3607                 abort ();
3608
3609               TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
3610               free_lang_decl_chain = free_lang_decl;
3611             }
3612           else
3613             {
3614               /* Storage leak.  */;
3615             }
3616         }
3617     }
3618   else
3619     {
3620       bcopy ((char *) newdecl + sizeof (struct tree_common),
3621              (char *) olddecl + sizeof (struct tree_common),
3622              sizeof (struct tree_decl) - sizeof (struct tree_common)
3623              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3624     }
3625
3626   DECL_UID (olddecl) = olddecl_uid;
3627   if (olddecl_friend)
3628     DECL_FRIEND_P (olddecl) = 1;
3629
3630   /* NEWDECL contains the merged attribute lists.
3631      Update OLDDECL to be the same.  */
3632   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3633
3634   return 1;
3635 }
3636
3637 /* Record a decl-node X as belonging to the current lexical scope.
3638    Check for errors (such as an incompatible declaration for the same
3639    name already seen in the same scope).
3640
3641    Returns either X or an old decl for the same name.
3642    If an old decl is returned, it may have been smashed
3643    to agree with what X says.  */
3644
3645 tree
3646 pushdecl (x)
3647      tree x;
3648 {
3649   register tree t;
3650   register tree name = DECL_ASSEMBLER_NAME (x);
3651   int need_new_binding = 1;
3652
3653   if (DECL_TEMPLATE_PARM_P (x))
3654     /* Template parameters have no context; they are not X::T even
3655        when declared within a class or namespace.  */
3656     ;
3657   else
3658     {
3659       if (current_function_decl && x != current_function_decl
3660           /* A local declaration for a function doesn't constitute
3661              nesting.  */
3662           && (TREE_CODE (x) != FUNCTION_DECL || DECL_INITIAL (x))
3663           /* Don't change DECL_CONTEXT of virtual methods.  */
3664           && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3665           && !DECL_CONTEXT (x))
3666         DECL_CONTEXT (x) = current_function_decl;
3667       if (!DECL_CONTEXT (x))
3668         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3669     }
3670
3671   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3672      compiler wants to use.  */
3673   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3674       || TREE_CODE (x) == NAMESPACE_DECL)
3675     name = DECL_NAME (x);
3676
3677   if (name)
3678     {
3679 #if 0
3680       /* Not needed...see below.  */
3681       char *file;
3682       int line;
3683 #endif
3684       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3685         name = TREE_OPERAND (name, 0);
3686
3687       /* Namespace-scoped variables are not found in the current level. */
3688       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3689         t = namespace_binding (name, DECL_CONTEXT (x));
3690       else
3691         t = lookup_name_current_level (name);
3692       if (t == error_mark_node)
3693         {
3694           /* error_mark_node is 0 for a while during initialization!  */
3695           t = NULL_TREE;
3696           cp_error_at ("`%#D' used prior to declaration", x);
3697         }
3698
3699       else if (t != NULL_TREE)
3700         {
3701 #if 0
3702           /* This is turned off until I have time to do it right (bpk).  */
3703           /* With the code below that uses it...  */
3704           file = DECL_SOURCE_FILE (t);
3705           line = DECL_SOURCE_LINE (t);
3706 #endif
3707           if (TREE_CODE (t) == PARM_DECL)
3708             {
3709               if (DECL_CONTEXT (t) == NULL_TREE)
3710                 fatal ("parse errors have confused me too much");
3711
3712               /* Check for duplicate params.  */
3713               if (duplicate_decls (x, t))
3714                 return t;
3715             }
3716           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3717                     || DECL_FUNCTION_TEMPLATE_P (x))
3718                    && is_overloaded_fn (t))
3719             /* Don't do anything just yet. */;
3720           else if (t == wchar_decl_node)
3721             {
3722               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3723                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3724
3725               /* Throw away the redeclaration.  */
3726               return t;
3727             }
3728           else if (TREE_CODE (t) != TREE_CODE (x))
3729             {
3730               if (duplicate_decls (x, t))
3731                 return t;
3732             }
3733           else if (duplicate_decls (x, t))
3734             {
3735 #if 0
3736               /* This is turned off until I have time to do it right (bpk).  */
3737
3738               /* Also warn if they did a prototype with `static' on it, but
3739                  then later left the `static' off.  */
3740               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3741                 {
3742                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3743                     return t;
3744
3745                   if (extra_warnings)
3746                     {
3747                       cp_warning ("`static' missing from declaration of `%D'",
3748                                   t);
3749                       warning_with_file_and_line (file, line,
3750                                                   "previous declaration of `%s'",
3751                                                   decl_as_string (t, 0));
3752                     }
3753
3754                   /* Now fix things so it'll do what they expect.  */
3755                   if (current_function_decl)
3756                     TREE_PUBLIC (current_function_decl) = 0;
3757                 }
3758               /* Due to interference in memory reclamation (X may be
3759                  obstack-deallocated at this point), we must guard against
3760                  one really special case.  [jason: This should be handled
3761                  by start_function]  */
3762               if (current_function_decl == x)
3763                 current_function_decl = t;
3764 #endif
3765               if (TREE_CODE (t) == TYPE_DECL)
3766                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3767               else if (TREE_CODE (t) == FUNCTION_DECL)
3768                 check_default_args (t);
3769
3770               return t;
3771             }
3772           else if (DECL_MAIN_P (x))
3773             {
3774               /* A redeclaration of main, but not a duplicate of the
3775                  previous one.
3776
3777                  [basic.start.main]
3778
3779                  This function shall not be overloaded.  */
3780               cp_error_at ("invalid redeclaration of `%D'", t);
3781               cp_error ("as `%D'", x);
3782               /* We don't try to push this declaration since that
3783                  causes a crash.  */
3784               return x;
3785             }
3786         }
3787
3788       check_template_shadow (x);
3789
3790       /* If this is a function conjured up by the backend, massage it
3791          so it looks friendly.  */
3792       if (TREE_CODE (x) == FUNCTION_DECL
3793           && ! DECL_LANG_SPECIFIC (x))
3794         {
3795           retrofit_lang_decl (x);
3796           DECL_LANGUAGE (x) = lang_c;
3797         }
3798
3799       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3800         {
3801           t = push_overloaded_decl (x, PUSH_LOCAL);
3802           if (t != x || DECL_LANGUAGE (x) == lang_c)
3803             return t;
3804           if (!namespace_bindings_p ())
3805             /* We do not need to create a binding for this name;
3806                push_overloaded_decl will have already done so if
3807                necessary.  */
3808             need_new_binding = 0;
3809         }
3810       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3811         return push_overloaded_decl (x, PUSH_GLOBAL);
3812
3813       /* If declaring a type as a typedef, copy the type (unless we're
3814          at line 0), and install this TYPE_DECL as the new type's typedef
3815          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3816       if (TREE_CODE (x) == TYPE_DECL)
3817         {
3818           tree type = TREE_TYPE (x);
3819           if (DECL_SOURCE_LINE (x) == 0)
3820             {
3821               if (TYPE_NAME (type) == 0)
3822                 TYPE_NAME (type) = x;
3823             }
3824           else if (type != error_mark_node && TYPE_NAME (type) != x
3825                    /* We don't want to copy the type when all we're
3826                       doing is making a TYPE_DECL for the purposes of
3827                       inlining.  */
3828                    && (!TYPE_NAME (type)
3829                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3830             {
3831               push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
3832
3833               DECL_ORIGINAL_TYPE (x) = type;
3834               type = build_type_copy (type);
3835               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3836               TYPE_NAME (type) = x;
3837               TREE_TYPE (x) = type;
3838
3839               pop_obstacks ();
3840             }
3841
3842           if (type != error_mark_node
3843               && TYPE_NAME (type)
3844               && TYPE_IDENTIFIER (type))
3845             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3846                                                   current_binding_level);
3847
3848         }
3849
3850       /* Multiple external decls of the same identifier ought to match.
3851
3852          We get warnings about inline functions where they are defined.
3853          We get warnings about other functions from push_overloaded_decl.
3854
3855          Avoid duplicate warnings where they are used.  */
3856       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3857         {
3858           tree decl;
3859
3860           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3861               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3862                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3863             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3864           else
3865             decl = NULL_TREE;
3866
3867           if (decl
3868               /* If different sort of thing, we already gave an error.  */
3869               && TREE_CODE (decl) == TREE_CODE (x)
3870               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3871             {
3872               cp_pedwarn ("type mismatch with previous external decl", x);
3873               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3874             }
3875         }
3876
3877       /* This name is new in its binding level.
3878          Install the new declaration and return it.  */
3879       if (namespace_bindings_p ())
3880         {
3881           /* Install a global value.  */
3882
3883           /* If the first global decl has external linkage,
3884              warn if we later see static one.  */
3885           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3886             TREE_PUBLIC (name) = 1;
3887
3888           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3889                 && t != NULL_TREE))
3890             {
3891               if (TREE_CODE (x) == FUNCTION_DECL)
3892                 my_friendly_assert
3893                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3894                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3895               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3896             }
3897
3898           /* Don't forget if the function was used via an implicit decl.  */
3899           if (IDENTIFIER_IMPLICIT_DECL (name)
3900               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3901             TREE_USED (x) = 1;
3902
3903           /* Don't forget if its address was taken in that way.  */
3904           if (IDENTIFIER_IMPLICIT_DECL (name)
3905               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3906             TREE_ADDRESSABLE (x) = 1;
3907
3908           /* Warn about mismatches against previous implicit decl.  */
3909           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3910               /* If this real decl matches the implicit, don't complain.  */
3911               && ! (TREE_CODE (x) == FUNCTION_DECL
3912                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3913             cp_warning
3914               ("`%D' was previously implicitly declared to return `int'", x);
3915
3916           /* If new decl is `static' and an `extern' was seen previously,
3917              warn about it.  */
3918           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3919             warn_extern_redeclared_static (x, t);
3920         }
3921       else
3922         {
3923           /* Here to install a non-global value.  */
3924           tree oldlocal = IDENTIFIER_VALUE (name);
3925           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3926
3927           if (need_new_binding)
3928             {
3929               push_local_binding (name, x, 0);
3930               /* Because push_local_binding will hook X on to the
3931                  current_binding_level's name list, we don't want to
3932                  do that again below.  */
3933               need_new_binding = 0;
3934             }
3935
3936           /* If this is a TYPE_DECL, push it into the type value slot.  */
3937           if (TREE_CODE (x) == TYPE_DECL)
3938             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3939                                                   current_binding_level);
3940
3941           /* Clear out any TYPE_DECL shadowed by a namespace so that
3942              we won't think this is a type.  The C struct hack doesn't
3943              go through namespaces.  */
3944           if (TREE_CODE (x) == NAMESPACE_DECL)
3945             set_identifier_type_value_with_scope (name, NULL_TREE,
3946                                                   current_binding_level);
3947
3948           /* If this is an extern function declaration, see if we
3949              have a global definition or declaration for the function.  */
3950           if (oldlocal == NULL_TREE
3951               && DECL_EXTERNAL (x)
3952               && oldglobal != NULL_TREE
3953               && TREE_CODE (x) == FUNCTION_DECL
3954               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3955             {
3956               /* We have one.  Their types must agree.  */
3957               if (decls_match (x, oldglobal))
3958                 /* OK */;
3959               else
3960                 {
3961                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3962                   cp_warning_at ("global declaration `%#D'", oldglobal);
3963                 }
3964             }
3965           /* If we have a local external declaration,
3966              and no file-scope declaration has yet been seen,
3967              then if we later have a file-scope decl it must not be static.  */
3968           if (oldlocal == NULL_TREE
3969               && oldglobal == NULL_TREE
3970               && DECL_EXTERNAL (x)
3971               && TREE_PUBLIC (x))
3972             TREE_PUBLIC (name) = 1;
3973
3974           if (DECL_FROM_INLINE (x))
3975             /* Inline decls shadow nothing.  */;
3976
3977           /* Warn if shadowing an argument at the top level of the body.  */
3978           else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3979               && TREE_CODE (oldlocal) == PARM_DECL
3980               && TREE_CODE (x) != PARM_DECL)
3981             {
3982               /* Go to where the parms should be and see if we
3983                  find them there.  */
3984               struct binding_level *b = current_binding_level->level_chain;
3985
3986               if (cleanup_label)
3987                 b = b->level_chain;
3988
3989               /* ARM $8.3 */
3990               if (b->parm_flag == 1)
3991                 cp_error ("declaration of `%#D' shadows a parameter", name);
3992             }
3993           else if (warn_shadow && oldlocal != NULL_TREE
3994                    && current_binding_level->is_for_scope
3995                    && !DECL_DEAD_FOR_LOCAL (oldlocal))
3996             {
3997               warning ("variable `%s' shadows local",
3998                        IDENTIFIER_POINTER (name));
3999               cp_warning_at ("  this is the shadowed declaration", oldlocal);
4000             }
4001           /* Maybe warn if shadowing something else.  */
4002           else if (warn_shadow && !DECL_EXTERNAL (x)
4003                    /* No shadow warnings for internally generated vars.  */
4004                    && ! DECL_ARTIFICIAL (x)
4005                    /* No shadow warnings for vars made for inlining.  */
4006                    && ! DECL_FROM_INLINE (x))
4007             {
4008               const char *warnstring = NULL;
4009
4010               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4011                 warnstring = "declaration of `%s' shadows a parameter";
4012               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4013                        && current_class_ptr
4014                        && !TREE_STATIC (name))
4015                 warnstring = "declaration of `%s' shadows a member of `this'";
4016               else if (oldlocal != NULL_TREE)
4017                 warnstring = "declaration of `%s' shadows previous local";
4018               else if (oldglobal != NULL_TREE)
4019                 /* XXX shadow warnings in outer-more namespaces */
4020                 warnstring = "declaration of `%s' shadows global declaration";
4021
4022               if (warnstring)
4023                 warning (warnstring, IDENTIFIER_POINTER (name));
4024             }
4025         }
4026
4027       if (TREE_CODE (x) == FUNCTION_DECL)
4028         check_default_args (x);
4029
4030       /* Keep count of variables in this level with incomplete type.  */
4031       if (TREE_CODE (x) == VAR_DECL
4032           && TREE_TYPE (x) != error_mark_node
4033           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4034                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4035               /* RTTI TD entries are created while defining the type_info.  */
4036               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4037                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4038         current_binding_level->incomplete
4039           = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4040     }
4041
4042   if (need_new_binding)
4043     {
4044       /* Put decls on list in reverse order.
4045          We will reverse them later if necessary.  */
4046       TREE_CHAIN (x) = current_binding_level->names;
4047       current_binding_level->names = x;
4048       if (current_binding_level == global_binding_level
4049           && !TREE_PERMANENT (x))
4050         my_friendly_abort (124);
4051     }
4052
4053   return x;
4054 }
4055
4056 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4057    caller to set DECL_CONTEXT properly.  */
4058
4059 static tree
4060 pushdecl_with_scope (x, level)
4061      tree x;
4062      struct binding_level *level;
4063 {
4064   register struct binding_level *b;
4065   tree function_decl = current_function_decl;
4066
4067   current_function_decl = NULL_TREE;
4068   if (level->parm_flag == 2)
4069     {
4070       b = class_binding_level;
4071       class_binding_level = level;
4072       pushdecl_class_level (x);
4073       class_binding_level = b;
4074     }
4075   else
4076     {
4077       b = current_binding_level;
4078       current_binding_level = level;
4079       x = pushdecl (x);
4080       current_binding_level = b;
4081     }
4082   current_function_decl = function_decl;
4083   return x;
4084 }
4085
4086 /* Like pushdecl, only it places X in the current namespace,
4087    if appropriate.  */
4088
4089 tree
4090 pushdecl_namespace_level (x)
4091      tree x;
4092 {
4093   register struct binding_level *b = current_binding_level;
4094   register tree t;
4095
4096   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4097
4098   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4099      what we want.  */
4100   if (TREE_CODE (x) == TYPE_DECL)
4101     {
4102       tree name = DECL_NAME (x);
4103       tree newval;
4104       tree *ptr = (tree *)0;
4105       for (; b != global_binding_level; b = b->level_chain)
4106         {
4107           tree shadowed = b->type_shadowed;
4108           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4109             if (TREE_PURPOSE (shadowed) == name)
4110               {
4111                 ptr = &TREE_VALUE (shadowed);
4112                 /* Can't break out of the loop here because sometimes
4113                    a binding level will have duplicate bindings for
4114                    PT names.  It's gross, but I haven't time to fix it.  */
4115               }
4116         }
4117       newval = TREE_TYPE (x);
4118       if (ptr == (tree *)0)
4119         {
4120           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4121              up here if this is changed to an assertion.  --KR  */
4122           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4123         }
4124       else
4125         {
4126           *ptr = newval;
4127         }
4128     }
4129   return t;
4130 }
4131
4132 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4133    if appropriate.  */
4134
4135 tree
4136 pushdecl_top_level (x)
4137      tree x;
4138 {
4139   tree cur_namespace = current_namespace;
4140   current_namespace = global_namespace;
4141   x = pushdecl_namespace_level (x);
4142   current_namespace = cur_namespace;
4143   return x;
4144 }
4145
4146 /* Make the declaration of X appear in CLASS scope.  */
4147
4148 void
4149 pushdecl_class_level (x)
4150      tree x;
4151 {
4152   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4153      scope looks for the pre-mangled name.  */
4154   register tree name;
4155
4156   if (TREE_CODE (x) == OVERLOAD)
4157     x = OVL_CURRENT (x);
4158   name = DECL_NAME (x);
4159
4160   if (name)
4161     {
4162       push_class_level_binding (name, x);
4163       if (TREE_CODE (x) == TYPE_DECL)
4164         set_identifier_type_value (name, TREE_TYPE (x));
4165     }
4166   else if (ANON_UNION_TYPE_P (TREE_TYPE (x)))
4167     {
4168       tree f;
4169
4170       for (f = TYPE_FIELDS (TREE_TYPE (x));
4171            f;
4172            f = TREE_CHAIN (f))
4173         pushdecl_class_level (f);
4174     }
4175 }
4176
4177 #if 0
4178 /* This function is used to push the mangled decls for nested types into
4179    the appropriate scope.  Previously pushdecl_top_level was used, but that
4180    is incorrect for members of local classes.  */
4181
4182 void
4183 pushdecl_nonclass_level (x)
4184      tree x;
4185 {
4186   struct binding_level *b = current_binding_level;
4187
4188   my_friendly_assert (b->parm_flag != 2, 180);
4189
4190 #if 0
4191   /* Get out of template binding levels */
4192   while (b->pseudo_global)
4193     b = b->level_chain;
4194 #endif
4195
4196   pushdecl_with_scope (x, b);
4197 }
4198 #endif
4199
4200 /* Make the declaration(s) of X appear in CLASS scope
4201    under the name NAME.  */
4202
4203 void
4204 push_class_level_binding (name, x)
4205      tree name;
4206      tree x;
4207 {
4208   tree binding;
4209   /* The class_binding_level will be NULL if x is a template
4210      parameter name in a member template.  */
4211   if (!class_binding_level)
4212     return;
4213
4214   /* Make sure that this new member does not have the same name
4215      as a template parameter.  */
4216   if (TYPE_BEING_DEFINED (current_class_type))
4217     check_template_shadow (x);
4218
4219   /* If this declaration shadows a declaration from an enclosing
4220      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4221      we leave this class.  Record the shadowed declaration here.  */
4222   binding = IDENTIFIER_BINDING (name);
4223   if (binding
4224       && ((TREE_CODE (x) == OVERLOAD
4225            && BINDING_VALUE (binding)
4226            && is_overloaded_fn (BINDING_VALUE (binding)))
4227           || INHERITED_VALUE_BINDING_P (binding)))
4228     {
4229       tree shadow;
4230       tree old_decl;
4231
4232       /* If the old binding was from a base class, and was for a tag
4233          name, slide it over to make room for the new binding.  The
4234          old binding is still visible if explicitly qualified with a
4235          class-key.  */
4236       if (INHERITED_VALUE_BINDING_P (binding)
4237           && BINDING_VALUE (binding)
4238           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4239           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4240           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4241         {
4242           old_decl = BINDING_TYPE (binding);
4243           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4244           BINDING_VALUE (binding) = NULL_TREE;
4245           INHERITED_VALUE_BINDING_P (binding) = 0;
4246         }
4247       else
4248         old_decl = BINDING_VALUE (binding);
4249
4250       /* There was already a binding for X containing fewer
4251          functions than are named in X.  Find the previous
4252          declaration of X on the class-shadowed list, and update it.  */
4253       for (shadow = class_binding_level->class_shadowed;
4254            shadow;
4255            shadow = TREE_CHAIN (shadow))
4256         if (TREE_PURPOSE (shadow) == name
4257             && TREE_TYPE (shadow) == old_decl)
4258           {
4259             BINDING_VALUE (binding) = x;
4260             INHERITED_VALUE_BINDING_P (binding) = 0;
4261             TREE_TYPE (shadow) = x;
4262             return;
4263           }
4264     }
4265
4266   /* If we didn't replace an existing binding, put the binding on the
4267      stack of bindings for the identifier, and update
4268      IDENTIFIER_CLASS_VALUE.  */
4269   if (push_class_binding (name, x))
4270     {
4271       maybe_push_cache_obstack ();
4272       class_binding_level->class_shadowed
4273         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4274                      class_binding_level->class_shadowed);
4275       pop_obstacks ();
4276       /* Record the value we are binding NAME to so that we can know
4277          what to pop later.  */
4278       TREE_TYPE (class_binding_level->class_shadowed) = x;
4279     }
4280 }
4281
4282 /* Insert another USING_DECL into the current binding level,
4283    returning this declaration. If this is a redeclaration,
4284    do nothing and return NULL_TREE.  */
4285
4286 tree
4287 push_using_decl (scope, name)
4288      tree scope;
4289      tree name;
4290 {
4291   tree decl;
4292
4293   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4294   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4295   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4296     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4297       break;
4298   if (decl)
4299     return NULL_TREE;
4300   decl = build_lang_decl (USING_DECL, name, void_type_node);
4301   DECL_INITIAL (decl) = scope;
4302   TREE_CHAIN (decl) = current_binding_level->usings;
4303   current_binding_level->usings = decl;
4304   return decl;
4305 }
4306
4307 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4308    changed (i.e. there was already a directive), or the fresh
4309    TREE_LIST otherwise.  */
4310
4311 tree
4312 push_using_directive (used)
4313      tree used;
4314 {
4315   tree ud = current_binding_level->using_directives;
4316   tree iter, ancestor;
4317
4318   /* Check if we already have this. */
4319   if (purpose_member (used, ud) != NULL_TREE)
4320     return NULL_TREE;
4321
4322   /* Recursively add all namespaces used. */
4323   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4324     push_using_directive (TREE_PURPOSE (iter));
4325
4326   ancestor = namespace_ancestor (current_decl_namespace (), used);
4327   ud = current_binding_level->using_directives;
4328   ud = perm_tree_cons (used, ancestor, ud);
4329   current_binding_level->using_directives = ud;
4330   return ud;
4331 }
4332
4333 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4334    other definitions already in place.  We get around this by making
4335    the value of the identifier point to a list of all the things that
4336    want to be referenced by that name.  It is then up to the users of
4337    that name to decide what to do with that list.
4338
4339    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4340    slot.  It is dealt with the same way.
4341
4342    FLAGS is a bitwise-or of the following values:
4343      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4344                  namespace scope.
4345      PUSH_USING: DECL is being pushed as the result of a using
4346                  declaration.
4347
4348    The value returned may be a previous declaration if we guessed wrong
4349    about what language DECL should belong to (C or C++).  Otherwise,
4350    it's always DECL (and never something that's not a _DECL).  */
4351
4352 tree
4353 push_overloaded_decl (decl, flags)
4354      tree decl;
4355      int flags;
4356 {
4357   tree name = DECL_NAME (decl);
4358   tree old;
4359   tree new_binding;
4360   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4361
4362   if (doing_global)
4363     {
4364       old = namespace_binding (name, DECL_CONTEXT (decl));
4365       if (old && TREE_CODE (old) == FUNCTION_DECL
4366           && DECL_ARTIFICIAL (old)
4367           && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
4368         {
4369           if (duplicate_decls (decl, old))
4370             return old;
4371           old = NULL_TREE;
4372         }
4373     }
4374   else
4375     old = lookup_name_current_level (name);
4376
4377   if (old)
4378     {
4379       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4380         {
4381           tree t = TREE_TYPE (old);
4382           if (IS_AGGR_TYPE (t) && warn_shadow
4383               && (! DECL_IN_SYSTEM_HEADER (decl)
4384                   || ! DECL_IN_SYSTEM_HEADER (old)))
4385             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4386           old = NULL_TREE;
4387         }
4388       else if (is_overloaded_fn (old))
4389         {
4390           tree tmp;
4391
4392           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4393             {
4394               tree fn = OVL_CURRENT (tmp);
4395
4396               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4397                   && !(flags & PUSH_USING)
4398                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4399                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4400                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4401                           decl, fn);
4402
4403               if (duplicate_decls (decl, fn))
4404                 return fn;
4405             }
4406         }
4407       else
4408         {
4409           cp_error_at ("previous non-function declaration `%#D'", old);
4410           cp_error ("conflicts with function declaration `%#D'", decl);
4411           return decl;
4412         }
4413     }
4414
4415   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4416     {
4417       if (old && TREE_CODE (old) != OVERLOAD)
4418         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4419       else
4420         new_binding = ovl_cons (decl, old);
4421       if (flags & PUSH_USING)
4422         OVL_USED (new_binding) = 1;
4423     }
4424   else
4425     /* NAME is not ambiguous.  */
4426     new_binding = decl;
4427
4428   if (doing_global)
4429     set_namespace_binding (name, current_namespace, new_binding);
4430   else
4431     {
4432       /* We only create an OVERLOAD if there was a previous binding at
4433          this level, or if decl is a template. In the former case, we
4434          need to remove the old binding and replace it with the new
4435          binding.  We must also run through the NAMES on the binding
4436          level where the name was bound to update the chain.  */
4437
4438       if (TREE_CODE (new_binding) == OVERLOAD && old)
4439         {
4440           tree *d;
4441
4442           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4443                *d;
4444                d = &TREE_CHAIN (*d))
4445             if (*d == old
4446                 || (TREE_CODE (*d) == TREE_LIST
4447                     && TREE_VALUE (*d) == old))
4448               {
4449                 if (TREE_CODE (*d) == TREE_LIST)
4450                   /* Just replace the old binding with the new.  */
4451                   TREE_VALUE (*d) = new_binding;
4452                 else
4453                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4454                   *d = build_tree_list (NULL_TREE, new_binding);
4455
4456                 /* And update the CPLUS_BINDING node.  */
4457                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4458                   = new_binding;
4459                 return decl;
4460               }
4461
4462           /* We should always find a previous binding in this case.  */
4463           my_friendly_abort (0);
4464         }
4465
4466       /* Install the new binding.  */
4467       push_local_binding (name, new_binding, flags);
4468     }
4469
4470   return decl;
4471 }
4472 \f
4473 /* Generate an implicit declaration for identifier FUNCTIONID
4474    as a function of type int ().  Print a warning if appropriate.  */
4475
4476 tree
4477 implicitly_declare (functionid)
4478      tree functionid;
4479 {
4480   register tree decl;
4481   int temp = allocation_temporary_p ();
4482
4483   push_obstacks_nochange ();
4484
4485   /* Save the decl permanently so we can warn if definition follows.
4486      In ANSI C, warn_implicit is usually false, so the saves little space.
4487      But in C++, it's usually true, hence the extra code.  */
4488   if (temp && (! warn_implicit || toplevel_bindings_p ()))
4489     end_temporary_allocation ();
4490
4491   /* We used to reuse an old implicit decl here,
4492      but this loses with inline functions because it can clobber
4493      the saved decl chains.  */
4494   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4495
4496   DECL_EXTERNAL (decl) = 1;
4497   TREE_PUBLIC (decl) = 1;
4498
4499   /* ANSI standard says implicit declarations are in the innermost block.
4500      So we record the decl in the standard fashion.  */
4501   pushdecl (decl);
4502   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4503
4504   if (warn_implicit
4505       /* Only one warning per identifier.  */
4506       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4507     {
4508       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4509     }
4510
4511   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4512
4513   pop_obstacks ();
4514
4515   return decl;
4516 }
4517
4518 /* Return zero if the declaration NEWDECL is valid
4519    when the declaration OLDDECL (assumed to be for the same name)
4520    has already been seen.
4521    Otherwise return an error message format string with a %s
4522    where the identifier should go.  */
4523
4524 static const char *
4525 redeclaration_error_message (newdecl, olddecl)
4526      tree newdecl, olddecl;
4527 {
4528   if (TREE_CODE (newdecl) == TYPE_DECL)
4529     {
4530       /* Because C++ can put things into name space for free,
4531          constructs like "typedef struct foo { ... } foo"
4532          would look like an erroneous redeclaration.  */
4533       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4534         return 0;
4535       else
4536         return "redefinition of `%#D'";
4537     }
4538   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4539     {
4540       /* If this is a pure function, its olddecl will actually be
4541          the original initialization to `0' (which we force to call
4542          abort()).  Don't complain about redefinition in this case.  */
4543       if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
4544         return 0;
4545
4546       /* If both functions come from different namespaces, this is not
4547          a redeclaration - this is a conflict with a used function. */
4548       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4549           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4550         return "`%D' conflicts with used function";
4551
4552       /* We'll complain about linkage mismatches in
4553          warn_extern_redeclared_static.  */
4554
4555       /* Defining the same name twice is no good.  */
4556       if (DECL_INITIAL (olddecl) != NULL_TREE
4557           && DECL_INITIAL (newdecl) != NULL_TREE)
4558         {
4559           if (DECL_NAME (olddecl) == NULL_TREE)
4560             return "`%#D' not declared in class";
4561           else
4562             return "redefinition of `%#D'";
4563         }
4564       return 0;
4565     }
4566   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4567     {
4568       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4569            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4570            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4571           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4572               && TYPE_SIZE (TREE_TYPE (newdecl))
4573               && TYPE_SIZE (TREE_TYPE (olddecl))))
4574         return "redefinition of `%#D'";
4575       return 0;
4576     }
4577   else if (toplevel_bindings_p ())
4578     {
4579       /* Objects declared at top level:  */
4580       /* If at least one is a reference, it's ok.  */
4581       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4582         return 0;
4583       /* Reject two definitions.  */
4584       return "redefinition of `%#D'";
4585     }
4586   else
4587     {
4588       /* Objects declared with block scope:  */
4589       /* Reject two definitions, and reject a definition
4590          together with an external reference.  */
4591       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4592         return "redeclaration of `%#D'";
4593       return 0;
4594     }
4595 }
4596 \f
4597 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4598    Create one if none exists so far for the current function.
4599    This function is called for both label definitions and label references.  */
4600
4601 tree
4602 lookup_label (id)
4603      tree id;
4604 {
4605   register tree decl = IDENTIFIER_LABEL_VALUE (id);
4606
4607   if (current_function_decl == NULL_TREE)
4608     {
4609       error ("label `%s' referenced outside of any function",
4610              IDENTIFIER_POINTER (id));
4611       return NULL_TREE;
4612     }
4613
4614   if ((decl == NULL_TREE
4615       || DECL_SOURCE_LINE (decl) == 0)
4616       && (named_label_uses == NULL
4617           || named_label_uses->names_in_scope != current_binding_level->names
4618           || named_label_uses->label_decl != decl))
4619     {
4620       struct named_label_list *new_ent;
4621       new_ent
4622         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4623       new_ent->label_decl = decl;
4624       new_ent->names_in_scope = current_binding_level->names;
4625       new_ent->binding_level = current_binding_level;
4626       new_ent->lineno_o_goto = lineno;
4627       new_ent->filename_o_goto = input_filename;
4628       new_ent->next = named_label_uses;
4629       named_label_uses = new_ent;
4630     }
4631
4632   /* Use a label already defined or ref'd with this name.  */
4633   if (decl != NULL_TREE)
4634     {
4635       /* But not if it is inherited and wasn't declared to be inheritable.  */
4636       if (DECL_CONTEXT (decl) != current_function_decl
4637           && ! C_DECLARED_LABEL_FLAG (decl))
4638         return shadow_label (id);
4639       return decl;
4640     }
4641
4642   decl = build_decl (LABEL_DECL, id, void_type_node);
4643
4644   /* Make sure every label has an rtx.  */
4645   label_rtx (decl);
4646
4647   /* A label not explicitly declared must be local to where it's ref'd.  */
4648   DECL_CONTEXT (decl) = current_function_decl;
4649
4650   DECL_MODE (decl) = VOIDmode;
4651
4652   /* Say where one reference is to the label,
4653      for the sake of the error if it is not defined.  */
4654   DECL_SOURCE_LINE (decl) = lineno;
4655   DECL_SOURCE_FILE (decl) = input_filename;
4656
4657   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4658
4659   named_labels = tree_cons (NULL_TREE, decl, named_labels);
4660   named_label_uses->label_decl = decl;
4661
4662   return decl;
4663 }
4664
4665 /* Make a label named NAME in the current function,
4666    shadowing silently any that may be inherited from containing functions
4667    or containing scopes.
4668
4669    Note that valid use, if the label being shadowed
4670    comes from another scope in the same function,
4671    requires calling declare_nonlocal_label right away.  */
4672
4673 tree
4674 shadow_label (name)
4675      tree name;
4676 {
4677   register tree decl = IDENTIFIER_LABEL_VALUE (name);
4678
4679   if (decl != NULL_TREE)
4680     {
4681       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4682       SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4683     }
4684
4685   return lookup_label (name);
4686 }
4687
4688 /* Define a label, specifying the location in the source file.
4689    Return the LABEL_DECL node for the label, if the definition is valid.
4690    Otherwise return 0.  */
4691
4692 tree
4693 define_label (filename, line, name)
4694      char *filename;
4695      int line;
4696      tree name;
4697 {
4698   tree decl;
4699
4700   if (minimal_parse_mode)
4701     {
4702       push_obstacks (&permanent_obstack, &permanent_obstack);
4703       decl = build_decl (LABEL_DECL, name, void_type_node);
4704       pop_obstacks ();
4705       DECL_SOURCE_LINE (decl) = line;
4706       DECL_SOURCE_FILE (decl) = filename;
4707       add_tree (decl);
4708       return decl;
4709     }
4710
4711   decl = lookup_label (name);
4712
4713   /* After labels, make any new cleanups go into their
4714      own new (temporary) binding contour.  */
4715   current_binding_level->more_cleanups_ok = 0;
4716
4717   /* If label with this name is known from an outer context, shadow it.  */
4718   if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
4719     {
4720       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4721       SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4722       decl = lookup_label (name);
4723     }
4724
4725   if (name == get_identifier ("wchar_t"))
4726     cp_pedwarn ("label named wchar_t");
4727
4728   if (DECL_INITIAL (decl) != NULL_TREE)
4729     {
4730       cp_error ("duplicate label `%D'", decl);
4731       return 0;
4732     }
4733   else
4734     {
4735       struct named_label_list *uses, *prev;
4736       int identified = 0;
4737
4738       /* Mark label as having been defined.  */
4739       DECL_INITIAL (decl) = error_mark_node;
4740       /* Say where in the source.  */
4741       DECL_SOURCE_FILE (decl) = filename;
4742       DECL_SOURCE_LINE (decl) = line;
4743
4744       prev = NULL;
4745       uses = named_label_uses;
4746       while (uses != NULL)
4747         if (uses->label_decl == decl)
4748           {
4749             struct binding_level *b = current_binding_level;
4750             while (b)
4751               {
4752                 tree new_decls = b->names;
4753                 tree old_decls = (b == uses->binding_level)
4754                                   ? uses->names_in_scope : NULL_TREE;
4755                 while (new_decls != old_decls)
4756                   {
4757                     if (TREE_CODE (new_decls) == VAR_DECL
4758                         /* Don't complain about crossing initialization
4759                            of internal entities.  They can't be accessed,
4760                            and they should be cleaned up
4761                            by the time we get to the label.  */
4762                         && ! DECL_ARTIFICIAL (new_decls)
4763                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4764                              && pod_type_p (TREE_TYPE (new_decls))))
4765                       {
4766                         if (! identified)
4767                           {
4768                             cp_error ("jump to label `%D'", decl);
4769                             error_with_file_and_line (uses->filename_o_goto,
4770                                                       uses->lineno_o_goto,
4771                                                       "  from here");
4772                             identified = 1;
4773                         }
4774                         if (DECL_INITIAL (new_decls)
4775                             || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls)))
4776                           cp_error_at ("  crosses initialization of `%#D'",
4777                                        new_decls);
4778                         else
4779                           cp_error_at ("  enters scope of non-POD `%#D'",
4780                                          new_decls);
4781                       }
4782                     new_decls = TREE_CHAIN (new_decls);
4783                   }
4784                 if (b == uses->binding_level)
4785                   break;
4786                 b = b->level_chain;
4787               }
4788
4789             if (prev != NULL)
4790               prev->next = uses->next;
4791             else
4792               named_label_uses = uses->next;
4793
4794             uses = uses->next;
4795           }
4796         else
4797           {
4798             prev = uses;
4799             uses = uses->next;
4800           }
4801       current_function_return_value = NULL_TREE;
4802       return decl;
4803     }
4804 }
4805
4806 struct cp_switch
4807 {
4808   struct binding_level *level;
4809   struct cp_switch *next;
4810 };
4811
4812 static struct cp_switch *switch_stack;
4813
4814 void
4815 push_switch ()
4816 {
4817   struct cp_switch *p
4818     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4819   p->level = current_binding_level;
4820   p->next = switch_stack;
4821   switch_stack = p;
4822 }
4823
4824 void
4825 pop_switch ()
4826 {
4827   switch_stack = switch_stack->next;
4828 }
4829
4830 /* Same, but for CASE labels.  If DECL is NULL_TREE, it's the default.  */
4831 /* XXX Note decl is never actually used. (bpk) */
4832
4833 void
4834 define_case_label ()
4835 {
4836   tree cleanup = last_cleanup_this_contour ();
4837   struct binding_level *b = current_binding_level;
4838   int identified = 0;
4839
4840   if (cleanup)
4841     {
4842       static int explained = 0;
4843       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4844       warning ("where case label appears here");
4845       if (!explained)
4846         {
4847           warning ("(enclose actions of previous case statements requiring");
4848           warning ("destructors in their own binding contours.)");
4849           explained = 1;
4850         }
4851     }
4852
4853   for (; b && b != switch_stack->level; b = b->level_chain)
4854     {
4855       tree new_decls = b->names;
4856       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4857         {
4858           if (TREE_CODE (new_decls) == VAR_DECL
4859               /* Don't complain about crossing initialization
4860                  of internal entities.  They can't be accessed,
4861                  and they should be cleaned up
4862                  by the time we get to the label.  */
4863               && ! DECL_ARTIFICIAL (new_decls)
4864               && ((DECL_INITIAL (new_decls) != NULL_TREE
4865                    && DECL_INITIAL (new_decls) != error_mark_node)
4866                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4867             {
4868               if (! identified)
4869                 error ("jump to case label");
4870               identified = 1;
4871               cp_error_at ("  crosses initialization of `%#D'",
4872                            new_decls);
4873             }
4874         }
4875     }
4876
4877   /* After labels, make any new cleanups go into their
4878      own new (temporary) binding contour.  */
4879
4880   current_binding_level->more_cleanups_ok = 0;
4881   current_function_return_value = NULL_TREE;
4882 }
4883 \f
4884 /* Return the list of declarations of the current level.
4885    Note that this list is in reverse order unless/until
4886    you nreverse it; and when you do nreverse it, you must
4887    store the result back using `storedecls' or you will lose.  */
4888
4889 tree
4890 getdecls ()
4891 {
4892   return current_binding_level->names;
4893 }
4894
4895 /* Return the list of type-tags (for structs, etc) of the current level.  */
4896
4897 tree
4898 gettags ()
4899 {
4900   return current_binding_level->tags;
4901 }
4902
4903 /* Store the list of declarations of the current level.
4904    This is done for the parameter declarations of a function being defined,
4905    after they are modified in the light of any missing parameters.  */
4906
4907 static void
4908 storedecls (decls)
4909      tree decls;
4910 {
4911   current_binding_level->names = decls;
4912 }
4913
4914 /* Similarly, store the list of tags of the current level.  */
4915
4916 static void
4917 storetags (tags)
4918      tree tags;
4919 {
4920   current_binding_level->tags = tags;
4921 }
4922 \f
4923 /* Given NAME, an IDENTIFIER_NODE,
4924    return the structure (or union or enum) definition for that name.
4925    Searches binding levels from BINDING_LEVEL up to the global level.
4926    If THISLEVEL_ONLY is nonzero, searches only the specified context
4927    (but skips any tag-transparent contexts to find one that is
4928    meaningful for tags).
4929    FORM says which kind of type the caller wants;
4930    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4931    If the wrong kind of type is found, and it's not a template, an error is
4932    reported.  */
4933
4934 static tree
4935 lookup_tag (form, name, binding_level, thislevel_only)
4936      enum tree_code form;
4937      tree name;
4938      struct binding_level *binding_level;
4939      int thislevel_only;
4940 {
4941   register struct binding_level *level;
4942   /* Non-zero if, we should look past a pseudo-global level, even if
4943      THISLEVEL_ONLY.  */
4944   int allow_pseudo_global = 1;
4945
4946   for (level = binding_level; level; level = level->level_chain)
4947     {
4948       register tree tail;
4949       if (ANON_AGGRNAME_P (name))
4950         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4951           {
4952             /* There's no need for error checking here, because
4953                anon names are unique throughout the compilation.  */
4954             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4955               return TREE_VALUE (tail);
4956           }
4957       else if (level->namespace_p)
4958         /* Do namespace lookup. */
4959         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4960           {
4961             tree old = binding_for_name (name, tail);
4962
4963             /* If we just skipped past a pseudo global level, even
4964                though THISLEVEL_ONLY, and we find a template class
4965                declaration, then we use the _TYPE node for the
4966                template.  See the example below.  */
4967             if (thislevel_only && !allow_pseudo_global
4968                 && old && BINDING_VALUE (old)
4969                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4970               old = TREE_TYPE (BINDING_VALUE (old));
4971             else
4972               old = BINDING_TYPE (old);
4973
4974             /* If it has an original type, it is a typedef, and we
4975                should not return it.  */
4976             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4977               old = NULL_TREE;
4978             if (old && TREE_CODE (old) != form
4979                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
4980               {
4981                 cp_error ("`%#D' redeclared as %C", old, form);
4982                 return NULL_TREE;
4983               }
4984             if (old)
4985               return old;
4986             if (thislevel_only || tail == global_namespace)
4987               return NULL_TREE;
4988           }
4989       else
4990         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4991           {
4992             if (TREE_PURPOSE (tail) == name)
4993               {
4994                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
4995                 /* Should tighten this up; it'll probably permit
4996                    UNION_TYPE and a struct template, for example.  */
4997                 if (code != form
4998                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
4999                   {
5000                     /* Definition isn't the kind we were looking for.  */
5001                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5002                               form);
5003                     return NULL_TREE;
5004                   }
5005                 return TREE_VALUE (tail);
5006               }
5007           }
5008       if (thislevel_only && ! level->tag_transparent)
5009         {
5010           if (level->pseudo_global && allow_pseudo_global)
5011             {
5012               /* We must deal with cases like this:
5013
5014                    template <class T> struct S;
5015                    template <class T> struct S {};
5016
5017                  When looking up `S', for the second declaration, we
5018                  would like to find the first declaration.  But, we
5019                  are in the pseudo-global level created for the
5020                  template parameters, rather than the (surrounding)
5021                  namespace level.  Thus, we keep going one more level,
5022                  even though THISLEVEL_ONLY is non-zero.  */
5023               allow_pseudo_global = 0;
5024               continue;
5025             }
5026           else
5027             return NULL_TREE;
5028         }
5029       if (current_class_type && level->level_chain->namespace_p)
5030         {
5031           /* Try looking in this class's tags before heading into
5032              global binding level.  */
5033           tree context = current_class_type;
5034           while (context)
5035             {
5036               switch (TREE_CODE_CLASS (TREE_CODE (context)))
5037                 {
5038                 tree these_tags;
5039                 case 't':
5040                     these_tags = CLASSTYPE_TAGS (context);
5041                     if (ANON_AGGRNAME_P (name))
5042                       while (these_tags)
5043                         {
5044                           if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
5045                               == name)
5046                             return TREE_VALUE (tail);
5047                           these_tags = TREE_CHAIN (these_tags);
5048                         }
5049                     else
5050                       while (these_tags)
5051                         {
5052                           if (TREE_PURPOSE (these_tags) == name)
5053                             {
5054                               if (TREE_CODE (TREE_VALUE (these_tags)) != form)
5055                                 {
5056                                   cp_error ("`%#D' redeclared as %C in class scope",
5057                                             TREE_VALUE (tail), form);
5058                                   return NULL_TREE;
5059                                 }
5060                               return TREE_VALUE (tail);
5061                             }
5062                           these_tags = TREE_CHAIN (these_tags);
5063                         }
5064                     /* If this type is not yet complete, then don't
5065                        look at its context.  */
5066                     if (TYPE_SIZE (context) == NULL_TREE)
5067                       goto no_context;
5068                     /* Go to next enclosing type, if any.  */
5069                     context = DECL_CONTEXT (TYPE_MAIN_DECL (context));
5070                     break;
5071                 case 'd':
5072                     context = DECL_CONTEXT (context);
5073                     break;
5074                 default:
5075                     my_friendly_abort (10);
5076                 }
5077               continue;
5078               no_context:
5079               break;
5080             }
5081         }
5082     }
5083   return NULL_TREE;
5084 }
5085
5086 #if 0
5087 void
5088 set_current_level_tags_transparency (tags_transparent)
5089      int tags_transparent;
5090 {
5091   current_binding_level->tag_transparent = tags_transparent;
5092 }
5093 #endif
5094
5095 /* Given a type, find the tag that was defined for it and return the tag name.
5096    Otherwise return 0.  However, the value can never be 0
5097    in the cases in which this is used.
5098
5099    C++: If NAME is non-zero, this is the new name to install.  This is
5100    done when replacing anonymous tags with real tag names.  */
5101
5102 static tree
5103 lookup_tag_reverse (type, name)
5104      tree type;
5105      tree name;
5106 {
5107   register struct binding_level *level;
5108
5109   for (level = current_binding_level; level; level = level->level_chain)
5110     {
5111       register tree tail;
5112       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5113         {
5114           if (TREE_VALUE (tail) == type)
5115             {
5116               if (name)
5117                 TREE_PURPOSE (tail) = name;
5118               return TREE_PURPOSE (tail);
5119             }
5120         }
5121     }
5122   return NULL_TREE;
5123 }
5124 \f
5125 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
5126    Return the type value, or NULL_TREE if not found.  */
5127
5128 static tree
5129 lookup_nested_type (type, context)
5130      tree type;
5131      tree context;
5132 {
5133   if (context == NULL_TREE)
5134     return NULL_TREE;
5135   while (context)
5136     {
5137       switch (TREE_CODE (context))
5138         {
5139         case TYPE_DECL:
5140           {
5141             tree ctype = TREE_TYPE (context);
5142             tree match = value_member (type, CLASSTYPE_TAGS (ctype));
5143             if (match)
5144               return TREE_VALUE (match);
5145             context = DECL_CONTEXT (context);
5146
5147             /* When we have a nested class whose member functions have
5148                local types (e.g., a set of enums), we'll arrive here
5149                with the DECL_CONTEXT as the actual RECORD_TYPE node for
5150                the enclosing class.  Instead, we want to make sure we
5151                come back in here with the TYPE_DECL, not the RECORD_TYPE.  */
5152             if (context && TREE_CODE (context) == RECORD_TYPE)
5153               context = TREE_CHAIN (context);
5154           }
5155           break;
5156         case FUNCTION_DECL:
5157           if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
5158             return lookup_name (TYPE_IDENTIFIER (type), 1);
5159           return NULL_TREE;
5160         default:
5161           my_friendly_abort (12);
5162         }
5163     }
5164   return NULL_TREE;
5165 }
5166
5167 /* Look up NAME in the NAMESPACE.  */
5168
5169 tree
5170 lookup_namespace_name (namespace, name)
5171      tree namespace, name;
5172 {
5173   struct tree_binding _b;
5174   tree val;
5175
5176   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5177
5178   if (TREE_CODE (name) == NAMESPACE_DECL)
5179     /* This happens for A::B<int> when B is a namespace. */
5180     return name;
5181   else if (TREE_CODE (name) == TEMPLATE_DECL)
5182     {
5183       /* This happens for A::B where B is a template, and there are no
5184          template arguments.  */
5185       cp_error ("invalid use of `%D'", name);
5186       return error_mark_node;
5187     }
5188
5189   namespace = ORIGINAL_NAMESPACE (namespace);
5190
5191   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5192
5193   val = binding_init (&_b);
5194   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5195     return error_mark_node;
5196
5197   if (BINDING_VALUE (val))
5198     {
5199       val = BINDING_VALUE (val);
5200
5201       /* If we have a single function from a using decl, pull it out.  */
5202       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5203         val = OVL_FUNCTION (val);
5204       return val;
5205     }
5206
5207   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5208   return error_mark_node;
5209 }
5210
5211 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5212
5213 static unsigned long
5214 typename_hash (k)
5215      hash_table_key k;
5216 {
5217   unsigned long hash;
5218   tree t;
5219
5220   t = (tree) k;
5221   hash = (((unsigned long) TYPE_CONTEXT (t))
5222           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5223
5224   return hash;
5225 }
5226
5227 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5228
5229 static boolean
5230 typename_compare (k1, k2)
5231      hash_table_key k1;
5232      hash_table_key k2;
5233 {
5234   tree t1;
5235   tree t2;
5236   tree d1;
5237   tree d2;
5238
5239   t1 = (tree) k1;
5240   t2 = (tree) k2;
5241   d1 = TYPE_NAME (t1);
5242   d2 = TYPE_NAME (t2);
5243
5244   return (DECL_NAME (d1) == DECL_NAME (d2)
5245           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5246           && ((TREE_TYPE (t1) != NULL_TREE)
5247               == (TREE_TYPE (t2) != NULL_TREE))
5248           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5249           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5250 }
5251
5252 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5253    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5254    is non-NULL, this type is being created by the implicit typename
5255    extension, and BASE_TYPE is a type named `t' in some base class of
5256    `T' which depends on template parameters.
5257
5258    Returns the new TYPENAME_TYPE.  */
5259
5260 tree
5261 build_typename_type (context, name, fullname, base_type)
5262      tree context;
5263      tree name;
5264      tree fullname;
5265      tree base_type;
5266 {
5267   tree t;
5268   tree d;
5269   struct hash_entry* e;
5270
5271   static struct hash_table ht;
5272
5273   push_obstacks (&permanent_obstack, &permanent_obstack);
5274
5275   if (!ht.table
5276       && !hash_table_init (&ht, &hash_newfunc, &typename_hash,
5277                            &typename_compare))
5278     fatal ("virtual memory exhausted");
5279
5280   /* Build the TYPENAME_TYPE.  */
5281   t = make_lang_type (TYPENAME_TYPE);
5282   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5283   TYPENAME_TYPE_FULLNAME (t) = fullname;
5284   TREE_TYPE (t) = base_type;
5285
5286   /* Build the corresponding TYPE_DECL.  */
5287   d = build_decl (TYPE_DECL, name, t);
5288   TYPE_NAME (TREE_TYPE (d)) = d;
5289   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5290   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5291   DECL_ARTIFICIAL (d) = 1;
5292
5293   /* See if we already have this type.  */
5294   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5295   if (e)
5296     {
5297       /* This will free not only TREE_TYPE, but the lang-specific data
5298          and the TYPE_DECL as well.  */
5299       obstack_free (&permanent_obstack, t);
5300       t = (tree) e->key;
5301     }
5302   else
5303     /* Insert the type into the table.  */
5304     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5305
5306   pop_obstacks ();
5307
5308   return t;
5309 }
5310
5311 tree
5312 make_typename_type (context, name)
5313      tree context, name;
5314 {
5315   tree t;
5316   tree fullname;
5317
5318   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5319     name = TYPE_IDENTIFIER (name);
5320   else if (TREE_CODE (name) == TYPE_DECL)
5321     name = DECL_NAME (name);
5322
5323   fullname = name;
5324
5325   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5326     {
5327       name = TREE_OPERAND (name, 0);
5328       if (TREE_CODE (name) == TEMPLATE_DECL)
5329         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5330     }
5331   if (TREE_CODE (name) != IDENTIFIER_NODE)
5332     my_friendly_abort (2000);
5333
5334   if (TREE_CODE (context) == NAMESPACE_DECL)
5335     {
5336       /* We can get here from typename_sub0 in the explicit_template_type
5337          expansion.  Just fail.  */
5338       cp_error ("no class template named `%#T' in `%#T'",
5339                 name, context);
5340       return error_mark_node;
5341     }
5342
5343   if (! uses_template_parms (context)
5344       || currently_open_class (context))
5345     {
5346       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5347         {
5348           if (IS_AGGR_TYPE (context))
5349             t = lookup_field (context, name, 0, 0);
5350           else
5351             {
5352               cp_error ("no class template named `%#T' in `%#T'",
5353                         name, context);
5354               return error_mark_node;
5355             }
5356
5357           if (t && DECL_CLASS_TEMPLATE_P (t))
5358             return lookup_template_class (t, TREE_OPERAND (fullname, 1),
5359                                           NULL_TREE, context,
5360                                           /*entering_scope=*/0);
5361         }
5362       else
5363         {
5364           if (IS_AGGR_TYPE (context))
5365             t = lookup_field (context, name, 0, 1);
5366           else
5367             {
5368               cp_error ("no type named `%#T' in `%#T'", name, context);
5369               return error_mark_node;
5370             }
5371
5372           if (t)
5373             return TREE_TYPE (t);
5374         }
5375     }
5376
5377   /* If the CONTEXT is not a template type, then either the field is
5378      there now or its never going to be.  */
5379   if (!uses_template_parms (context) && !t)
5380     {
5381       cp_error ("no type named `%#T' in `%#T'", name, context);
5382       return error_mark_node;
5383     }
5384
5385
5386   return build_typename_type (context, name, fullname,  NULL_TREE);
5387 }
5388
5389 /* Select the right _DECL from multiple choices. */
5390
5391 static tree
5392 select_decl (binding, flags)
5393      tree binding;
5394      int flags;
5395 {
5396   tree val;
5397   val = BINDING_VALUE (binding);
5398   if (LOOKUP_NAMESPACES_ONLY (flags))
5399     {
5400       /* We are not interested in types. */
5401       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5402         return val;
5403       return NULL_TREE;
5404     }
5405
5406   /* If we could have a type and
5407      we have nothing or we need a type and have none.  */
5408   if (BINDING_TYPE (binding)
5409       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5410                    && TREE_CODE (val) != TYPE_DECL)))
5411     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5412   /* Don't return non-types if we really prefer types. */
5413   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5414            && (TREE_CODE (val) != TEMPLATE_DECL
5415                || !DECL_CLASS_TEMPLATE_P (val)))
5416     val = NULL_TREE;
5417
5418   return val;
5419 }
5420
5421 /* Unscoped lookup of a global, iterate over namespaces, considering
5422    using namespace statements. */
5423
5424 static tree
5425 unqualified_namespace_lookup (name, flags)
5426      tree name;
5427      int flags;
5428 {
5429   struct tree_binding _binding;
5430   tree b = binding_init (&_binding);
5431   tree initial = current_decl_namespace();
5432   tree scope = initial;
5433   tree siter;
5434   struct binding_level *level;
5435   tree val = NULL_TREE;
5436
5437   while (!val)
5438     {
5439       val = binding_for_name (name, scope);
5440
5441       /* Initialize binding for this context. */
5442       BINDING_VALUE (b) = BINDING_VALUE (val);
5443       BINDING_TYPE (b) = BINDING_TYPE (val);
5444
5445       /* Add all _DECLs seen through local using-directives. */
5446       for (level = current_binding_level;
5447            !level->namespace_p;
5448            level = level->level_chain)
5449         if (!lookup_using_namespace (name, b, level->using_directives,
5450                                      scope, flags))
5451           /* Give up because of error. */
5452           return error_mark_node;
5453
5454       /* Add all _DECLs seen through global using-directives. */
5455       /* XXX local and global using lists should work equally. */
5456       siter = initial;
5457       while (1)
5458         {
5459           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5460                                        scope, flags))
5461             /* Give up because of error. */
5462             return error_mark_node;
5463           if (siter == scope) break;
5464           siter = CP_DECL_CONTEXT (siter);
5465         }
5466
5467       val = select_decl (b, flags);
5468       if (scope == global_namespace)
5469         break;
5470       scope = CP_DECL_CONTEXT (scope);
5471     }
5472   return val;
5473 }
5474
5475 /* Combine prefer_type and namespaces_only into flags.  */
5476
5477 static int
5478 lookup_flags (prefer_type, namespaces_only)
5479   int prefer_type, namespaces_only;
5480 {
5481   if (namespaces_only)
5482     return LOOKUP_PREFER_NAMESPACES;
5483   if (prefer_type > 1)
5484     return LOOKUP_PREFER_TYPES;
5485   if (prefer_type > 0)
5486     return LOOKUP_PREFER_BOTH;
5487   return 0;
5488 }
5489
5490 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5491    ignore it or not.  Subroutine of lookup_name_real.  */
5492
5493 static tree
5494 qualify_lookup (val, flags)
5495      tree val;
5496      int flags;
5497 {
5498   if (val == NULL_TREE)
5499     return val;
5500   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5501     return val;
5502   if ((flags & LOOKUP_PREFER_TYPES)
5503       && (TREE_CODE (val) == TYPE_DECL
5504           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5505               && DECL_CLASS_TEMPLATE_P (val))))
5506     return val;
5507   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5508     return NULL_TREE;
5509   return val;
5510 }
5511
5512 /* Look up NAME in the current binding level and its superiors in the
5513    namespace of variables, functions and typedefs.  Return a ..._DECL
5514    node of some kind representing its definition if there is only one
5515    such declaration, or return a TREE_LIST with all the overloaded
5516    definitions if there are many, or return 0 if it is undefined.
5517
5518    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5519    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5520    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5521    Otherwise we prefer non-TYPE_DECLs.
5522
5523    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5524    using IDENTIFIER_CLASS_VALUE.  */
5525
5526 static tree
5527 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5528      tree name;
5529      int prefer_type, nonclass, namespaces_only;
5530 {
5531   register tree val;
5532   int yylex = 0;
5533   tree from_obj = NULL_TREE;
5534   int flags;
5535
5536   /* Hack: copy flag set by parser, if set. */
5537   if (only_namespace_names)
5538     namespaces_only = 1;
5539
5540   if (prefer_type == -2)
5541     {
5542       extern int looking_for_typename;
5543       tree type = NULL_TREE;
5544
5545       yylex = 1;
5546       prefer_type = looking_for_typename;
5547
5548       flags = lookup_flags (prefer_type, namespaces_only);
5549       /* If the next thing is '<', class templates are types. */
5550       if (looking_for_template)
5551         flags |= LOOKUP_TEMPLATES_EXPECTED;
5552
5553       /* std:: becomes :: for now.  */
5554       if (got_scope == std_node)
5555         got_scope = void_type_node;
5556
5557       if (got_scope)
5558         type = got_scope;
5559       else if (got_object != error_mark_node)
5560         type = got_object;
5561
5562       if (type)
5563         {
5564           if (type == error_mark_node)
5565             return error_mark_node;
5566           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5567             type = TREE_TYPE (type);
5568
5569           if (TYPE_P (type))
5570             type = complete_type (type);
5571
5572           if (TREE_CODE (type) == VOID_TYPE)
5573             type = global_namespace;
5574           if (TREE_CODE (type) == NAMESPACE_DECL)
5575             {
5576               struct tree_binding b;
5577               val = binding_init (&b);
5578               if (!qualified_lookup_using_namespace (name, type, val, flags))
5579                 return NULL_TREE;
5580               val = select_decl (val, flags);
5581             }
5582           else if (! IS_AGGR_TYPE (type)
5583                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5584                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5585                    || TREE_CODE (type) == TYPENAME_TYPE)
5586             /* Someone else will give an error about this if needed.  */
5587             val = NULL_TREE;
5588           else if (type == current_class_type)
5589             val = IDENTIFIER_CLASS_VALUE (name);
5590           else
5591             val = lookup_member (type, name, 0, prefer_type);
5592         }
5593       else
5594         val = NULL_TREE;
5595
5596       if (got_scope)
5597         goto done;
5598       else if (got_object && val)
5599         from_obj = val;
5600     }
5601   else
5602     {
5603       flags = lookup_flags (prefer_type, namespaces_only);
5604       /* If we're not parsing, we need to complain. */
5605       flags |= LOOKUP_COMPLAIN;
5606     }
5607
5608   /* First, look in non-namespace scopes.  */
5609   for (val = IDENTIFIER_BINDING (name); val; val = TREE_CHAIN (val))
5610     {
5611       if (!LOCAL_BINDING_P (val) && nonclass)
5612         /* We're not looking for class-scoped bindings, so keep going.  */
5613         continue;
5614
5615       /* If this is the kind of thing we're looking for, we're done.  */
5616       if (qualify_lookup (BINDING_VALUE (val), flags))
5617         {
5618           val = BINDING_VALUE (val);
5619           break;
5620         }
5621       else if ((flags & LOOKUP_PREFER_TYPES)
5622                && qualify_lookup (BINDING_TYPE (val), flags))
5623         {
5624           val = BINDING_TYPE (val);
5625           break;
5626         }
5627     }
5628
5629   /* The name might be from an enclosing class of the current scope.  */
5630   if (!val && !nonclass && current_class_type)
5631     val = qualify_lookup (lookup_nested_field (name, !yylex), flags);
5632
5633   /* If we found a type from a dependent base class (using the
5634      implicit typename extension) make sure that there's not some
5635      global name which should be chosen instead.  */
5636   if (val && TREE_CODE (val) == TYPE_DECL
5637       && IMPLICIT_TYPENAME_P (TREE_TYPE (val)))
5638     {
5639       tree global_val;
5640
5641       /* Any other name takes precedence over an implicit typename.  Warn the
5642          user about this potentially confusing lookup.  */
5643       global_val = unqualified_namespace_lookup (name, flags);
5644
5645       if (global_val)
5646         {
5647           tree subtype;
5648
5649           /* Only warn when not lexing; we don't want to warn if they
5650              use this name as a declarator.  */
5651           subtype = TREE_TYPE (TREE_TYPE (val));
5652           if (! yylex
5653               && ! (TREE_CODE (global_val) == TEMPLATE_DECL
5654                     && CLASSTYPE_TEMPLATE_INFO (subtype)
5655                     && CLASSTYPE_TI_TEMPLATE (subtype) == global_val)
5656               && ! (TREE_CODE (global_val) == TYPE_DECL
5657                     && same_type_p (TREE_TYPE (global_val), subtype)))
5658             {
5659               cp_warning ("lookup of `%D' finds `%#D'", name, global_val);
5660               cp_warning ("  instead of `%D' from dependent base class",
5661                           val);
5662               cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5663                           constructor_name (current_class_type), name);
5664             }
5665
5666           /* Use the global value instead of the implicit typename.  */
5667           val = global_val;
5668         }
5669     }
5670   else if (!val)
5671     /* No local, or class-scoped binding.  Look for a namespace-scope
5672        declaration.  */
5673     val = unqualified_namespace_lookup (name, flags);
5674
5675  done:
5676   if (val)
5677     {
5678       /* This should only warn about types used in qualified-ids.  */
5679       if (from_obj && from_obj != val)
5680         {
5681           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5682               && TREE_CODE (val) == TYPE_DECL
5683               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5684             {
5685               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5686                           name, got_object, TREE_TYPE (from_obj));
5687               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5688                           TREE_TYPE (val));
5689             }
5690
5691           /* We don't change val to from_obj if got_object depends on
5692              template parms because that breaks implicit typename for
5693              destructor calls.  */
5694           if (! uses_template_parms (got_object))
5695             val = from_obj;
5696         }
5697
5698       /* If we have a single function from a using decl, pull it out.  */
5699       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5700         val = OVL_FUNCTION (val);
5701     }
5702   else if (from_obj)
5703     val = from_obj;
5704
5705   return val;
5706 }
5707
5708 tree
5709 lookup_name_nonclass (name)
5710      tree name;
5711 {
5712   return lookup_name_real (name, 0, 1, 0);
5713 }
5714
5715 tree
5716 lookup_function_nonclass (name, args)
5717      tree name;
5718      tree args;
5719 {
5720   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5721 }
5722
5723 tree
5724 lookup_name_namespace_only (name)
5725      tree name;
5726 {
5727   /* type-or-namespace, nonclass, namespace_only */
5728   return lookup_name_real (name, 1, 1, 1);
5729 }
5730
5731 tree
5732 lookup_name (name, prefer_type)
5733      tree name;
5734      int prefer_type;
5735 {
5736   return lookup_name_real (name, prefer_type, 0, 0);
5737 }
5738
5739 /* Similar to `lookup_name' but look only in the innermost non-class
5740    binding level.  */
5741
5742 tree
5743 lookup_name_current_level (name)
5744      tree name;
5745 {
5746   struct binding_level *b;
5747   tree t = NULL_TREE;
5748
5749   b = current_binding_level;
5750   while (b->parm_flag == 2)
5751     b = b->level_chain;
5752
5753   if (b->namespace_p)
5754     {
5755       t =  IDENTIFIER_NAMESPACE_VALUE (name);
5756
5757       /* extern "C" function() */
5758       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5759         t = TREE_VALUE (t);
5760     }
5761   else if (IDENTIFIER_BINDING (name)
5762            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5763     {
5764       while (1)
5765         {
5766           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5767             return IDENTIFIER_VALUE (name);
5768
5769           if (b->keep == 2)
5770             b = b->level_chain;
5771           else
5772             break;
5773         }
5774     }
5775
5776   return t;
5777 }
5778
5779 /* Like lookup_name_current_level, but for types.  */
5780
5781 tree
5782 lookup_type_current_level (name)
5783      tree name;
5784 {
5785   register tree t = NULL_TREE;
5786
5787   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5788
5789   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5790       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5791     {
5792       struct binding_level *b = current_binding_level;
5793       while (1)
5794         {
5795           if (purpose_member (name, b->type_shadowed))
5796             return REAL_IDENTIFIER_TYPE_VALUE (name);
5797           if (b->keep == 2)
5798             b = b->level_chain;
5799           else
5800             break;
5801         }
5802     }
5803
5804   return t;
5805 }
5806
5807 void
5808 begin_only_namespace_names ()
5809 {
5810   only_namespace_names = 1;
5811 }
5812
5813 void
5814 end_only_namespace_names ()
5815 {
5816   only_namespace_names = 0;
5817 }
5818 \f
5819 /* Arrange for the user to get a source line number, even when the
5820    compiler is going down in flames, so that she at least has a
5821    chance of working around problems in the compiler.  We used to
5822    call error(), but that let the segmentation fault continue
5823    through; now, it's much more passive by asking them to send the
5824    maintainers mail about the problem.  */
5825
5826 static void
5827 signal_catch (sig)
5828      int sig ATTRIBUTE_UNUSED;
5829 {
5830   signal (SIGSEGV, SIG_DFL);
5831 #ifdef SIGIOT
5832   signal (SIGIOT, SIG_DFL);
5833 #endif
5834 #ifdef SIGILL
5835   signal (SIGILL, SIG_DFL);
5836 #endif
5837 #ifdef SIGABRT
5838   signal (SIGABRT, SIG_DFL);
5839 #endif
5840 #ifdef SIGBUS
5841   signal (SIGBUS, SIG_DFL);
5842 #endif
5843   my_friendly_abort (0);
5844 }
5845
5846 #if 0
5847 /* Unused -- brendan 970107 */
5848 /* Array for holding types considered "built-in".  These types
5849    are output in the module in which `main' is defined.  */
5850 static tree *builtin_type_tdescs_arr;
5851 static int builtin_type_tdescs_len, builtin_type_tdescs_max;
5852 #endif
5853
5854 /* Push the declarations of builtin types into the namespace.
5855    RID_INDEX, if < RID_MAX is the index of the builtin type
5856    in the array RID_POINTERS.  NAME is the name used when looking
5857    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5858
5859 static void
5860 record_builtin_type (rid_index, name, type)
5861      enum rid rid_index;
5862      const char *name;
5863      tree type;
5864 {
5865   tree rname = NULL_TREE, tname = NULL_TREE;
5866   tree tdecl = NULL_TREE;
5867
5868   if ((int) rid_index < (int) RID_MAX)
5869     rname = ridpointers[(int) rid_index];
5870   if (name)
5871     tname = get_identifier (name);
5872
5873   TYPE_BUILT_IN (type) = 1;
5874
5875   if (tname)
5876     {
5877       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5878       set_identifier_type_value (tname, NULL_TREE);
5879       if ((int) rid_index < (int) RID_MAX)
5880         /* Built-in types live in the global namespace. */
5881         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5882     }
5883   if (rname != NULL_TREE)
5884     {
5885       if (tname != NULL_TREE)
5886         {
5887           set_identifier_type_value (rname, NULL_TREE);
5888           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5889         }
5890       else
5891         {
5892           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5893           set_identifier_type_value (rname, NULL_TREE);
5894         }
5895     }
5896 }
5897
5898 /* Record one of the standard Java types.
5899  * Declare it as having the given NAME.
5900  * If SIZE > 0, it is the size of one of the integral types;
5901  * otherwise it is the negative of the size of one of the other types.  */
5902
5903 static tree
5904 record_builtin_java_type (name, size)
5905      const char *name;
5906      int size;
5907 {
5908   tree type, decl;
5909   if (size > 0)
5910     type = make_signed_type (size);
5911   else if (size > -32)
5912     { /* "__java_char" or ""__java_boolean". */
5913       type = make_unsigned_type (-size);
5914       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5915     }
5916   else
5917     { /* "__java_float" or ""__java_double". */
5918       type = make_node (REAL_TYPE);
5919       TYPE_PRECISION (type) = - size;
5920       layout_type (type);
5921     }
5922   record_builtin_type (RID_MAX, name, type);
5923   decl = TYPE_NAME (type);
5924   DECL_IGNORED_P (decl) = 1;
5925   TYPE_FOR_JAVA (type) = 1;
5926   return type;
5927 }
5928
5929 /* Push a type into the namespace so that the back-ends ignore it. */
5930
5931 static void
5932 record_unknown_type (type, name)
5933      tree type;
5934      const char *name;
5935 {
5936   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5937   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5938   DECL_IGNORED_P (decl) = 1;
5939   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5940   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5941   TYPE_ALIGN (type) = 1;
5942   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5943 }
5944
5945 /* Push overloaded decl, in global scope, with one argument so it
5946    can be used as a callback from define_function.  */
5947
5948 static void
5949 push_overloaded_decl_1 (x)
5950      tree x;
5951 {
5952   push_overloaded_decl (x, PUSH_GLOBAL);
5953 }
5954
5955 #ifdef __GNUC__
5956 __inline
5957 #endif
5958 tree
5959 auto_function (name, type, code)
5960      tree name, type;
5961      enum built_in_function code;
5962 {
5963   return define_function
5964     (IDENTIFIER_POINTER (name), type, code, push_overloaded_decl_1,
5965      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5966                                               0)));
5967 }
5968
5969 /* Create the predefined scalar types of C,
5970    and some nodes representing standard constants (0, 1, (void *)0).
5971    Initialize the global binding level.
5972    Make definitions for built-in primitive functions.  */
5973
5974 void
5975 init_decl_processing ()
5976 {
5977   register tree endlink, int_endlink, double_endlink, unsigned_endlink;
5978   tree fields[20];
5979   /* Data type of memcpy.  */
5980   tree memcpy_ftype, strlen_ftype;
5981   int wchar_type_size;
5982   tree temp;
5983   tree array_domain_type;
5984   tree vb_off_identifier = NULL_TREE;
5985   /* Function type `char *(char *, char *)' and similar ones */
5986   tree string_ftype_ptr_ptr, int_ftype_string_string;
5987   tree sizetype_endlink;
5988   tree ptr_ftype, ptr_ftype_unsigned, ptr_ftype_sizetype;
5989   tree void_ftype, void_ftype_int, void_ftype_ptr;
5990
5991   /* Have to make these distinct before we try using them.  */
5992   lang_name_cplusplus = get_identifier ("C++");
5993   lang_name_c = get_identifier ("C");
5994   lang_name_java = get_identifier ("Java");
5995
5996   /* Enter the global namespace. */
5997   my_friendly_assert (global_namespace == NULL_TREE, 375);
5998   my_friendly_assert (current_lang_name == NULL_TREE, 375);
5999   current_lang_name = lang_name_cplusplus;
6000   push_namespace (get_identifier ("::"));
6001   global_namespace = current_namespace;
6002   current_lang_name = NULL_TREE;
6003
6004   if (flag_strict_prototype == 2)
6005     flag_strict_prototype = pedantic;
6006   if (! flag_permissive && ! pedantic)
6007     flag_pedantic_errors = 1;
6008
6009   strict_prototypes_lang_c = flag_strict_prototype;
6010
6011   /* Initially, C.  */
6012   current_lang_name = lang_name_c;
6013
6014   current_function_decl = NULL_TREE;
6015   named_labels = NULL_TREE;
6016   named_label_uses = NULL;
6017   current_binding_level = NULL_BINDING_LEVEL;
6018   free_binding_level = NULL_BINDING_LEVEL;
6019
6020   /* Because most segmentation signals can be traced back into user
6021      code, catch them and at least give the user a chance of working
6022      around compiler bugs.  */
6023   signal (SIGSEGV, signal_catch);
6024
6025   /* We will also catch aborts in the back-end through signal_catch and
6026      give the user a chance to see where the error might be, and to defeat
6027      aborts in the back-end when there have been errors previously in their
6028      code.  */
6029 #ifdef SIGIOT
6030   signal (SIGIOT, signal_catch);
6031 #endif
6032 #ifdef SIGILL
6033   signal (SIGILL, signal_catch);
6034 #endif
6035 #ifdef SIGABRT
6036   signal (SIGABRT, signal_catch);
6037 #endif
6038 #ifdef SIGBUS
6039   signal (SIGBUS, signal_catch);
6040 #endif
6041
6042   gcc_obstack_init (&decl_obstack);
6043
6044   /* Must lay these out before anything else gets laid out.  */
6045   error_mark_node = make_node (ERROR_MARK);
6046   TREE_PERMANENT (error_mark_node) = 1;
6047   TREE_TYPE (error_mark_node) = error_mark_node;
6048   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6049   TREE_TYPE (error_mark_list) = error_mark_node;
6050
6051   /* Make the binding_level structure for global names.  */
6052   pushlevel (0);
6053   global_binding_level = current_binding_level;
6054   /* The global level is the namespace level of ::.  */
6055   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6056   declare_namespace_level ();
6057
6058   this_identifier = get_identifier (THIS_NAME);
6059   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6060   ctor_identifier = get_identifier (CTOR_NAME);
6061   dtor_identifier = get_identifier (DTOR_NAME);
6062   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6063   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6064   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6065   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6066   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6067   if (flag_handle_signatures)
6068     {
6069       tag_identifier = get_identifier (SIGTABLE_TAG_NAME);
6070       vb_off_identifier = get_identifier (SIGTABLE_VB_OFF_NAME);
6071       vt_off_identifier = get_identifier (SIGTABLE_VT_OFF_NAME);
6072     }
6073
6074   /* Define `int' and `char' first so that dbx will output them first.  */
6075
6076   integer_type_node = make_signed_type (INT_TYPE_SIZE);
6077   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6078
6079   /* Define `char', which is like either `signed char' or `unsigned char'
6080      but not the same as either.  */
6081
6082   char_type_node
6083     = (flag_signed_char
6084        ? make_signed_type (CHAR_TYPE_SIZE)
6085        : make_unsigned_type (CHAR_TYPE_SIZE));
6086   record_builtin_type (RID_CHAR, "char", char_type_node);
6087
6088   /* `signed' is the same as `int' */
6089   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6090
6091   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
6092   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6093
6094   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
6095   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6096
6097   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
6098   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6099   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6100
6101   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
6102   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6103
6104   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
6105   record_builtin_type (RID_MAX, "long long unsigned int",
6106                        long_long_unsigned_type_node);
6107   record_builtin_type (RID_MAX, "long long unsigned",
6108                        long_long_unsigned_type_node);
6109
6110   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
6111   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6112   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
6113   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6114   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6115
6116   /* `unsigned long' is the standard type for sizeof.
6117      Note that stddef.h uses `unsigned long',
6118      and this must agree, even if long and int are the same size.  */
6119   set_sizetype
6120     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6121
6122   ptrdiff_type_node
6123     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6124
6125   /* Define both `signed char' and `unsigned char'.  */
6126   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
6127   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6128   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
6129   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6130
6131   /* These are types that type_for_size and type_for_mode use.  */
6132   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
6133   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6134   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
6135   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6136   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
6137   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6138   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
6139   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6140 #if HOST_BITS_PER_WIDE_INT >= 64
6141   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
6142   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6143 #endif
6144   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
6145   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6146   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
6147   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6148   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
6149   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6150   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
6151   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6152 #if HOST_BITS_PER_WIDE_INT >= 64
6153   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
6154   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6155 #endif
6156
6157   float_type_node = make_node (REAL_TYPE);
6158   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
6159   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6160   layout_type (float_type_node);
6161
6162   double_type_node = make_node (REAL_TYPE);
6163   if (flag_short_double)
6164     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
6165   else
6166     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
6167   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6168   layout_type (double_type_node);
6169
6170   long_double_type_node = make_node (REAL_TYPE);
6171   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
6172   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6173   layout_type (long_double_type_node);
6174
6175   complex_integer_type_node = make_node (COMPLEX_TYPE);
6176   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6177                         complex_integer_type_node));
6178   TREE_TYPE (complex_integer_type_node) = integer_type_node;
6179   layout_type (complex_integer_type_node);
6180
6181   complex_float_type_node = make_node (COMPLEX_TYPE);
6182   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6183                         complex_float_type_node));
6184   TREE_TYPE (complex_float_type_node) = float_type_node;
6185   layout_type (complex_float_type_node);
6186
6187   complex_double_type_node = make_node (COMPLEX_TYPE);
6188   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6189                         complex_double_type_node));
6190   TREE_TYPE (complex_double_type_node) = double_type_node;
6191   layout_type (complex_double_type_node);
6192
6193   complex_long_double_type_node = make_node (COMPLEX_TYPE);
6194   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6195                         complex_long_double_type_node));
6196   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
6197   layout_type (complex_long_double_type_node);
6198
6199   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6200   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6201   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6202   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6203   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6204   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6205   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6206   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6207
6208   integer_zero_node = build_int_2 (0, 0);
6209   TREE_TYPE (integer_zero_node) = integer_type_node;
6210   integer_one_node = build_int_2 (1, 0);
6211   TREE_TYPE (integer_one_node) = integer_type_node;
6212   integer_two_node = build_int_2 (2, 0);
6213   TREE_TYPE (integer_two_node) = integer_type_node;
6214   integer_three_node = build_int_2 (3, 0);
6215   TREE_TYPE (integer_three_node) = integer_type_node;
6216
6217   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6218   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6219   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6220   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6221   TYPE_PRECISION (boolean_type_node) = 1;
6222   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6223   boolean_false_node = build_int_2 (0, 0);
6224   TREE_TYPE (boolean_false_node) = boolean_type_node;
6225   boolean_true_node = build_int_2 (1, 0);
6226   TREE_TYPE (boolean_true_node) = boolean_type_node;
6227
6228   /* These are needed by stor-layout.c.  */
6229   size_zero_node = size_int (0);
6230   size_one_node = size_int (1);
6231
6232   signed_size_zero_node = build_int_2 (0, 0);
6233   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6234
6235   void_type_node = make_node (VOID_TYPE);
6236   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6237   layout_type (void_type_node); /* Uses integer_zero_node.  */
6238   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6239   TREE_PARMLIST (void_list_node) = 1;
6240
6241   null_pointer_node = build_int_2 (0, 0);
6242   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
6243   layout_type (TREE_TYPE (null_pointer_node));
6244
6245   /* Used for expressions that do nothing, but are not errors.  */
6246   void_zero_node = build_int_2 (0, 0);
6247   TREE_TYPE (void_zero_node) = void_type_node;
6248
6249   string_type_node = build_pointer_type (char_type_node);
6250   const_string_type_node
6251     = build_pointer_type (build_qualified_type (char_type_node,
6252                                                 TYPE_QUAL_CONST));
6253 #if 0
6254   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6255 #endif
6256
6257   /* Make a type to be the domain of a few array types
6258      whose domains don't really matter.
6259      200 is small enough that it always fits in size_t
6260      and large enough that it can hold most function names for the
6261      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
6262   array_domain_type = build_index_type (build_int_2 (200, 0));
6263
6264   /* Make a type for arrays of characters.
6265      With luck nothing will ever really depend on the length of this
6266      array type.  */
6267   char_array_type_node
6268     = build_array_type (char_type_node, array_domain_type);
6269   /* Likewise for arrays of ints.  */
6270   int_array_type_node
6271     = build_array_type (integer_type_node, array_domain_type);
6272
6273   /* This is just some anonymous class type.  Nobody should ever
6274      need to look inside this envelope.  */
6275   class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
6276
6277   default_function_type
6278     = build_function_type (integer_type_node, NULL_TREE);
6279
6280   ptr_type_node = build_pointer_type (void_type_node);
6281   const_ptr_type_node
6282     = build_pointer_type (build_qualified_type (void_type_node,
6283                                                 TYPE_QUAL_CONST));
6284 #if 0
6285   record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
6286 #endif
6287   endlink = void_list_node;
6288   int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
6289   double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
6290   unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
6291
6292   ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
6293   ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
6294   sizetype_endlink = tree_cons (NULL_TREE, sizetype, endlink);
6295   /* We realloc here because sizetype could be int or unsigned.  S'ok.  */
6296   ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
6297
6298   void_ftype = build_function_type (void_type_node, endlink);
6299   void_ftype_int = build_function_type (void_type_node, int_endlink);
6300   void_ftype_ptr
6301     = build_function_type (void_type_node,
6302                            tree_cons (NULL_TREE, ptr_type_node, endlink));
6303   void_ftype_ptr
6304     = build_exception_variant (void_ftype_ptr,
6305                                tree_cons (NULL_TREE, NULL_TREE, NULL_TREE));
6306
6307   float_ftype_float
6308     = build_function_type (float_type_node,
6309                            tree_cons (NULL_TREE, float_type_node, endlink));
6310
6311   double_ftype_double
6312     = build_function_type (double_type_node, double_endlink);
6313
6314   ldouble_ftype_ldouble
6315     = build_function_type (long_double_type_node,
6316                            tree_cons (NULL_TREE, long_double_type_node,
6317                                       endlink));
6318
6319   double_ftype_double_double
6320     = build_function_type (double_type_node,
6321                            tree_cons (NULL_TREE, double_type_node,
6322                                       double_endlink));
6323
6324   int_ftype_int
6325     = build_function_type (integer_type_node, int_endlink);
6326
6327   long_ftype_long
6328     = build_function_type (long_integer_type_node,
6329                            tree_cons (NULL_TREE, long_integer_type_node,
6330                                       endlink));
6331
6332   int_ftype_cptr_cptr_sizet
6333     = build_function_type (integer_type_node,
6334                            tree_cons (NULL_TREE, const_ptr_type_node,
6335                                       tree_cons (NULL_TREE, const_ptr_type_node,
6336                                                  tree_cons (NULL_TREE,
6337                                                             sizetype,
6338                                                             endlink))));
6339
6340   string_ftype_ptr_ptr          /* strcpy prototype */
6341     = build_function_type (string_type_node,
6342                            tree_cons (NULL_TREE, string_type_node,
6343                                       tree_cons (NULL_TREE,
6344                                                  const_string_type_node,
6345                                                  endlink)));
6346
6347   int_ftype_string_string       /* strcmp prototype */
6348     = build_function_type (integer_type_node,
6349                            tree_cons (NULL_TREE, const_string_type_node,
6350                                       tree_cons (NULL_TREE,
6351                                                  const_string_type_node,
6352                                                  endlink)));
6353
6354   strlen_ftype          /* strlen prototype */
6355     = build_function_type (sizetype,
6356                            tree_cons (NULL_TREE, const_string_type_node,
6357                                       endlink));
6358
6359   memcpy_ftype  /* memcpy prototype */
6360     = build_function_type (ptr_type_node,
6361                            tree_cons (NULL_TREE, ptr_type_node,
6362                                       tree_cons (NULL_TREE, const_ptr_type_node,
6363                                                  sizetype_endlink)));
6364
6365   if (flag_huge_objects)
6366     delta_type_node = long_integer_type_node;
6367   else
6368     delta_type_node = short_integer_type_node;
6369
6370   builtin_function ("__builtin_constant_p", default_function_type,
6371                     BUILT_IN_CONSTANT_P, NULL_PTR);
6372
6373   builtin_return_address_fndecl
6374     = builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
6375                         BUILT_IN_RETURN_ADDRESS, NULL_PTR);
6376
6377   builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
6378                     BUILT_IN_FRAME_ADDRESS, NULL_PTR);
6379
6380   builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
6381                     BUILT_IN_ALLOCA, "alloca");
6382   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
6383   /* Define alloca, ffs as builtins.
6384      Declare _exit just to mark it as volatile.  */
6385   if (! flag_no_builtin && !flag_no_nonansi_builtin)
6386     {
6387       temp = builtin_function ("alloca", ptr_ftype_sizetype,
6388                                BUILT_IN_ALLOCA, NULL_PTR);
6389       /* Suppress error if redefined as a non-function.  */
6390       DECL_BUILT_IN_NONANSI (temp) = 1;
6391       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
6392       /* Suppress error if redefined as a non-function.  */
6393       DECL_BUILT_IN_NONANSI (temp) = 1;
6394       temp = builtin_function ("_exit", void_ftype_int,
6395                                NOT_BUILT_IN, NULL_PTR);
6396       TREE_THIS_VOLATILE (temp) = 1;
6397       TREE_SIDE_EFFECTS (temp) = 1;
6398       /* Suppress error if redefined as a non-function.  */
6399       DECL_BUILT_IN_NONANSI (temp) = 1;
6400     }
6401
6402   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
6403   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
6404                     NULL_PTR);
6405   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
6406                     NULL_PTR);
6407   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
6408                     NULL_PTR);
6409   builtin_function ("__builtin_labs", long_ftype_long,
6410                     BUILT_IN_LABS, NULL_PTR);
6411   builtin_function ("__builtin_saveregs", ptr_ftype,
6412                     BUILT_IN_SAVEREGS, NULL_PTR);
6413   builtin_function ("__builtin_classify_type", default_function_type,
6414                     BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
6415   builtin_function ("__builtin_next_arg", ptr_ftype,
6416                     BUILT_IN_NEXT_ARG, NULL_PTR);
6417   builtin_function ("__builtin_args_info", int_ftype_int,
6418                     BUILT_IN_ARGS_INFO, NULL_PTR);
6419   builtin_function ("__builtin_setjmp",
6420                     build_function_type (integer_type_node,
6421                                          tree_cons (NULL_TREE, ptr_type_node,
6422                                                     endlink)),
6423                     BUILT_IN_SETJMP, NULL_PTR);
6424   builtin_function ("__builtin_longjmp",
6425                     build_function_type (integer_type_node,
6426                                          tree_cons (NULL_TREE, ptr_type_node,
6427                                                     tree_cons (NULL_TREE,
6428                                                                integer_type_node,
6429                                                                endlink))),
6430                     BUILT_IN_LONGJMP, NULL_PTR);
6431
6432   /* Untyped call and return.  */
6433   builtin_function ("__builtin_apply_args", ptr_ftype,
6434                     BUILT_IN_APPLY_ARGS, NULL_PTR);
6435
6436   temp = tree_cons (NULL_TREE,
6437                     build_pointer_type (build_function_type (void_type_node,
6438                                                              NULL_TREE)),
6439                     tree_cons (NULL_TREE, ptr_ftype_sizetype, NULL_TREE));
6440   builtin_function ("__builtin_apply",
6441                     build_function_type (ptr_type_node, temp),
6442                     BUILT_IN_APPLY, NULL_PTR);
6443   builtin_function ("__builtin_return", void_ftype_ptr,
6444                     BUILT_IN_RETURN, NULL_PTR);
6445
6446   /* Currently under experimentation.  */
6447   builtin_function ("__builtin_memcpy", memcpy_ftype,
6448                     BUILT_IN_MEMCPY, "memcpy");
6449   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
6450                     BUILT_IN_MEMCMP, "memcmp");
6451   builtin_function ("__builtin_strcmp", int_ftype_string_string,
6452                     BUILT_IN_STRCMP, "strcmp");
6453   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
6454                     BUILT_IN_STRCPY, "strcpy");
6455   builtin_function ("__builtin_strlen", strlen_ftype,
6456                     BUILT_IN_STRLEN, "strlen");
6457   builtin_function ("__builtin_sqrtf", float_ftype_float,
6458                     BUILT_IN_FSQRT, "sqrtf");
6459   builtin_function ("__builtin_fsqrt", double_ftype_double,
6460                     BUILT_IN_FSQRT, NULL_PTR);
6461   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
6462                     BUILT_IN_FSQRT, "sqrtl");
6463   builtin_function ("__builtin_sinf", float_ftype_float,
6464                     BUILT_IN_SIN, "sinf");
6465   builtin_function ("__builtin_sin", double_ftype_double,
6466                     BUILT_IN_SIN, "sin");
6467   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
6468                     BUILT_IN_SIN, "sinl");
6469   builtin_function ("__builtin_cosf", float_ftype_float,
6470                     BUILT_IN_COS, "cosf");
6471   builtin_function ("__builtin_cos", double_ftype_double,
6472                     BUILT_IN_COS, "cos");
6473   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
6474                     BUILT_IN_COS, "cosl");
6475
6476   if (!flag_no_builtin)
6477     {
6478       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
6479       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
6480       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
6481       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
6482       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
6483                         NULL_PTR);
6484       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
6485       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
6486                         NULL_PTR);
6487       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
6488                         NULL_PTR);
6489       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
6490                         NULL_PTR);
6491       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
6492       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
6493       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
6494       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
6495                         NULL_PTR);
6496       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
6497       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
6498       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
6499       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
6500       builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
6501       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
6502
6503       /* Declare these functions volatile
6504          to avoid spurious "control drops through" warnings.  */
6505       temp = builtin_function ("abort", void_ftype,
6506                                NOT_BUILT_IN, NULL_PTR);
6507       TREE_THIS_VOLATILE (temp) = 1;
6508       TREE_SIDE_EFFECTS (temp) = 1;
6509       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6510          them...  */
6511       DECL_BUILT_IN_NONANSI (temp) = 1;
6512       temp = builtin_function ("exit", void_ftype_int,
6513                                NOT_BUILT_IN, NULL_PTR);
6514       TREE_THIS_VOLATILE (temp) = 1;
6515       TREE_SIDE_EFFECTS (temp) = 1;
6516       DECL_BUILT_IN_NONANSI (temp) = 1;
6517     }
6518
6519 #if 0
6520   /* Support for these has not been written in either expand_builtin
6521      or build_function_call.  */
6522   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
6523   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
6524   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
6525                     NULL_PTR);
6526   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
6527                     NULL_PTR);
6528   builtin_function ("__builtin_fmod", double_ftype_double_double,
6529                     BUILT_IN_FMOD, NULL_PTR);
6530   builtin_function ("__builtin_frem", double_ftype_double_double,
6531                     BUILT_IN_FREM, NULL_PTR);
6532   builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
6533                     BUILT_IN_MEMSET, NULL_PTR);
6534   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
6535                     NULL_PTR);
6536   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
6537                     NULL_PTR);
6538 #endif
6539
6540   /* C++ extensions */
6541
6542   unknown_type_node = make_node (UNKNOWN_TYPE);
6543   record_unknown_type (unknown_type_node, "unknown type");
6544
6545   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6546   TREE_TYPE (unknown_type_node) = unknown_type_node;
6547
6548   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6549
6550   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6551      result.  */
6552   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6553   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6554
6555   /* This is for handling opaque types in signatures.  */
6556   opaque_type_node = copy_node (ptr_type_node);
6557   TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
6558   record_builtin_type (RID_MAX, 0, opaque_type_node);
6559
6560   /* This is special for C++ so functions can be overloaded.  */
6561   wchar_type_node
6562     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
6563   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6564   signed_wchar_type_node = make_signed_type (wchar_type_size);
6565   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6566   wchar_type_node
6567     = TREE_UNSIGNED (wchar_type_node)
6568       ? unsigned_wchar_type_node
6569       : signed_wchar_type_node;
6570   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6571
6572   /* Artificial declaration of wchar_t -- can be bashed */
6573   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6574                                 wchar_type_node);
6575   pushdecl (wchar_decl_node);
6576
6577   /* This is for wide string constants.  */
6578   wchar_array_type_node
6579     = build_array_type (wchar_type_node, array_domain_type);
6580
6581   if (flag_vtable_thunks)
6582     {
6583       /* Make sure we get a unique function type, so we can give
6584          its pointer type a name.  (This wins for gdb.) */
6585       tree vfunc_type = make_node (FUNCTION_TYPE);
6586       TREE_TYPE (vfunc_type) = integer_type_node;
6587       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6588       layout_type (vfunc_type);
6589
6590       vtable_entry_type = build_pointer_type (vfunc_type);
6591     }
6592   else
6593     {
6594       vtable_entry_type = make_lang_type (RECORD_TYPE);
6595       fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
6596                                          delta_type_node);
6597       fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
6598                                          delta_type_node);
6599       fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
6600                                          ptr_type_node);
6601       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6602                            double_type_node);
6603
6604       /* Make this part of an invisible union.  */
6605       fields[3] = copy_node (fields[2]);
6606       TREE_TYPE (fields[3]) = delta_type_node;
6607       DECL_NAME (fields[3]) = delta2_identifier;
6608       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6609       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6610       TREE_UNSIGNED (fields[3]) = 0;
6611       TREE_CHAIN (fields[2]) = fields[3];
6612       vtable_entry_type = build_qualified_type (vtable_entry_type,
6613                                                 TYPE_QUAL_CONST);
6614     }
6615   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6616
6617   vtbl_type_node
6618     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6619   layout_type (vtbl_type_node);
6620   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6621   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6622   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6623   layout_type (vtbl_ptr_type_node);
6624   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6625
6626   /* Simplify life by making a "sigtable_entry_type".  Give its
6627      fields names so that the debugger can use them.  */
6628
6629   if (flag_handle_signatures)
6630     {
6631       sigtable_entry_type = make_lang_type (RECORD_TYPE);
6632       fields[0] = build_lang_field_decl (FIELD_DECL, tag_identifier,
6633                                          delta_type_node);
6634       fields[1] = build_lang_field_decl (FIELD_DECL, vb_off_identifier,
6635                                          delta_type_node);
6636       fields[2] = build_lang_field_decl (FIELD_DECL, delta_identifier,
6637                                          delta_type_node);
6638       fields[3] = build_lang_field_decl (FIELD_DECL, index_identifier,
6639                                          delta_type_node);
6640       fields[4] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
6641                                          ptr_type_node);
6642
6643       /* Set the alignment to the max of the alignment of ptr_type_node and
6644          delta_type_node.  Double alignment wastes a word on the Sparc.  */
6645       finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 4,
6646                            (TYPE_ALIGN (ptr_type_node) > TYPE_ALIGN (delta_type_node))
6647                            ? ptr_type_node
6648                            : delta_type_node);
6649
6650       /* Make this part of an invisible union.  */
6651       fields[5] = copy_node (fields[4]);
6652       TREE_TYPE (fields[5]) = delta_type_node;
6653       DECL_NAME (fields[5]) = vt_off_identifier;
6654       DECL_MODE (fields[5]) = TYPE_MODE (delta_type_node);
6655       DECL_SIZE (fields[5]) = TYPE_SIZE (delta_type_node);
6656       TREE_UNSIGNED (fields[5]) = 0;
6657       TREE_CHAIN (fields[4]) = fields[5];
6658
6659       sigtable_entry_type = build_qualified_type (sigtable_entry_type,
6660                                                   TYPE_QUAL_CONST);
6661       record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
6662     }
6663
6664   std_node = build_decl (NAMESPACE_DECL,
6665                          get_identifier (flag_honor_std ? "fake std":"std"),
6666                          void_type_node);
6667   pushdecl (std_node);
6668
6669   global_type_node = make_node (LANG_TYPE);
6670   record_unknown_type (global_type_node, "global type");
6671
6672   /* Now, C++.  */
6673   current_lang_name = lang_name_cplusplus;
6674
6675   {
6676     tree bad_alloc_type_node, newtype, deltype;
6677     if (flag_honor_std)
6678       push_namespace (get_identifier ("std"));
6679     bad_alloc_type_node = xref_tag
6680       (class_type_node, get_identifier ("bad_alloc"), 1);
6681     if (flag_honor_std)
6682       pop_namespace ();
6683     newtype = build_exception_variant
6684       (ptr_ftype_sizetype, build_tree_list (NULL_TREE, bad_alloc_type_node));
6685     deltype = build_exception_variant
6686       (void_ftype_ptr, build_tree_list (NULL_TREE, NULL_TREE));
6687     auto_function (ansi_opname[(int) NEW_EXPR], newtype, NOT_BUILT_IN);
6688     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype, NOT_BUILT_IN);
6689     global_delete_fndecl
6690       = auto_function (ansi_opname[(int) DELETE_EXPR], deltype, NOT_BUILT_IN);
6691     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype, NOT_BUILT_IN);
6692   }
6693
6694   abort_fndecl
6695     = define_function ("__pure_virtual", void_ftype,
6696                        NOT_BUILT_IN, 0, 0);
6697
6698   /* Perform other language dependent initializations.  */
6699   init_class_processing ();
6700   init_init_processing ();
6701   init_search_processing ();
6702   if (flag_rtti)
6703     init_rtti_processing ();
6704
6705   if (flag_exceptions)
6706     init_exception_processing ();
6707   if (flag_no_inline)
6708     {
6709       flag_inline_functions = 0;
6710     }
6711
6712   if (! supports_one_only ())
6713     flag_weak = 0;
6714
6715   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6716   declare_function_name ();
6717
6718   /* Prepare to check format strings against argument lists.  */
6719   init_function_format_info ();
6720
6721   /* Show we use EH for cleanups.  */
6722   using_eh_for_cleanups ();
6723
6724   print_error_function = lang_print_error_function;
6725   lang_get_alias_set = &c_get_alias_set;
6726
6727   /* Maintain consistency.  Perhaps we should just complain if they
6728      say -fwritable-strings?  */
6729   if (flag_writable_strings)
6730     flag_const_strings = 0;
6731 }
6732
6733 /* Function to print any language-specific context for an error message.  */
6734
6735 static void
6736 lang_print_error_function (file)
6737      char *file;
6738 {
6739   default_print_error_function (file);
6740   maybe_print_template_context ();
6741 }
6742
6743 /* Make a definition for a builtin function named NAME and whose data type
6744    is TYPE.  TYPE should be a function type with argument types.
6745    FUNCTION_CODE tells later passes how to compile calls to this function.
6746    See tree.h for its possible values.
6747
6748    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6749    the name to be called if we can't opencode the function.  */
6750
6751 tree
6752 define_function (name, type, function_code, pfn, library_name)
6753      const char *name;
6754      tree type;
6755      enum built_in_function function_code;
6756      void (*pfn) PROTO((tree));
6757      const char *library_name;
6758 {
6759   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6760   DECL_EXTERNAL (decl) = 1;
6761   TREE_PUBLIC (decl) = 1;
6762   DECL_ARTIFICIAL (decl) = 1;
6763
6764   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6765   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6766
6767   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6768      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6769      function in the namespace.  */
6770   if (pfn) (*pfn) (decl);
6771   if (library_name)
6772     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6773   make_function_rtl (decl);
6774   if (function_code != NOT_BUILT_IN)
6775     {
6776       DECL_BUILT_IN (decl) = 1;
6777       DECL_FUNCTION_CODE (decl) = function_code;
6778     }
6779   return decl;
6780 }
6781 \f
6782 /* When we call finish_struct for an anonymous union, we create
6783    default copy constructors and such.  But, an anonymous union
6784    shouldn't have such things; this function undoes the damage to the
6785    anonymous union type T.
6786
6787    (The reason that we create the synthesized methods is that we don't
6788    distinguish `union { int i; }' from `typedef union { int i; } U'.
6789    The first is an anonymous union; the second is just an ordinary
6790    union type.)  */
6791
6792 void
6793 fixup_anonymous_union (t)
6794      tree t;
6795 {
6796   tree *q;
6797
6798   /* Wipe out memory of synthesized methods */
6799   TYPE_HAS_CONSTRUCTOR (t) = 0;
6800   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6801   TYPE_HAS_INIT_REF (t) = 0;
6802   TYPE_HAS_CONST_INIT_REF (t) = 0;
6803   TYPE_HAS_ASSIGN_REF (t) = 0;
6804   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6805
6806   /* Splice the implicitly generated functions out of the TYPE_METHODS
6807      list.  */
6808   q = &TYPE_METHODS (t);
6809   while (*q)
6810     {
6811       if (DECL_ARTIFICIAL (*q))
6812         *q = TREE_CHAIN (*q);
6813       else
6814         q = &TREE_CHAIN (*q);
6815     }
6816
6817   /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
6818      function members.  */
6819   if (TYPE_METHODS (t))
6820     error ("an anonymous union cannot have function members");
6821 }
6822
6823 /* Make sure that a declaration with no declarator is well-formed, i.e.
6824    just defines a tagged type or anonymous union.
6825
6826    Returns the type defined, if any.  */
6827
6828 tree
6829 check_tag_decl (declspecs)
6830      tree declspecs;
6831 {
6832   int found_type = 0;
6833   tree ob_modifier = NULL_TREE;
6834   register tree link;
6835   register tree t = NULL_TREE;
6836
6837   for (link = declspecs; link; link = TREE_CHAIN (link))
6838     {
6839       register tree value = TREE_VALUE (link);
6840
6841       if (TYPE_P (value))
6842         {
6843           ++found_type;
6844
6845           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6846             {
6847               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6848               t = value;
6849             }
6850         }
6851       else if (value == ridpointers[(int) RID_FRIEND])
6852         {
6853           if (current_class_type == NULL_TREE
6854               || current_scope () != current_class_type)
6855             ob_modifier = value;
6856         }
6857       else if (value == ridpointers[(int) RID_STATIC]
6858                || value == ridpointers[(int) RID_EXTERN]
6859                || value == ridpointers[(int) RID_AUTO]
6860                || value == ridpointers[(int) RID_REGISTER]
6861                || value == ridpointers[(int) RID_INLINE]
6862                || value == ridpointers[(int) RID_VIRTUAL]
6863                || value == ridpointers[(int) RID_CONST]
6864                || value == ridpointers[(int) RID_VOLATILE]
6865                || value == ridpointers[(int) RID_EXPLICIT])
6866         ob_modifier = value;
6867     }
6868
6869   if (found_type > 1)
6870     error ("multiple types in one declaration");
6871
6872   /* Inside a class, we might be in a friend or access declaration.
6873      Until we have a good way of detecting the latter, don't warn.  */
6874   if (t == NULL_TREE && ! current_class_type)
6875     pedwarn ("declaration does not declare anything");
6876
6877   /* Check for an anonymous union.  We're careful
6878      accessing TYPE_IDENTIFIER because some built-in types, like
6879      pointer-to-member types, do not have TYPE_NAME.  */
6880   else if (t && TREE_CODE (t) == UNION_TYPE
6881            && TYPE_NAME (t)
6882            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6883     {
6884       /* Anonymous unions are objects, so they can have specifiers.  */;
6885       SET_ANON_UNION_TYPE_P (t);
6886     }
6887
6888   else if (ob_modifier)
6889     {
6890       if (ob_modifier == ridpointers[(int) RID_INLINE]
6891           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6892         cp_error ("`%D' can only be specified for functions", ob_modifier);
6893       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6894         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6895       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6896         cp_error ("`%D' can only be specified for constructors",
6897                   ob_modifier);
6898       else
6899         cp_error ("`%D' can only be specified for objects and functions",
6900                   ob_modifier);
6901     }
6902
6903   return t;
6904 }
6905
6906 /* Called when a declaration is seen that contains no names to declare.
6907    If its type is a reference to a structure, union or enum inherited
6908    from a containing scope, shadow that tag name for the current scope
6909    with a forward reference.
6910    If its type defines a new named structure or union
6911    or defines an enum, it is valid but we need not do anything here.
6912    Otherwise, it is an error.
6913
6914    C++: may have to grok the declspecs to learn about static,
6915    complain for anonymous unions.  */
6916
6917 void
6918 shadow_tag (declspecs)
6919      tree declspecs;
6920 {
6921   tree t = check_tag_decl (declspecs);
6922
6923   if (t)
6924     maybe_process_partial_specialization (t);
6925
6926   /* This is where the variables in an anonymous union are
6927      declared.  An anonymous union declaration looks like:
6928      union { ... } ;
6929      because there is no declarator after the union, the parser
6930      sends that declaration here.  */
6931   if (t && ANON_UNION_TYPE_P (t))
6932     {
6933       fixup_anonymous_union (t);
6934
6935       if (TYPE_FIELDS (t))
6936         {
6937           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6938                                       NULL_TREE);
6939           finish_anon_union (decl);
6940         }
6941     }
6942 }
6943 \f
6944 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6945
6946 tree
6947 groktypename (typename)
6948      tree typename;
6949 {
6950   if (TREE_CODE (typename) != TREE_LIST)
6951     return typename;
6952   return grokdeclarator (TREE_VALUE (typename),
6953                          TREE_PURPOSE (typename),
6954                          TYPENAME, 0, NULL_TREE);
6955 }
6956
6957 /* Decode a declarator in an ordinary declaration or data definition.
6958    This is called as soon as the type information and variable name
6959    have been parsed, before parsing the initializer if any.
6960    Here we create the ..._DECL node, fill in its type,
6961    and put it on the list of decls for the current context.
6962    The ..._DECL node is returned as the value.
6963
6964    Exception: for arrays where the length is not specified,
6965    the type is left null, to be filled in by `cp_finish_decl'.
6966
6967    Function definitions do not come here; they go to start_function
6968    instead.  However, external and forward declarations of functions
6969    do go through here.  Structure field declarations are done by
6970    grokfield and not through here.  */
6971
6972 /* Set this to zero to debug not using the temporary obstack
6973    to parse initializers.  */
6974 int debug_temp_inits = 1;
6975
6976 tree
6977 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6978      tree declarator, declspecs;
6979      int initialized;
6980      tree attributes, prefix_attributes;
6981 {
6982   register tree decl;
6983   register tree type, tem;
6984   tree context;
6985   extern int have_extern_spec;
6986   extern int used_extern_spec;
6987   tree attrlist;
6988
6989 #if 0
6990   /* See code below that used this.  */
6991   int init_written = initialized;
6992 #endif
6993
6994   /* This should only be done once on the top most decl.  */
6995   if (have_extern_spec && !used_extern_spec)
6996     {
6997       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6998                                   declspecs);
6999       used_extern_spec = 1;
7000     }
7001
7002   if (attributes || prefix_attributes)
7003     attrlist = build_scratch_list (attributes, prefix_attributes);
7004   else
7005     attrlist = NULL_TREE;
7006
7007   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7008                          attrlist);
7009
7010   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7011     return NULL_TREE;
7012
7013   type = TREE_TYPE (decl);
7014
7015   if (type == error_mark_node)
7016     return NULL_TREE;
7017
7018   /* Don't lose if destructors must be executed at file-level.  */
7019   if (! processing_template_decl && TREE_STATIC (decl)
7020       && TYPE_NEEDS_DESTRUCTOR (complete_type (type))
7021       && !TREE_PERMANENT (decl))
7022     {
7023       push_obstacks (&permanent_obstack, &permanent_obstack);
7024       decl = copy_node (decl);
7025       if (TREE_CODE (type) == ARRAY_TYPE)
7026         {
7027           tree itype = TYPE_DOMAIN (type);
7028           if (itype && ! TREE_PERMANENT (itype))
7029             {
7030               itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
7031               type = build_cplus_array_type (TREE_TYPE (type), itype);
7032               TREE_TYPE (decl) = type;
7033             }
7034         }
7035       pop_obstacks ();
7036     }
7037
7038   context
7039     = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
7040       ? DECL_CLASS_CONTEXT (decl)
7041       : DECL_CONTEXT (decl);
7042
7043   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7044       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7045     {
7046       /* When parsing the initializer, lookup should use the object's
7047          namespace. */
7048       push_decl_namespace (context);
7049     }
7050
7051   /* We are only interested in class contexts, later. */
7052   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7053     context = NULL_TREE;
7054
7055   if (initialized)
7056     /* Is it valid for this decl to have an initializer at all?
7057        If not, set INITIALIZED to zero, which will indirectly
7058        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7059     switch (TREE_CODE (decl))
7060       {
7061       case TYPE_DECL:
7062         /* typedef foo = bar  means give foo the same type as bar.
7063            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7064            Any other case of an initialization in a TYPE_DECL is an error.  */
7065         if (pedantic || list_length (declspecs) > 1)
7066           {
7067             cp_error ("typedef `%D' is initialized", decl);
7068             initialized = 0;
7069           }
7070         break;
7071
7072       case FUNCTION_DECL:
7073         cp_error ("function `%#D' is initialized like a variable", decl);
7074         initialized = 0;
7075         break;
7076
7077       default:
7078         if (! processing_template_decl)
7079           {
7080             if (type != error_mark_node)
7081               {
7082                 if (TYPE_SIZE (type) != NULL_TREE
7083                     && ! TREE_CONSTANT (TYPE_SIZE (type)))
7084                   {
7085                     cp_error
7086                       ("variable-sized object `%D' may not be initialized",
7087                        decl);
7088                     initialized = 0;
7089                   }
7090
7091                 if (TREE_CODE (type) == ARRAY_TYPE
7092                     && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
7093                   {
7094                     cp_error
7095                       ("elements of array `%#D' have incomplete type", decl);
7096                     initialized = 0;
7097                   }
7098               }
7099           }
7100       }
7101
7102   if (initialized)
7103     {
7104       if (! toplevel_bindings_p ()
7105           && DECL_EXTERNAL (decl))
7106         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7107                     decl);
7108       DECL_EXTERNAL (decl) = 0;
7109       if (toplevel_bindings_p ())
7110         TREE_STATIC (decl) = 1;
7111
7112       /* Tell `pushdecl' this is an initialized decl
7113          even though we don't yet have the initializer expression.
7114          Also tell `cp_finish_decl' it may store the real initializer.  */
7115       DECL_INITIAL (decl) = error_mark_node;
7116     }
7117
7118   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
7119     {
7120       pushclass (context, 2);
7121
7122       if (TREE_CODE (decl) == VAR_DECL)
7123         {
7124           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7125           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7126             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7127           else
7128             {
7129               if (DECL_CONTEXT (field) != context)
7130                 {
7131                   cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
7132                               DECL_CONTEXT (field), DECL_NAME (decl),
7133                               context, DECL_NAME (decl));
7134                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7135                 }
7136               /* Static data member are tricky; an in-class initialization
7137                  still doesn't provide a definition, so the in-class
7138                  declaration will have DECL_EXTERNAL set, but will have an
7139                  initialization.  Thus, duplicate_decls won't warn
7140                  about this situation, and so we check here.  */
7141               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7142                 cp_error ("duplicate initialization of %D", decl);
7143               if (duplicate_decls (decl, field))
7144                 decl = field;
7145             }
7146         }
7147       else
7148         {
7149           tree field = check_classfn (context, decl);
7150           if (field && duplicate_decls (decl, field))
7151             decl = field;
7152         }
7153
7154       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7155       DECL_IN_AGGR_P (decl) = 0;
7156       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7157           || CLASSTYPE_USE_TEMPLATE (context))
7158         {
7159           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7160           /* [temp.expl.spec] An explicit specialization of a static data
7161              member of a template is a definition if the declaration
7162              includes an initializer; otherwise, it is a declaration.
7163
7164              We check for processing_specialization so this only applies
7165              to the new specialization syntax.  */
7166           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7167             DECL_EXTERNAL (decl) = 1;
7168         }
7169
7170       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7171         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7172                     decl);
7173     }
7174
7175 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7176   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7177 #endif
7178
7179   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7180   cplus_decl_attributes (decl, attributes, prefix_attributes);
7181
7182   /* Add this decl to the current binding level, but not if it
7183      comes from another scope, e.g. a static member variable.
7184      TEM may equal DECL or it may be a previous decl of the same name.  */
7185
7186   if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE
7187        /* Definitions of namespace members outside their namespace are
7188           possible. */
7189        && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
7190       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
7191       || TREE_CODE (type) == LANG_TYPE
7192       /* The declaration of template specializations does not affect
7193          the functions available for overload resolution, so we do not
7194          call pushdecl.  */
7195       || (TREE_CODE (decl) == FUNCTION_DECL
7196           && DECL_TEMPLATE_SPECIALIZATION (decl)))
7197     tem = decl;
7198   else
7199     tem = pushdecl (decl);
7200
7201   if (processing_template_decl)
7202     {
7203       if (! current_function_decl)
7204         tem = push_template_decl (tem);
7205       else if (minimal_parse_mode)
7206         DECL_VINDEX (tem)
7207             = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
7208                             copy_to_permanent (declspecs),
7209                             NULL_TREE);
7210     }
7211
7212
7213 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7214   /* Tell the back-end to use or not use .common as appropriate.  If we say
7215      -fconserve-space, we want this to save .data space, at the expense of
7216      wrong semantics.  If we say -fno-conserve-space, we want this to
7217      produce errors about redefs; to do this we force variables into the
7218      data segment.  */
7219   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7220 #endif
7221
7222   if (! processing_template_decl)
7223     start_decl_1 (tem);
7224
7225   /* Corresponding pop_obstacks is done in `cp_finish_decl'.  */
7226   push_obstacks_nochange ();
7227
7228 #if 0
7229   /* We have no way of knowing whether the initializer will need to be
7230      evaluated at run-time or not until we've parsed it, so let's just put
7231      it in the permanent obstack.  (jason) */
7232   if (init_written
7233       && ! (TREE_CODE (tem) == PARM_DECL
7234             || (TREE_READONLY (tem)
7235                 && (TREE_CODE (tem) == VAR_DECL
7236                     || TREE_CODE (tem) == FIELD_DECL))))
7237     {
7238       /* When parsing and digesting the initializer,
7239          use temporary storage.  Do this even if we will ignore the value.  */
7240       if (toplevel_bindings_p () && debug_temp_inits)
7241         {
7242           if (processing_template_decl
7243               || TYPE_NEEDS_CONSTRUCTING (type)
7244               || TREE_CODE (type) == REFERENCE_TYPE)
7245             /* In this case, the initializer must lay down in permanent
7246                storage, since it will be saved until `finish_file' is run.   */
7247             ;
7248           else
7249             temporary_allocation ();
7250         }
7251     }
7252 #endif
7253
7254   return tem;
7255 }
7256
7257 void
7258 start_decl_1 (decl)
7259      tree decl;
7260 {
7261   tree type = TREE_TYPE (decl);
7262   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7263
7264   if (type == error_mark_node)
7265     return;
7266
7267   /* If this type of object needs a cleanup, and control may
7268      jump past it, make a new binding level so that it is cleaned
7269      up only when it is initialized first.  */
7270   if (TYPE_NEEDS_DESTRUCTOR (type)
7271       && current_binding_level->more_cleanups_ok == 0)
7272     pushlevel_temporary (1);
7273
7274   if (initialized)
7275     /* Is it valid for this decl to have an initializer at all?
7276        If not, set INITIALIZED to zero, which will indirectly
7277        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7278     {
7279       /* Don't allow initializations for incomplete types except for
7280          arrays which might be completed by the initialization.  */
7281       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
7282         ;                       /* A complete type is ok.  */
7283       else if (TREE_CODE (type) != ARRAY_TYPE)
7284         {
7285           cp_error ("variable `%#D' has initializer but incomplete type",
7286                     decl);
7287           initialized = 0;
7288           type = TREE_TYPE (decl) = error_mark_node;
7289         }
7290       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
7291         {
7292           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7293             cp_error ("elements of array `%#D' have incomplete type", decl);
7294           /* else we already gave an error in start_decl.  */
7295           initialized = 0;
7296         }
7297     }
7298
7299   if (!initialized
7300       && TREE_CODE (decl) != TYPE_DECL
7301       && TREE_CODE (decl) != TEMPLATE_DECL
7302       && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
7303     {
7304       if ((! processing_template_decl || ! uses_template_parms (type))
7305           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
7306         {
7307           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7308                  decl);
7309           /* Change the type so that assemble_variable will give
7310              DECL an rtl we can live with: (mem (const_int 0)).  */
7311           type = TREE_TYPE (decl) = error_mark_node;
7312         }
7313       else
7314         {
7315           /* If any base type in the hierarchy of TYPE needs a constructor,
7316              then we set initialized to 1.  This way any nodes which are
7317              created for the purposes of initializing this aggregate
7318              will live as long as it does.  This is necessary for global
7319              aggregates which do not have their initializers processed until
7320              the end of the file.  */
7321           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7322         }
7323     }
7324
7325 #if 0
7326   /* We don't do this yet for GNU C++.  */
7327   /* For a local variable, define the RTL now.  */
7328   if (! toplevel_bindings_p ()
7329       /* But not if this is a duplicate decl
7330          and we preserved the rtl from the previous one
7331          (which may or may not happen).  */
7332       && DECL_RTL (tem) == NULL_RTX)
7333     {
7334       if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
7335         expand_decl (tem);
7336       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
7337                && DECL_INITIAL (tem) != NULL_TREE)
7338         expand_decl (tem);
7339     }
7340 #endif
7341
7342   if (! initialized)
7343     DECL_INITIAL (decl) = NULL_TREE;
7344 }
7345
7346 /* Handle initialization of references.
7347    These three arguments are from `cp_finish_decl', and have the
7348    same meaning here that they do there.
7349
7350    Quotes on semantics can be found in ARM 8.4.3.  */
7351
7352 static void
7353 grok_reference_init (decl, type, init)
7354      tree decl, type, init;
7355 {
7356   tree tmp;
7357
7358   if (init == NULL_TREE)
7359     {
7360       if ((DECL_LANG_SPECIFIC (decl) == 0
7361            || DECL_IN_AGGR_P (decl) == 0)
7362           && ! DECL_THIS_EXTERN (decl))
7363         {
7364           cp_error ("`%D' declared as reference but not initialized", decl);
7365           if (TREE_CODE (decl) == VAR_DECL)
7366             SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
7367         }
7368       return;
7369     }
7370
7371   if (init == error_mark_node)
7372     return;
7373
7374   if (TREE_CODE (type) == REFERENCE_TYPE
7375       && TREE_CODE (init) == CONSTRUCTOR)
7376     {
7377       cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
7378       return;
7379     }
7380
7381   if (TREE_CODE (init) == TREE_LIST)
7382     init = build_compound_expr (init);
7383
7384   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7385     init = convert_from_reference (init);
7386
7387   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7388       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7389     {
7390       /* Note: default conversion is only called in very special cases.  */
7391       init = default_conversion (init);
7392     }
7393
7394   tmp = convert_to_reference
7395     (type, init, CONV_IMPLICIT,
7396      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7397
7398   if (tmp == error_mark_node)
7399     goto fail;
7400   else if (tmp != NULL_TREE)
7401     {
7402       init = tmp;
7403       DECL_INITIAL (decl) = save_expr (init);
7404     }
7405   else
7406     {
7407       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7408       goto fail;
7409     }
7410
7411   /* ?? Can this be optimized in some cases to
7412      hand back the DECL_INITIAL slot??  */
7413   if (TYPE_SIZE (TREE_TYPE (type)))
7414     {
7415       init = convert_from_reference (decl);
7416       if (TREE_PERMANENT (decl))
7417         init = copy_to_permanent (init);
7418       SET_DECL_REFERENCE_SLOT (decl, init);
7419     }
7420
7421   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7422     {
7423       expand_static_init (decl, DECL_INITIAL (decl));
7424       DECL_INITIAL (decl) = NULL_TREE;
7425     }
7426   return;
7427
7428  fail:
7429   if (TREE_CODE (decl) == VAR_DECL)
7430     SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
7431   return;
7432 }
7433
7434 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7435    mucking with forces it does not comprehend (i.e. initialization with a
7436    constructor).  If we are at global scope and won't go into COMMON, fill
7437    it in with a dummy CONSTRUCTOR to force the variable into .data;
7438    otherwise we can use error_mark_node.  */
7439
7440 static tree
7441 obscure_complex_init (decl, init)
7442      tree decl, init;
7443 {
7444   if (! flag_no_inline && TREE_STATIC (decl))
7445     {
7446       if (extract_init (decl, init))
7447         return NULL_TREE;
7448     }
7449
7450 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7451   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7452     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7453                                  NULL_TREE);
7454   else
7455 #endif
7456     DECL_INITIAL (decl) = error_mark_node;
7457
7458   return init;
7459 }
7460
7461 /* Issue an error message if DECL is an uninitialized const variable.  */
7462
7463 static void
7464 check_for_uninitialized_const_var (decl)
7465      tree decl;
7466 {
7467   tree type = TREE_TYPE (decl);
7468
7469   /* ``Unless explicitly declared extern, a const object does not have
7470      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7471      7.1.6 */
7472   if (TREE_CODE (decl) == VAR_DECL
7473       && TREE_CODE (type) != REFERENCE_TYPE
7474       && CP_TYPE_CONST_P (type)
7475       && !TYPE_NEEDS_CONSTRUCTING (type)
7476       && !DECL_INITIAL (decl))
7477     cp_error ("uninitialized const `%D'", decl);
7478 }
7479
7480 /* Finish processing of a declaration;
7481    install its line number and initial value.
7482    If the length of an array type is not known before,
7483    it must be determined now, from the initial value, or it is an error.
7484
7485    Call `pop_obstacks' iff NEED_POP is nonzero.
7486
7487    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
7488    for aggregates that have constructors alive on the permanent obstack,
7489    so that the global initializing functions can be written at the end.
7490
7491    INIT0 holds the value of an initializer that should be allowed to escape
7492    the normal rules.
7493
7494    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7495    if the (init) syntax was used.
7496
7497    For functions that take default parameters, DECL points to its
7498    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7499    subsequently lower and lower forms of instantiation, checking for
7500    ambiguity as it goes.  This can be sped up later.  */
7501
7502 void
7503 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
7504      tree decl, init;
7505      tree asmspec_tree;
7506      int need_pop;
7507      int flags;
7508 {
7509   register tree type;
7510   tree cleanup = NULL_TREE, ttype = NULL_TREE;
7511   int was_incomplete;
7512   int temporary = allocation_temporary_p ();
7513   char *asmspec = NULL;
7514   int was_readonly = 0;
7515   int already_used = 0;
7516
7517   /* If this is 0, then we did not change obstacks.  */
7518   if (! decl)
7519     {
7520       if (init)
7521         error ("assignment (not initialization) in declaration");
7522       return;
7523     }
7524
7525   /* If a name was specified, get the string.  */
7526   if (asmspec_tree)
7527       asmspec = TREE_STRING_POINTER (asmspec_tree);
7528
7529   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7530     {
7531       cp_error ("Cannot initialize `%D' to namespace `%D'",
7532                 decl, init);
7533       init = NULL_TREE;
7534     }
7535
7536   if (current_class_type
7537       && DECL_REAL_CONTEXT (decl) == current_class_type
7538       && TYPE_BEING_DEFINED (current_class_type)
7539       && (DECL_INITIAL (decl) || init))
7540     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7541
7542   if (TREE_CODE (decl) == VAR_DECL
7543       && DECL_CONTEXT (decl)
7544       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7545       && DECL_CONTEXT (decl) != current_namespace
7546       && init)
7547     {
7548       /* Leave the namespace of the object. */
7549       pop_decl_namespace ();
7550     }
7551
7552   /* If the type of the thing we are declaring either has
7553      a constructor, or has a virtual function table pointer,
7554      AND its initialization was accepted by `start_decl',
7555      then we stayed on the permanent obstack through the
7556      declaration, otherwise, changed obstacks as GCC would.  */
7557
7558   type = TREE_TYPE (decl);
7559
7560   if (type == error_mark_node)
7561     {
7562       if (toplevel_bindings_p () && temporary)
7563         end_temporary_allocation ();
7564
7565       return;
7566     }
7567
7568   if (TYPE_HAS_MUTABLE_P (type))
7569     TREE_READONLY (decl) = 0;
7570
7571   if (processing_template_decl)
7572     {
7573       if (init && DECL_INITIAL (decl))
7574         DECL_INITIAL (decl) = init;
7575       if (minimal_parse_mode && ! DECL_ARTIFICIAL (decl))
7576         {
7577           tree stmt = DECL_VINDEX (decl);
7578           /* If the decl is declaring a member of a local class (in a
7579              template function), the DECL_VINDEX will either be NULL,
7580              or it will be an actual virtual function index, not a
7581              DECL_STMT.  */
7582           if (stmt != NULL_TREE && TREE_CODE (stmt) == DECL_STMT)
7583             {
7584               DECL_VINDEX (decl) = NULL_TREE;
7585               TREE_OPERAND (stmt, 2) = copy_to_permanent (init);
7586               add_tree (stmt);
7587             }
7588         }
7589
7590       goto finish_end0;
7591     }
7592   /* Take care of TYPE_DECLs up front.  */
7593   if (TREE_CODE (decl) == TYPE_DECL)
7594     {
7595       if (init && DECL_INITIAL (decl))
7596         {
7597           /* typedef foo = bar; store the type of bar as the type of foo.  */
7598           TREE_TYPE (decl) = type = TREE_TYPE (init);
7599           DECL_INITIAL (decl) = init = NULL_TREE;
7600         }
7601       if (type != error_mark_node
7602           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7603         {
7604           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7605             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7606           set_identifier_type_value (DECL_NAME (decl), type);
7607           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7608         }
7609       GNU_xref_decl (current_function_decl, decl);
7610
7611       /* If we have installed this as the canonical typedef for this
7612          type, and that type has not been defined yet, delay emitting
7613          the debug information for it, as we will emit it later.  */
7614       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7615           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7616         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7617
7618       rest_of_decl_compilation (decl, NULL_PTR,
7619                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7620       goto finish_end;
7621     }
7622   if (TREE_CODE (decl) != FUNCTION_DECL)
7623     {
7624       ttype = target_type (type);
7625     }
7626
7627   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7628       && TYPE_NEEDS_CONSTRUCTING (type))
7629     {
7630
7631       /* Currently, GNU C++ puts constants in text space, making them
7632          impossible to initialize.  In the future, one would hope for
7633          an operating system which understood the difference between
7634          initialization and the running of a program.  */
7635       was_readonly = 1;
7636       TREE_READONLY (decl) = 0;
7637     }
7638
7639   if (TREE_CODE (decl) == FIELD_DECL)
7640     {
7641       if (init && init != error_mark_node)
7642         my_friendly_assert (TREE_PERMANENT (init), 147);
7643
7644       if (asmspec)
7645         {
7646           /* This must override the asm specifier which was placed
7647              by grokclassfn.  Lay this out fresh.  */
7648           DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7649           DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7650           make_decl_rtl (decl, asmspec, 0);
7651         }
7652     }
7653   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7654   else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7655     init = NULL_TREE;
7656   else if (DECL_EXTERNAL (decl))
7657     ;
7658   else if (TREE_CODE (type) == REFERENCE_TYPE
7659            || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
7660     {
7661       if (TREE_STATIC (decl))
7662         make_decl_rtl (decl, NULL_PTR,
7663                        toplevel_bindings_p ()
7664                        || pseudo_global_level_p ());
7665       grok_reference_init (decl, type, init);
7666       init = NULL_TREE;
7667     }
7668
7669   GNU_xref_decl (current_function_decl, decl);
7670
7671   if (TREE_CODE (decl) == FIELD_DECL)
7672     ;
7673   else if (TREE_CODE (decl) == CONST_DECL)
7674     {
7675       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7676
7677       DECL_INITIAL (decl) = init;
7678
7679       /* This will keep us from needing to worry about our obstacks.  */
7680       my_friendly_assert (init != NULL_TREE, 149);
7681       init = NULL_TREE;
7682     }
7683   else if (init)
7684     {
7685       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7686         {
7687           if (TREE_CODE (type) == ARRAY_TYPE)
7688             init = digest_init (type, init, (tree *) 0);
7689           else if (TREE_CODE (init) == CONSTRUCTOR
7690                    && TREE_HAS_CONSTRUCTOR (init))
7691             {
7692               if (TYPE_NON_AGGREGATE_CLASS (type))
7693                 {
7694                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7695                             decl);
7696                   init = error_mark_node;
7697                 }
7698               else
7699                 goto dont_use_constructor;
7700             }
7701         }
7702       else
7703         {
7704         dont_use_constructor:
7705           if (TREE_CODE (init) != TREE_VEC)
7706             init = store_init_value (decl, init);
7707         }
7708
7709       if (init)
7710         /* We must hide the initializer so that expand_decl
7711            won't try to do something it does not understand.  */
7712         init = obscure_complex_init (decl, init);
7713     }
7714   else if (DECL_EXTERNAL (decl))
7715     ;
7716   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7717            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7718     {
7719       tree ctype = type;
7720       while (TREE_CODE (ctype) == ARRAY_TYPE)
7721         ctype = TREE_TYPE (ctype);
7722       if (! TYPE_NEEDS_CONSTRUCTING (ctype))
7723         {
7724           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
7725             cp_error ("structure `%D' with uninitialized const members", decl);
7726           if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
7727             cp_error ("structure `%D' with uninitialized reference members",
7728                       decl);
7729         }
7730
7731       check_for_uninitialized_const_var (decl);
7732
7733       if (TYPE_SIZE (type) != NULL_TREE
7734           && TYPE_NEEDS_CONSTRUCTING (type))
7735         init = obscure_complex_init (decl, NULL_TREE);
7736
7737     }
7738   else
7739     check_for_uninitialized_const_var (decl);
7740
7741   /* For top-level declaration, the initial value was read in
7742      the temporary obstack.  MAXINDEX, rtl, etc. to be made below
7743      must go in the permanent obstack; but don't discard the
7744      temporary data yet.  */
7745
7746   if (toplevel_bindings_p () && temporary)
7747     end_temporary_allocation ();
7748
7749   /* Deduce size of array from initialization, if not already known.  */
7750
7751   if (TREE_CODE (type) == ARRAY_TYPE
7752       && TYPE_DOMAIN (type) == NULL_TREE
7753       && TREE_CODE (decl) != TYPE_DECL)
7754     {
7755       int do_default
7756         = (TREE_STATIC (decl)
7757            /* Even if pedantic, an external linkage array
7758               may have incomplete type at first.  */
7759            ? pedantic && ! DECL_EXTERNAL (decl)
7760            : !DECL_EXTERNAL (decl));
7761       tree initializer = init ? init : DECL_INITIAL (decl);
7762       int failure = complete_array_type (type, initializer, do_default);
7763
7764       if (failure == 1)
7765         cp_error ("initializer fails to determine size of `%D'", decl);
7766
7767       if (failure == 2)
7768         {
7769           if (do_default)
7770             cp_error ("array size missing in `%D'", decl);
7771           /* If a `static' var's size isn't known, make it extern as
7772              well as static, so it does not get allocated.  If it's not
7773              `static', then don't mark it extern; finish_incomplete_decl
7774              will give it a default size and it will get allocated.  */
7775           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7776             DECL_EXTERNAL (decl) = 1;
7777         }
7778
7779       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7780           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7781                               integer_zero_node))
7782         cp_error ("zero-size array `%D'", decl);
7783
7784       layout_decl (decl, 0);
7785     }
7786
7787   if (TREE_CODE (decl) == VAR_DECL)
7788     {
7789       if (DECL_SIZE (decl) == NULL_TREE
7790           && TYPE_SIZE (complete_type (TREE_TYPE (decl))) != NULL_TREE)
7791         layout_decl (decl, 0);
7792
7793       if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
7794         {
7795           /* A static variable with an incomplete type:
7796              that is an error if it is initialized.
7797              Otherwise, let it through, but if it is not `extern'
7798              then it may cause an error message later.  */
7799           if (DECL_INITIAL (decl) != NULL_TREE)
7800             cp_error ("storage size of `%D' isn't known", decl);
7801           init = NULL_TREE;
7802         }
7803       else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7804         {
7805           /* An automatic variable with an incomplete type: that is an error.
7806              Don't talk about array types here, since we took care of that
7807              message in grokdeclarator.  */
7808           cp_error ("storage size of `%D' isn't known", decl);
7809           TREE_TYPE (decl) = error_mark_node;
7810         }
7811       else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7812         /* Let debugger know it should output info for this type.  */
7813         note_debug_info_needed (ttype);
7814
7815       if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7816         note_debug_info_needed (DECL_CONTEXT (decl));
7817
7818       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7819           && DECL_SIZE (decl) != NULL_TREE
7820           && ! TREE_CONSTANT (DECL_SIZE (decl)))
7821         {
7822           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7823             constant_expression_warning (DECL_SIZE (decl));
7824           else
7825             cp_error ("storage size of `%D' isn't constant", decl);
7826         }
7827
7828       if (! DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type)
7829           /* Cleanups for static variables are handled by `finish_file'.  */
7830           && ! TREE_STATIC (decl))
7831         {
7832           int yes = suspend_momentary ();
7833           cleanup = maybe_build_cleanup (decl);
7834           resume_momentary (yes);
7835         }
7836     }
7837   /* PARM_DECLs get cleanups, too.  */
7838   else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
7839     {
7840       if (temporary)
7841         end_temporary_allocation ();
7842       cleanup = maybe_build_cleanup (decl);
7843       if (temporary)
7844         resume_temporary_allocation ();
7845     }
7846
7847   /* Output the assembler code and/or RTL code for variables and functions,
7848      unless the type is an undefined structure or union.
7849      If not, it will get done when the type is completed.  */
7850
7851   was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
7852
7853   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7854       || TREE_CODE (decl) == RESULT_DECL)
7855     {
7856       /* ??? FIXME: What about nested classes?  */
7857       int toplev = toplevel_bindings_p () || pseudo_global_level_p ();
7858       int was_temp
7859         = (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)
7860            && allocation_temporary_p ());
7861
7862       if (was_temp)
7863         end_temporary_allocation ();
7864
7865       /* Static data in a function with comdat linkage also has comdat
7866          linkage.  */
7867       if (TREE_CODE (decl) == VAR_DECL
7868           && TREE_STATIC (decl)
7869           /* Don't mess with __FUNCTION__.  */
7870           && ! TREE_ASM_WRITTEN (decl)
7871           && current_function_decl
7872           && DECL_CONTEXT (decl) == current_function_decl
7873           && (DECL_THIS_INLINE (current_function_decl)
7874               || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7875           && TREE_PUBLIC (current_function_decl))
7876         {
7877           /* Rather than try to get this right with inlining, we suppress
7878              inlining of such functions.  */
7879           current_function_cannot_inline
7880             = "function with static variable cannot be inline";
7881
7882           /* If flag_weak, we don't need to mess with this, as we can just
7883              make the function weak, and let it refer to its unique local
7884              copy.  This works because we don't allow the function to be
7885              inlined.  */
7886           if (! flag_weak)
7887             {
7888               if (DECL_INTERFACE_KNOWN (current_function_decl))
7889                 {
7890                   TREE_PUBLIC (decl) = 1;
7891                   DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7892                 }
7893               else if (DECL_INITIAL (decl) == NULL_TREE
7894                        || DECL_INITIAL (decl) == error_mark_node)
7895                 {
7896                   TREE_PUBLIC (decl) = 1;
7897                   DECL_COMMON (decl) = 1;
7898                 }
7899               /* else we lose. We can only do this if we can use common,
7900                  which we can't if it has been initialized.  */
7901
7902               if (TREE_PUBLIC (decl))
7903                 DECL_ASSEMBLER_NAME (decl)
7904                   = build_static_name (current_function_decl, DECL_NAME (decl));
7905               else if (! DECL_ARTIFICIAL (decl))
7906                 {
7907                   cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7908                   cp_warning_at ("  you can work around this by removing the initializer"), decl;
7909                 }
7910             }
7911         }
7912
7913       else if (TREE_CODE (decl) == VAR_DECL
7914                && DECL_LANG_SPECIFIC (decl)
7915                && DECL_COMDAT (decl))
7916         /* Set it up again; we might have set DECL_INITIAL since the
7917            last time.  */
7918         comdat_linkage (decl);
7919
7920       if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
7921         make_decl_rtl (decl, NULL_PTR, toplev);
7922       else if (TREE_CODE (decl) == VAR_DECL
7923                && TREE_READONLY (decl)
7924                && DECL_INITIAL (decl) != NULL_TREE
7925                && DECL_INITIAL (decl) != error_mark_node
7926                && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7927         {
7928           DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7929
7930           if (asmspec)
7931             DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7932
7933           if (! toplev
7934               && TREE_STATIC (decl)
7935               && ! TREE_SIDE_EFFECTS (decl)
7936               && ! TREE_PUBLIC (decl)
7937               && ! DECL_EXTERNAL (decl)
7938               && ! TYPE_NEEDS_DESTRUCTOR (type)
7939               && DECL_MODE (decl) != BLKmode)
7940             {
7941               /* If this variable is really a constant, then fill its DECL_RTL
7942                  slot with something which won't take up storage.
7943                  If something later should take its address, we can always give
7944                  it legitimate RTL at that time.  */
7945               DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
7946               store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
7947               TREE_ASM_WRITTEN (decl) = 1;
7948             }
7949           else if (toplev && ! TREE_PUBLIC (decl))
7950             {
7951               /* If this is a static const, change its apparent linkage
7952                  if it belongs to a #pragma interface.  */
7953               if (!interface_unknown)
7954                 {
7955                   TREE_PUBLIC (decl) = 1;
7956                   DECL_EXTERNAL (decl) = interface_only;
7957                 }
7958               make_decl_rtl (decl, asmspec, toplev);
7959             }
7960           else
7961             rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7962         }
7963       else if (TREE_CODE (decl) == VAR_DECL
7964                && DECL_LANG_SPECIFIC (decl)
7965                && DECL_IN_AGGR_P (decl))
7966         {
7967           if (TREE_STATIC (decl))
7968             {
7969               if (init == NULL_TREE
7970 #ifdef DEFAULT_STATIC_DEFS
7971                   /* If this code is dead, then users must
7972                      explicitly declare static member variables
7973                      outside the class def'n as well.  */
7974                   && TYPE_NEEDS_CONSTRUCTING (type)
7975 #endif
7976                   )
7977                 {
7978                   DECL_EXTERNAL (decl) = 1;
7979                   make_decl_rtl (decl, asmspec, 1);
7980                 }
7981               else
7982                 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7983             }
7984           else
7985             /* Just a constant field.  Should not need any rtl.  */
7986             goto finish_end0;
7987         }
7988       else
7989         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7990
7991       if (was_temp)
7992         resume_temporary_allocation ();
7993
7994       if (type != error_mark_node
7995           && TYPE_LANG_SPECIFIC (type)
7996           && CLASSTYPE_ABSTRACT_VIRTUALS (type))
7997         abstract_virtuals_error (decl, type);
7998       else if ((TREE_CODE (type) == FUNCTION_TYPE
7999                 || TREE_CODE (type) == METHOD_TYPE)
8000                && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
8001                && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
8002         abstract_virtuals_error (decl, TREE_TYPE (type));
8003
8004       if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
8005         signature_error (decl, type);
8006       else if ((TREE_CODE (type) == FUNCTION_TYPE
8007                 || TREE_CODE (type) == METHOD_TYPE)
8008                && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
8009                && IS_SIGNATURE (TREE_TYPE (type)))
8010         signature_error (decl, TREE_TYPE (type));
8011
8012       if (TREE_CODE (decl) == FUNCTION_DECL)
8013         ;
8014       else if (DECL_EXTERNAL (decl)
8015                && ! (DECL_LANG_SPECIFIC (decl)
8016                      && DECL_NOT_REALLY_EXTERN (decl)))
8017         {
8018           if (init)
8019             DECL_INITIAL (decl) = init;
8020         }
8021       else if (TREE_STATIC (decl) && type != error_mark_node)
8022         {
8023           /* Cleanups for static variables are handled by `finish_file'.  */
8024           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8025               || TYPE_NEEDS_DESTRUCTOR (type))
8026             expand_static_init (decl, init);
8027         }
8028       else if (! toplev)
8029         {
8030           /* This is a declared decl which must live until the
8031              end of the binding contour.  It may need a cleanup.  */
8032
8033           /* Recompute the RTL of a local array now
8034              if it used to be an incomplete type.  */
8035           if (was_incomplete && ! TREE_STATIC (decl))
8036             {
8037               /* If we used it already as memory, it must stay in memory.  */
8038               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8039               /* If it's still incomplete now, no init will save it.  */
8040               if (DECL_SIZE (decl) == NULL_TREE)
8041                 DECL_INITIAL (decl) = NULL_TREE;
8042               expand_decl (decl);
8043             }
8044           else if (! TREE_ASM_WRITTEN (decl)
8045                    && (TYPE_SIZE (type) != NULL_TREE
8046                        || TREE_CODE (type) == ARRAY_TYPE))
8047             {
8048               /* Do this here, because we did not expand this decl's
8049                  rtl in start_decl.  */
8050               if (DECL_RTL (decl) == NULL_RTX)
8051                 expand_decl (decl);
8052               else if (cleanup)
8053                 {
8054                   /* XXX: Why don't we use decl here?  */
8055                   /* Ans: Because it was already expanded? */
8056                   if (! expand_decl_cleanup (NULL_TREE, cleanup))
8057                     cp_error ("parser lost in parsing declaration of `%D'",
8058                               decl);
8059                   /* Cleanup used up here.  */
8060                   cleanup = NULL_TREE;
8061                 }
8062             }
8063
8064           if (current_binding_level->is_for_scope)
8065             {
8066               struct binding_level *outer
8067                 = current_binding_level->level_chain;
8068
8069               /* Check to see if the same name is already bound at
8070                  the outer level, either because it was directly declared,
8071                  or because a dead for-decl got preserved.  In either case,
8072                  the code would not have been valid under the ARM
8073                  scope rules, so clear is_for_scope for the
8074                  current_binding_level.
8075
8076                  Otherwise, we need to preserve the temp slot for decl
8077                  to last into the outer binding level.  */
8078
8079               tree outer_binding
8080                 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8081
8082               if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8083                   && (TREE_CODE (BINDING_VALUE (outer_binding))
8084                       == VAR_DECL)
8085                   && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8086                 {
8087                   BINDING_VALUE (outer_binding)
8088                     = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8089                   current_binding_level->is_for_scope = 0;
8090                 }
8091               else if (DECL_IN_MEMORY_P (decl))
8092                 preserve_temp_slots (DECL_RTL (decl));
8093             }
8094
8095           expand_start_target_temps ();
8096
8097           if (DECL_SIZE (decl) && type != error_mark_node)
8098             {
8099               /* Compute and store the initial value.  */
8100               expand_decl_init (decl);
8101               already_used = TREE_USED (decl) || TREE_USED (type);
8102
8103               if (init || TYPE_NEEDS_CONSTRUCTING (type))
8104                 {
8105                   emit_line_note (DECL_SOURCE_FILE (decl),
8106                                   DECL_SOURCE_LINE (decl));
8107                   expand_aggr_init (decl, init, flags);
8108                 }
8109
8110               /* Set this to 0 so we can tell whether an aggregate which
8111                  was initialized was ever used.  Don't do this if it has a
8112                  destructor, so we don't complain about the 'resource
8113                  allocation is initialization' idiom.  */
8114               /* Now set attribute((unused)) on types so decls of
8115                  that type will be marked used. (see TREE_USED, above.)
8116                  This avoids the warning problems this particular code
8117                  tried to work around. */
8118
8119               if (TYPE_NEEDS_CONSTRUCTING (type)
8120                   && ! already_used
8121                   && cleanup == NULL_TREE
8122                   && DECL_NAME (decl))
8123                 TREE_USED (decl) = 0;
8124
8125               if (already_used)
8126                 TREE_USED (decl) = 1;
8127             }
8128
8129           /* Cleanup any temporaries needed for the initial value.  */
8130           expand_end_target_temps ();
8131
8132           if (DECL_SIZE (decl) && type != error_mark_node)
8133             {
8134               /* Store the cleanup, if there was one.  */
8135               if (cleanup)
8136                 {
8137                   if (! expand_decl_cleanup (decl, cleanup))
8138                     cp_error ("parser lost in parsing declaration of `%D'",
8139                               decl);
8140                 }
8141             }
8142         }
8143     finish_end0:
8144
8145       /* Undo call to `pushclass' that was done in `start_decl'
8146          due to initialization of qualified member variable.
8147          I.e., Foo::x = 10;  */
8148       {
8149         tree context = DECL_REAL_CONTEXT (decl);
8150         if (context
8151             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
8152             && (TREE_CODE (decl) == VAR_DECL
8153                 /* We also have a pushclass done that we need to undo here
8154                    if we're at top level and declare a method.  */
8155                 || TREE_CODE (decl) == FUNCTION_DECL)
8156             /* If size hasn't been set, we're still defining it,
8157                and therefore inside the class body; don't pop
8158                the binding level..  */
8159             && TYPE_SIZE (context) != NULL_TREE
8160             && context == current_class_type)
8161           popclass (1);
8162       }
8163     }
8164
8165  finish_end:
8166
8167   /* If requested, warn about definitions of large data objects.  */
8168
8169   if (warn_larger_than
8170       && ! processing_template_decl
8171       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
8172       && !DECL_EXTERNAL (decl))
8173     {
8174       register tree decl_size = DECL_SIZE (decl);
8175
8176       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
8177         {
8178           unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
8179
8180           if (units > larger_than_size)
8181             warning_with_decl (decl, "size of `%s' is %u bytes", units);
8182         }
8183     }
8184
8185   if (need_pop)
8186     {
8187       /* Resume permanent allocation, if not within a function.  */
8188       /* The corresponding push_obstacks_nochange is in start_decl,
8189          start_method, groktypename, and in grokfield.  */
8190       pop_obstacks ();
8191     }
8192
8193   if (was_readonly)
8194     TREE_READONLY (decl) = 1;
8195 }
8196
8197 /* This is here for a midend callback from c-common.c */
8198
8199 void
8200 finish_decl (decl, init, asmspec_tree)
8201      tree decl, init;
8202      tree asmspec_tree;
8203 {
8204   cp_finish_decl (decl, init, asmspec_tree, 1, 0);
8205 }
8206
8207 void
8208 expand_static_init (decl, init)
8209      tree decl;
8210      tree init;
8211 {
8212   tree oldstatic = value_member (decl, static_aggregates);
8213
8214   /* If at_eof is 2, we're too late.  */
8215   my_friendly_assert (at_eof <= 1, 990323);
8216
8217   if (oldstatic)
8218     {
8219       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8220         cp_error ("multiple initializations given for `%D'", decl);
8221     }
8222   else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
8223     {
8224       /* Emit code to perform this initialization but once.  */
8225       tree temp;
8226
8227       /* Remember this information until end of file.  */
8228       push_obstacks (&permanent_obstack, &permanent_obstack);
8229
8230       /* Emit code to perform this initialization but once.  This code
8231          looks like:
8232
8233            static int temp = 0;
8234            if (!temp) {
8235              // Do initialization.
8236              temp = 1;
8237              // Register variable for destruction at end of program.
8238            }
8239
8240          Note that the `temp' variable is only set to 1 *after* the
8241          initialization is complete.  This ensures that an exception,
8242          thrown during the construction, will cause the variable to
8243          reinitialized when we pass through this code again, as per:
8244
8245            [stmt.dcl]
8246
8247            If the initialization exits by throwing an exception, the
8248            initialization is not complete, so it will be tried again
8249            the next time control enters the declaration.
8250
8251          In theory, this process should be thread-safe, too; multiple
8252          threads should not be able to initialize the variable more
8253          than once.  We don't yet attempt to ensure thread-safety.  */
8254       temp = get_temp_name (integer_type_node, 1);
8255       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8256
8257       /* Begin the conditional initialization.  */
8258       expand_start_cond (build_binary_op (EQ_EXPR, temp,
8259                                           integer_zero_node, 1), 0);
8260       expand_start_target_temps ();
8261
8262       /* Do the initialization itself.  */
8263       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8264           || (init && TREE_CODE (init) == TREE_LIST))
8265         {
8266           expand_aggr_init (decl, init, 0);
8267           do_pending_stack_adjust ();
8268         }
8269       else if (init)
8270         expand_assignment (decl, init, 0, 0);
8271
8272       /* Set TEMP to 1.  */
8273       expand_assignment (temp, integer_one_node, 0, 0);
8274
8275       /* Cleanup any temporaries needed for the initial value.  If
8276          destroying one of the temporaries causes an exception to be
8277          thrown, then the object itself has still been fully
8278          constructed.  */
8279       expand_end_target_temps ();
8280
8281       /* Use atexit to register a function for destroying this static
8282          variable.  */
8283       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8284         {
8285           tree cleanup, fcall;
8286           static tree Atexit = 0;
8287           if (Atexit == 0)
8288             {
8289               tree atexit_fndecl, PFV, pfvlist;
8290               /* Remember this information until end of file.  */
8291               push_obstacks (&permanent_obstack, &permanent_obstack);
8292               PFV = build_pointer_type (build_function_type
8293                                         (void_type_node, void_list_node));
8294
8295               pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
8296
8297               push_lang_context (lang_name_c);
8298               atexit_fndecl
8299                 = builtin_function ("atexit",
8300                                     build_function_type (void_type_node,
8301                                                          pfvlist),
8302                                     NOT_BUILT_IN, NULL_PTR);
8303               mark_used (atexit_fndecl);
8304               Atexit = default_conversion (atexit_fndecl);
8305               pop_lang_context ();
8306               pop_obstacks ();
8307             }
8308
8309           /* Call build_cleanup before we enter the anonymous function
8310              so that any access checks will be done relative to the
8311              current scope, rather than the scope of the anonymous
8312              function.  */
8313           fcall = build_cleanup (decl);
8314           cleanup = start_anon_func ();
8315           expand_expr_stmt (fcall);
8316           end_anon_func ();
8317           mark_addressable (cleanup);
8318           cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8319           fcall = build_function_call (Atexit, expr_tree_cons (NULL_TREE, cleanup, NULL_TREE));
8320           expand_expr_stmt (fcall);
8321         }
8322
8323       expand_end_cond ();
8324       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8325         {
8326           static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
8327           TREE_STATIC (static_aggregates) = 1;
8328         }
8329
8330       /* Resume old (possibly temporary) allocation.  */
8331       pop_obstacks ();
8332     }
8333   else
8334     {
8335       /* This code takes into account memory allocation
8336          policy of `start_decl'.  Namely, if TYPE_NEEDS_CONSTRUCTING
8337          does not hold for this object, then we must make permanent
8338          the storage currently in the temporary obstack.  */
8339       if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
8340         preserve_initializer ();
8341       static_aggregates = perm_tree_cons (init, decl, static_aggregates);
8342     }
8343 }
8344 \f
8345 /* Make TYPE a complete type based on INITIAL_VALUE.
8346    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8347    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
8348
8349 int
8350 complete_array_type (type, initial_value, do_default)
8351      tree type, initial_value;
8352      int do_default;
8353 {
8354   register tree maxindex = NULL_TREE;
8355   int value = 0;
8356
8357   if (initial_value)
8358     {
8359       /* Note MAXINDEX  is really the maximum index,
8360          one less than the size.  */
8361       if (TREE_CODE (initial_value) == STRING_CST)
8362         {
8363           int eltsize
8364             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8365           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8366                                    / eltsize) - 1, 0);
8367         }
8368       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8369         {
8370           tree elts = CONSTRUCTOR_ELTS (initial_value);
8371           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
8372           for (; elts; elts = TREE_CHAIN (elts))
8373             {
8374               if (TREE_PURPOSE (elts))
8375                 maxindex = TREE_PURPOSE (elts);
8376               else
8377                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
8378             }
8379           maxindex = copy_node (maxindex);
8380         }
8381       else
8382         {
8383           /* Make an error message unless that happened already.  */
8384           if (initial_value != error_mark_node)
8385             value = 1;
8386           else
8387             initial_value = NULL_TREE;
8388
8389           /* Prevent further error messages.  */
8390           maxindex = build_int_2 (0, 0);
8391         }
8392     }
8393
8394   if (!maxindex)
8395     {
8396       if (do_default)
8397         maxindex = build_int_2 (0, 0);
8398       value = 2;
8399     }
8400
8401   if (maxindex)
8402     {
8403       tree itype;
8404
8405       TYPE_DOMAIN (type) = build_index_type (maxindex);
8406       if (! TREE_TYPE (maxindex))
8407         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
8408       if (initial_value)
8409         itype = TREE_TYPE (initial_value);
8410       else
8411         itype = NULL;
8412       if (itype && !TYPE_DOMAIN (itype))
8413         TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
8414       /* The type of the main variant should never be used for arrays
8415          of different sizes.  It should only ever be completed with the
8416          size of the array.  */
8417       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8418         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = TYPE_DOMAIN (type);
8419     }
8420
8421   /* Lay out the type now that we can get the real answer.  */
8422
8423   layout_type (type);
8424
8425   return value;
8426 }
8427 \f
8428 /* Return zero if something is declared to be a member of type
8429    CTYPE when in the context of CUR_TYPE.  STRING is the error
8430    message to print in that case.  Otherwise, quietly return 1.  */
8431
8432 static int
8433 member_function_or_else (ctype, cur_type, string)
8434      tree ctype, cur_type;
8435      const char *string;
8436 {
8437   if (ctype && ctype != cur_type)
8438     {
8439       error (string, TYPE_NAME_STRING (ctype));
8440       return 0;
8441     }
8442   return 1;
8443 }
8444 \f
8445 /* Subroutine of `grokdeclarator'.  */
8446
8447 /* Generate errors possibly applicable for a given set of specifiers.
8448    This is for ARM $7.1.2.  */
8449
8450 static void
8451 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8452      tree object;
8453      const char *type;
8454      int virtualp, quals, friendp, raises, inlinep;
8455 {
8456   if (virtualp)
8457     cp_error ("`%D' declared as a `virtual' %s", object, type);
8458   if (inlinep)
8459     cp_error ("`%D' declared as an `inline' %s", object, type);
8460   if (quals)
8461     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8462               object, type);
8463   if (friendp)
8464     cp_error_at ("invalid friend declaration", object);
8465   if (raises)
8466     cp_error_at ("invalid exception specifications", object);
8467 }
8468
8469 /* CTYPE is class type, or null if non-class.
8470    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8471    or METHOD_TYPE.
8472    DECLARATOR is the function's name.
8473    VIRTUALP is truthvalue of whether the function is virtual or not.
8474    FLAGS are to be passed through to `grokclassfn'.
8475    QUALS are qualifiers indicating whether the function is `const'
8476    or `volatile'.
8477    RAISES is a list of exceptions that this function can raise.
8478    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8479    not look, and -1 if we should not call `grokclassfn' at all.
8480
8481    Returns `NULL_TREE' if something goes wrong, after issuing
8482    applicable error messages.  */
8483
8484 static tree
8485 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8486             raises, attrlist, check, friendp, publicp, inlinep, funcdef_flag,
8487             template_count, in_namespace)
8488      tree ctype, type;
8489      tree declarator;
8490      tree orig_declarator;
8491      int virtualp;
8492      enum overload_flags flags;
8493      tree quals, raises, attrlist;
8494      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8495      tree in_namespace;
8496 {
8497   tree cname, decl;
8498   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8499   tree t;
8500
8501   if (ctype)
8502     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8503       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8504   else
8505     cname = NULL_TREE;
8506
8507   if (raises)
8508     {
8509       type = build_exception_variant (type, raises);
8510     }
8511
8512   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8513   /* Propagate volatile out from type to decl. */
8514   if (TYPE_VOLATILE (type))
8515     TREE_THIS_VOLATILE (decl) = 1;
8516
8517   /* If this decl has namespace scope, set that up.  */
8518   if (in_namespace)
8519     set_decl_namespace (decl, in_namespace, friendp);
8520   else if (publicp && ! ctype)
8521     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8522
8523   /* `main' and builtins have implicit 'C' linkage.  */
8524   if ((MAIN_NAME_P (declarator)
8525        || (IDENTIFIER_LENGTH (declarator) > 10
8526            && IDENTIFIER_POINTER (declarator)[0] == '_'
8527            && IDENTIFIER_POINTER (declarator)[1] == '_'
8528            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8529       && current_lang_name == lang_name_cplusplus
8530       && ctype == NULL_TREE
8531       /* NULL_TREE means global namespace.  */
8532       && DECL_CONTEXT (decl) == NULL_TREE)
8533     DECL_LANGUAGE (decl) = lang_c;
8534
8535   /* Should probably propagate const out from type to decl I bet (mrs).  */
8536   if (staticp)
8537     {
8538       DECL_STATIC_FUNCTION_P (decl) = 1;
8539       DECL_CONTEXT (decl) = ctype;
8540     }
8541
8542   if (ctype)
8543     DECL_CLASS_CONTEXT (decl) = ctype;
8544
8545   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8546     {
8547       if (processing_template_decl)
8548         error ("cannot declare `main' to be a template");
8549       if (inlinep)
8550         error ("cannot declare `main' to be inline");
8551       else if (! publicp)
8552         error ("cannot declare `main' to be static");
8553       inlinep = 0;
8554       publicp = 1;
8555     }
8556
8557   /* Members of anonymous types and local classes have no linkage; make
8558      them internal.  */
8559   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8560                 || hack_decl_function_context (TYPE_MAIN_DECL (ctype))))
8561     publicp = 0;
8562
8563   if (publicp)
8564     {
8565       /* [basic.link]: A name with no linkage (notably, the name of a class
8566          or enumeration declared in a local scope) shall not be used to
8567          declare an entity with linkage.
8568
8569          Only check this for public decls for now.  */
8570       t = no_linkage_check (TREE_TYPE (decl));
8571       if (t)
8572         {
8573           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8574             {
8575               if (DECL_LANGUAGE (decl) == lang_c)
8576                 /* Allow this; it's pretty common in C.  */;
8577               else
8578                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8579                             decl);
8580             }
8581           else
8582             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8583                         decl, t);
8584         }
8585     }
8586
8587   TREE_PUBLIC (decl) = publicp;
8588   if (! publicp)
8589     {
8590       DECL_INTERFACE_KNOWN (decl) = 1;
8591       DECL_NOT_REALLY_EXTERN (decl) = 1;
8592     }
8593
8594   if (inlinep)
8595     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8596
8597   DECL_EXTERNAL (decl) = 1;
8598   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8599     {
8600       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8601                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8602       quals = NULL_TREE;
8603     }
8604
8605   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8606     grok_op_properties (decl, virtualp, check < 0);
8607
8608   if (ctype && hack_decl_function_context (decl))
8609     DECL_NO_STATIC_CHAIN (decl) = 1;
8610
8611   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8612     if (TREE_PURPOSE (t)
8613         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8614       {
8615         add_defarg_fn (decl);
8616         break;
8617       }
8618
8619   if (friendp
8620       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8621     {
8622       if (funcdef_flag)
8623         cp_error
8624           ("defining explicit specialization `%D' in friend declaration",
8625            orig_declarator);
8626       else
8627         {
8628           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8629             {
8630               /* Something like `template <class T> friend void f<T>()'.  */
8631               cp_error ("template-id `%D' in declaration of primary template",
8632                         orig_declarator);
8633               return NULL_TREE;
8634             }
8635
8636           /* A friend declaration of the form friend void f<>().  Record
8637              the information in the TEMPLATE_ID_EXPR.  */
8638           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8639           DECL_TEMPLATE_INFO (decl)
8640             = perm_tree_cons (TREE_OPERAND (orig_declarator, 0),
8641                               TREE_OPERAND (orig_declarator, 1),
8642                               NULL_TREE);
8643         }
8644     }
8645
8646   /* Plain overloading: will not be grok'd by grokclassfn.  */
8647   if (! ctype && ! processing_template_decl
8648       && DECL_LANGUAGE (decl) != lang_c
8649       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8650     set_mangled_name_for_decl (decl);
8651
8652   if (funcdef_flag)
8653     /* Make the init_value nonzero so pushdecl knows this is not
8654        tentative.  error_mark_node is replaced later with the BLOCK.  */
8655     DECL_INITIAL (decl) = error_mark_node;
8656
8657   /* Caller will do the rest of this.  */
8658   if (check < 0)
8659     return decl;
8660
8661   if (check && funcdef_flag)
8662     DECL_INITIAL (decl) = error_mark_node;
8663
8664   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8665     {
8666       tree tmp;
8667       /* Just handle constructors here.  We could do this
8668          inside the following if stmt, but I think
8669          that the code is more legible by breaking this
8670          case out.  See comments below for what each of
8671          the following calls is supposed to do.  */
8672       DECL_CONSTRUCTOR_P (decl) = 1;
8673
8674       grokclassfn (ctype, decl, flags, quals);
8675
8676       decl = check_explicit_specialization (orig_declarator, decl,
8677                                             template_count,
8678                                             2 * (funcdef_flag != 0) +
8679                                             4 * (friendp != 0));
8680       if (decl == error_mark_node)
8681         return NULL_TREE;
8682
8683       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8684           && check)
8685         {
8686           tmp = check_classfn (ctype, decl);
8687
8688           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8689             tmp = DECL_TEMPLATE_RESULT(tmp);
8690
8691           if (tmp && DECL_ARTIFICIAL (tmp))
8692             cp_error ("definition of implicitly-declared `%D'", tmp);
8693           if (tmp && duplicate_decls (decl, tmp))
8694             return tmp;
8695         }
8696       if (! grok_ctor_properties (ctype, decl))
8697         return NULL_TREE;
8698     }
8699   else
8700     {
8701       tree tmp;
8702
8703       /* Function gets the ugly name, field gets the nice one.
8704          This call may change the type of the function (because
8705          of default parameters)!  */
8706       if (ctype != NULL_TREE)
8707         grokclassfn (ctype, decl, flags, quals);
8708
8709       decl = check_explicit_specialization (orig_declarator, decl,
8710                                             template_count,
8711                                             2 * (funcdef_flag != 0) +
8712                                             4 * (friendp != 0));
8713       if (decl == error_mark_node)
8714         return NULL_TREE;
8715
8716       if (ctype != NULL_TREE
8717           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8718           && check)
8719         {
8720           tmp = check_classfn (ctype, decl);
8721
8722           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8723             tmp = DECL_TEMPLATE_RESULT (tmp);
8724
8725           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8726               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8727             {
8728               /* Remove the `this' parm added by grokclassfn.
8729                  XXX Isn't this done in start_function, too?  */
8730               revert_static_member_fn (&decl, NULL, NULL);
8731               last_function_parms = TREE_CHAIN (last_function_parms);
8732             }
8733           if (tmp && DECL_ARTIFICIAL (tmp))
8734             cp_error ("definition of implicitly-declared `%D'", tmp);
8735           if (tmp)
8736             {
8737               /* Attempt to merge the declarations.  This can fail, in
8738                  the case of some illegal specialization declarations.  */
8739               if (!duplicate_decls (decl, tmp))
8740                 cp_error ("no `%#D' member function declared in class `%T'",
8741                           decl, ctype);
8742               return tmp;
8743             }
8744         }
8745
8746       if (ctype == NULL_TREE || check)
8747         return decl;
8748
8749       if (attrlist)
8750         cplus_decl_attributes (decl, TREE_PURPOSE (attrlist),
8751                                TREE_VALUE (attrlist));
8752       make_decl_rtl (decl, NULL_PTR, 1);
8753
8754       if (virtualp)
8755         {
8756           DECL_VIRTUAL_P (decl) = 1;
8757           if (DECL_VINDEX (decl) == NULL_TREE)
8758             DECL_VINDEX (decl) = error_mark_node;
8759           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8760         }
8761     }
8762   return decl;
8763 }
8764
8765 static tree
8766 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8767      tree type;
8768      tree declarator;
8769      RID_BIT_TYPE *specbits_in;
8770      int initialized;
8771      int constp;
8772      tree in_namespace;
8773 {
8774   tree decl;
8775   RID_BIT_TYPE specbits;
8776
8777   specbits = *specbits_in;
8778
8779   if (TREE_CODE (type) == OFFSET_TYPE)
8780     {
8781       /* If you declare a static member so that it
8782          can be initialized, the code will reach here.  */
8783       tree basetype = TYPE_OFFSET_BASETYPE (type);
8784       type = TREE_TYPE (type);
8785       decl = build_lang_field_decl (VAR_DECL, declarator, type);
8786       DECL_CONTEXT (decl) = basetype;
8787       DECL_CLASS_CONTEXT (decl) = basetype;
8788       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8789     }
8790   else
8791     {
8792       tree context;
8793
8794       if (in_namespace)
8795         context = in_namespace;
8796       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8797         context = current_namespace;
8798       else
8799         context = NULL_TREE;
8800
8801       decl = build_decl (VAR_DECL, declarator, complete_type (type));
8802
8803       if (context)
8804         set_decl_namespace (decl, context, 0);
8805
8806       context = DECL_CONTEXT (decl);
8807       if (declarator && context && current_lang_name != lang_name_c)
8808         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8809     }
8810
8811   if (in_namespace)
8812     set_decl_namespace (decl, in_namespace, 0);
8813
8814   if (RIDBIT_SETP (RID_EXTERN, specbits))
8815     {
8816       DECL_THIS_EXTERN (decl) = 1;
8817       DECL_EXTERNAL (decl) = !initialized;
8818     }
8819
8820   /* In class context, static means one per class,
8821      public access, and static storage.  */
8822   if (DECL_CLASS_SCOPE_P (decl))
8823     {
8824       TREE_PUBLIC (decl) = 1;
8825       TREE_STATIC (decl) = 1;
8826       DECL_EXTERNAL (decl) = 0;
8827     }
8828   /* At top level, either `static' or no s.c. makes a definition
8829      (perhaps tentative), and absence of `static' makes it public.  */
8830   else if (toplevel_bindings_p ())
8831     {
8832       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8833                             && (DECL_THIS_EXTERN (decl) || ! constp));
8834       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8835     }
8836   /* Not at top level, only `static' makes a static definition.  */
8837   else
8838     {
8839       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8840       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8841     }
8842
8843   if (TREE_PUBLIC (decl))
8844     {
8845       /* [basic.link]: A name with no linkage (notably, the name of a class
8846          or enumeration declared in a local scope) shall not be used to
8847          declare an entity with linkage.
8848
8849          Only check this for public decls for now.  */
8850       tree t = no_linkage_check (TREE_TYPE (decl));
8851       if (t)
8852         {
8853           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8854             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8855           else
8856             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8857                         decl, t);
8858         }
8859     }
8860
8861   return decl;
8862 }
8863
8864 /* Create and return a canonical pointer to member function type, for
8865    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8866
8867 tree
8868 build_ptrmemfunc_type (type)
8869      tree type;
8870 {
8871   tree fields[4];
8872   tree t;
8873   tree u;
8874
8875   /* If a canonical type already exists for this type, use it.  We use
8876      this method instead of type_hash_canon, because it only does a
8877      simple equality check on the list of field members.  */
8878
8879   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8880     return t;
8881
8882   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
8883
8884   u = make_lang_type (UNION_TYPE);
8885   SET_IS_AGGR_TYPE (u, 0);
8886   fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
8887   fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
8888                                      delta_type_node);
8889   finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8890   TYPE_NAME (u) = NULL_TREE;
8891
8892   t = make_lang_type (RECORD_TYPE);
8893
8894   /* Let the front-end know this is a pointer to member function...  */
8895   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8896   /* ... and not really an aggregate.  */
8897   SET_IS_AGGR_TYPE (t, 0);
8898
8899   fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
8900                                      delta_type_node);
8901   fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
8902                                      delta_type_node);
8903   fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8904   finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8905
8906   pop_obstacks ();
8907
8908   /* Zap out the name so that the back-end will give us the debugging
8909      information for this anonymous RECORD_TYPE.  */
8910   TYPE_NAME (t) = NULL_TREE;
8911
8912   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8913
8914   /* Seems to be wanted.  */
8915   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8916   return t;
8917 }
8918
8919 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8920    Check to see that the definition is valid.  Issue appropriate error
8921    messages.  Return 1 if the definition is particularly bad, or 0
8922    otherwise.  */
8923
8924 int
8925 check_static_variable_definition (decl, type)
8926      tree decl;
8927      tree type;
8928 {
8929   /* Motion 10 at San Diego: If a static const integral data member is
8930      initialized with an integral constant expression, the initializer
8931      may appear either in the declaration (within the class), or in
8932      the definition, but not both.  If it appears in the class, the
8933      member is a member constant.  The file-scope definition is always
8934      required.  */
8935   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8936     {
8937       cp_error ("in-class initialization of static data member of non-integral type `%T'",
8938                 type);
8939       /* If we just return the declaration, crashes will sometimes
8940          occur.  We therefore return void_type_node, as if this was a
8941          friend declaration, to cause callers to completely ignore
8942          this declaration.  */
8943       return 1;
8944     }
8945   else if (!CP_TYPE_CONST_P (type))
8946     cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8947               decl);
8948   else if (pedantic && !INTEGRAL_TYPE_P (type))
8949     cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8950
8951   return 0;
8952 }
8953
8954 /* Given declspecs and a declarator,
8955    determine the name and type of the object declared
8956    and construct a ..._DECL node for it.
8957    (In one case we can return a ..._TYPE node instead.
8958     For invalid input we sometimes return 0.)
8959
8960    DECLSPECS is a chain of tree_list nodes whose value fields
8961     are the storage classes and type specifiers.
8962
8963    DECL_CONTEXT says which syntactic context this declaration is in:
8964      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8965      FUNCDEF for a function definition.  Like NORMAL but a few different
8966       error messages in each case.  Return value may be zero meaning
8967       this definition is too screwy to try to parse.
8968      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
8969       handle member functions (which have FIELD context).
8970       Return value may be zero meaning this definition is too screwy to
8971       try to parse.
8972      PARM for a parameter declaration (either within a function prototype
8973       or before a function body).  Make a PARM_DECL, or return void_type_node.
8974      CATCHPARM for a parameter declaration before a catch clause.
8975      TYPENAME if for a typename (in a cast or sizeof).
8976       Don't make a DECL node; just return the ..._TYPE node.
8977      FIELD for a struct or union field; make a FIELD_DECL.
8978      BITFIELD for a field with specified width.
8979    INITIALIZED is 1 if the decl has an initializer.
8980
8981    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
8982    normal attributes in TREE_PURPOSE, or NULL_TREE.
8983
8984    In the TYPENAME case, DECLARATOR is really an absolute declarator.
8985    It may also be so in the PARM case, for a prototype where the
8986    argument type is specified but not the name.
8987
8988    This function is where the complicated C meanings of `static'
8989    and `extern' are interpreted.
8990
8991    For C++, if there is any monkey business to do, the function which
8992    calls this one must do it, i.e., prepending instance variables,
8993    renaming overloaded function names, etc.
8994
8995    Note that for this C++, it is an error to define a method within a class
8996    which does not belong to that class.
8997
8998    Except in the case where SCOPE_REFs are implicitly known (such as
8999    methods within a class being redundantly qualified),
9000    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9001    (class_name::decl_name).  The caller must also deal with this.
9002
9003    If a constructor or destructor is seen, and the context is FIELD,
9004    then the type gains the attribute TREE_HAS_x.  If such a declaration
9005    is erroneous, NULL_TREE is returned.
9006
9007    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9008    function, these are the qualifiers to give to the `this' pointer.
9009
9010    May return void_type_node if the declarator turned out to be a friend.
9011    See grokfield for details.  */
9012
9013 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9014
9015 tree
9016 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9017      tree declspecs;
9018      tree declarator;
9019      enum decl_context decl_context;
9020      int initialized;
9021      tree attrlist;
9022 {
9023   RID_BIT_TYPE specbits;
9024   int nclasses = 0;
9025   tree spec;
9026   tree type = NULL_TREE;
9027   int longlong = 0;
9028   int constp;
9029   int restrictp;
9030   int volatilep;
9031   int type_quals;
9032   int virtualp, explicitp, friendp, inlinep, staticp;
9033   int explicit_int = 0;
9034   int explicit_char = 0;
9035   int defaulted_int = 0;
9036   int opaque_typedef = 0;
9037   tree typedef_decl = NULL_TREE;
9038   char *name;
9039   tree typedef_type = NULL_TREE;
9040   int funcdef_flag = 0;
9041   enum tree_code innermost_code = ERROR_MARK;
9042   int bitfield = 0;
9043 #if 0
9044   /* See the code below that used this.  */
9045   tree decl_machine_attr = NULL_TREE;
9046 #endif
9047   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9048      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9049   tree init = NULL_TREE;
9050
9051   /* Keep track of what sort of function is being processed
9052      so that we can warn about default return values, or explicit
9053      return values which do not match prescribed defaults.  */
9054   enum return_types return_type = return_normal;
9055
9056   tree dname = NULL_TREE;
9057   tree ctype = current_class_type;
9058   tree ctor_return_type = NULL_TREE;
9059   enum overload_flags flags = NO_SPECIAL;
9060   tree quals = NULL_TREE;
9061   tree raises = NULL_TREE;
9062   int template_count = 0;
9063   tree in_namespace = NULL_TREE;
9064   tree inner_attrs;
9065   int ignore_attrs;
9066
9067   RIDBIT_RESET_ALL (specbits);
9068   if (decl_context == FUNCDEF)
9069     funcdef_flag = 1, decl_context = NORMAL;
9070   else if (decl_context == MEMFUNCDEF)
9071     funcdef_flag = -1, decl_context = FIELD;
9072   else if (decl_context == BITFIELD)
9073     bitfield = 1, decl_context = FIELD;
9074
9075   /* Look inside a declarator for the name being declared
9076      and get it as a string, for an error message.  */
9077   {
9078     tree *next = &declarator;
9079     register tree decl;
9080     name = NULL;
9081
9082     while (next && *next)
9083       {
9084         decl = *next;
9085         switch (TREE_CODE (decl))
9086           {
9087           case TREE_LIST:
9088             /* For attributes.  */
9089             next = &TREE_VALUE (decl);
9090             break;
9091
9092           case COND_EXPR:
9093             ctype = NULL_TREE;
9094             next = &TREE_OPERAND (decl, 0);
9095             break;
9096
9097           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9098             {
9099               tree name = TREE_OPERAND (decl, 0);
9100               tree rename = NULL_TREE;
9101
9102               my_friendly_assert (flags == NO_SPECIAL, 152);
9103               flags = DTOR_FLAG;
9104               return_type = return_dtor;
9105               if (TREE_CODE (name) == TYPE_DECL)
9106                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9107               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9108               if (ctype == NULL_TREE)
9109                 {
9110                   if (current_class_type == NULL_TREE)
9111                     {
9112                       error ("destructors must be member functions");
9113                       flags = NO_SPECIAL;
9114                     }
9115                   else
9116                     {
9117                       tree t = constructor_name (current_class_name);
9118                       if (t != name)
9119                         rename = t;
9120                     }
9121                 }
9122               else
9123                 {
9124                   tree t = constructor_name (ctype);
9125                   if (t != name)
9126                     rename = t;
9127                 }
9128
9129               if (rename)
9130                 {
9131                   cp_error ("destructor `%T' must match class name `%T'",
9132                             name, rename);
9133                   TREE_OPERAND (decl, 0) = rename;
9134                 }
9135               next = &name;
9136             }
9137             break;
9138
9139           case ADDR_EXPR:       /* C++ reference declaration */
9140             /* Fall through. */
9141           case ARRAY_REF:
9142           case INDIRECT_REF:
9143             ctype = NULL_TREE;
9144             innermost_code = TREE_CODE (decl);
9145             next = &TREE_OPERAND (decl, 0);
9146             break;
9147
9148           case CALL_EXPR:
9149             if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
9150               {
9151                 /* This is actually a variable declaration using
9152                    constructor syntax.  We need to call start_decl and
9153                    cp_finish_decl so we can get the variable
9154                    initialized...  */
9155
9156                 tree attributes, prefix_attributes;
9157
9158                 *next = TREE_OPERAND (decl, 0);
9159                 init = TREE_OPERAND (decl, 1);
9160
9161                 if (attrlist)
9162                   {
9163                     attributes = TREE_PURPOSE (attrlist);
9164                     prefix_attributes = TREE_VALUE (attrlist);
9165                   }
9166                 else
9167                   {
9168                     attributes = NULL_TREE;
9169                     prefix_attributes = NULL_TREE;
9170                   }
9171
9172                 decl = start_decl (declarator, declspecs, 1,
9173                                    attributes, prefix_attributes);
9174                 if (decl)
9175                   {
9176                     /* Look for __unused__ attribute */
9177                     if (TREE_USED (TREE_TYPE (decl)))
9178                       TREE_USED (decl) = 1;
9179                     finish_decl (decl, init, NULL_TREE);
9180                   }
9181                 else
9182                   cp_error ("invalid declarator");
9183                 return 0;
9184               }
9185             innermost_code = TREE_CODE (decl);
9186             if (decl_context == FIELD && ctype == NULL_TREE)
9187               ctype = current_class_type;
9188             if (ctype
9189                 && TREE_OPERAND (decl, 0)
9190                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9191                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9192                          == constructor_name_full (ctype))
9193                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9194                             == constructor_name (ctype)))))
9195               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9196             next = &TREE_OPERAND (decl, 0);
9197             decl = *next;
9198             if (ctype != NULL_TREE
9199                 && decl != NULL_TREE && flags != DTOR_FLAG
9200                 && decl == constructor_name (ctype))
9201               {
9202                 return_type = return_ctor;
9203                 ctor_return_type = ctype;
9204               }
9205             ctype = NULL_TREE;
9206             break;
9207
9208           case TEMPLATE_ID_EXPR:
9209               {
9210                 tree fns = TREE_OPERAND (decl, 0);
9211
9212                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9213                   fns = TREE_OPERAND (fns, 0);
9214
9215                 dname = fns;
9216                 if (TREE_CODE (dname) == COMPONENT_REF)
9217                   dname = TREE_OPERAND (dname, 1);
9218                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9219                   {
9220                     my_friendly_assert (is_overloaded_fn (dname),
9221                                         19990331);
9222                     dname = DECL_NAME (get_first_fn (dname));
9223                   }
9224               }
9225           /* Fall through. */
9226
9227           case IDENTIFIER_NODE:
9228             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9229               dname = decl;
9230
9231             next = 0;
9232
9233             if (is_rid (dname))
9234               {
9235                 cp_error ("declarator-id missing; using reserved word `%D'",
9236                           dname);
9237                 name = IDENTIFIER_POINTER (dname);
9238               }
9239             if (! IDENTIFIER_OPNAME_P (dname)
9240                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9241                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9242               name = IDENTIFIER_POINTER (dname);
9243             else
9244               {
9245                 if (IDENTIFIER_TYPENAME_P (dname))
9246                   {
9247                     my_friendly_assert (flags == NO_SPECIAL, 154);
9248                     flags = TYPENAME_FLAG;
9249                     ctor_return_type = TREE_TYPE (dname);
9250                     return_type = return_conversion;
9251                   }
9252                 name = operator_name_string (dname);
9253               }
9254             break;
9255
9256             /* C++ extension */
9257           case SCOPE_REF:
9258             {
9259               /* Perform error checking, and decide on a ctype.  */
9260               tree cname = TREE_OPERAND (decl, 0);
9261               if (cname == NULL_TREE)
9262                 ctype = NULL_TREE;
9263               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9264                 {
9265                   ctype = NULL_TREE;
9266                   in_namespace = TREE_OPERAND (decl, 0);
9267                   TREE_OPERAND (decl, 0) = NULL_TREE;
9268                 }
9269               else if (! is_aggr_type (cname, 1))
9270                 TREE_OPERAND (decl, 0) = NULL_TREE;
9271               /* Must test TREE_OPERAND (decl, 1), in case user gives
9272                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9273               else if (TREE_OPERAND (decl, 1)
9274                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9275                 ctype = cname;
9276               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9277                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9278                 {
9279                   cp_error ("`%T::%D' is not a valid declarator", cname,
9280                             TREE_OPERAND (decl, 1));
9281                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9282                             cname, TREE_OPERAND (decl, 1));
9283                   return void_type_node;
9284                 }
9285               else if (ctype == NULL_TREE)
9286                 ctype = cname;
9287               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9288                 TREE_OPERAND (decl, 0) = ctype;
9289               else
9290                 {
9291                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9292                     {
9293                       cp_error ("type `%T' is not derived from type `%T'",
9294                                 cname, ctype);
9295                       TREE_OPERAND (decl, 0) = NULL_TREE;
9296                     }
9297                   else
9298                     ctype = cname;
9299                 }
9300
9301               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9302                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9303                        == constructor_name_full (ctype))
9304                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9305                           == constructor_name (ctype))))
9306                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9307               next = &TREE_OPERAND (decl, 1);
9308               decl = *next;
9309               if (ctype)
9310                 {
9311                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9312                       && constructor_name (ctype) == decl)
9313                     {
9314                       return_type = return_ctor;
9315                       ctor_return_type = ctype;
9316                     }
9317                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9318                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9319                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9320                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9321                     {
9322                       return_type = return_dtor;
9323                       ctor_return_type = ctype;
9324                       flags = DTOR_FLAG;
9325                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9326                       next = &TREE_OPERAND (decl, 0);
9327                     }
9328                 }
9329             }
9330             break;
9331
9332           case ERROR_MARK:
9333             next = 0;
9334             break;
9335
9336           case TYPE_DECL:
9337             /* Parse error puts this typespec where
9338                a declarator should go.  */
9339             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9340             if (TREE_TYPE (decl) == current_class_type)
9341               cp_error ("  perhaps you want `%T' for a constructor",
9342                         current_class_name);
9343             dname = DECL_NAME (decl);
9344             name = IDENTIFIER_POINTER (dname);
9345
9346             /* Avoid giving two errors for this.  */
9347             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9348
9349             declspecs = temp_tree_cons (NULL_TREE, integer_type_node,
9350                                         declspecs);
9351             *next = dname;
9352             next = 0;
9353             break;
9354
9355           default:
9356             cp_compiler_error ("`%D' as declarator", decl);
9357             return 0; /* We used to do a 155 abort here.  */
9358           }
9359       }
9360     if (name == NULL)
9361       name = "type name";
9362   }
9363
9364   /* A function definition's declarator must have the form of
9365      a function declarator.  */
9366
9367   if (funcdef_flag && innermost_code != CALL_EXPR)
9368     return 0;
9369
9370   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9371       && innermost_code != CALL_EXPR
9372       && ! (ctype && declspecs == NULL_TREE))
9373     {
9374       cp_error ("declaration of `%D' as non-function", dname);
9375       return void_type_node;
9376     }
9377
9378   /* Anything declared one level down from the top level
9379      must be one of the parameters of a function
9380      (because the body is at least two levels down).  */
9381
9382   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9383      by not allowing C++ class definitions to specify their parameters
9384      with xdecls (must be spec.d in the parmlist).
9385
9386      Since we now wait to push a class scope until we are sure that
9387      we are in a legitimate method context, we must set oldcname
9388      explicitly (since current_class_name is not yet alive).
9389
9390      We also want to avoid calling this a PARM if it is in a namespace.  */
9391
9392   if (decl_context == NORMAL && ! namespace_bindings_p ()
9393       && ! pseudo_global_level_p ())
9394     {
9395       struct binding_level *b = current_binding_level;
9396       current_binding_level = b->level_chain;
9397       if (current_binding_level != 0 && toplevel_bindings_p ())
9398         decl_context = PARM;
9399       current_binding_level = b;
9400     }
9401
9402   /* Look through the decl specs and record which ones appear.
9403      Some typespecs are defined as built-in typenames.
9404      Others, the ones that are modifiers of other types,
9405      are represented by bits in SPECBITS: set the bits for
9406      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9407
9408      If there is a typedef name or a type, store the type in TYPE.
9409      This includes builtin typedefs such as `int'.
9410
9411      Set EXPLICIT_INT if the type is `int' or `char' and did not
9412      come from a user typedef.
9413
9414      Set LONGLONG if `long' is mentioned twice.
9415
9416      For C++, constructors and destructors have their own fast treatment.  */
9417
9418   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9419     {
9420       register int i;
9421       register tree id;
9422
9423       /* Certain parse errors slip through.  For example,
9424          `int class;' is not caught by the parser. Try
9425          weakly to recover here.  */
9426       if (TREE_CODE (spec) != TREE_LIST)
9427         return 0;
9428
9429       id = TREE_VALUE (spec);
9430
9431       if (TREE_CODE (id) == IDENTIFIER_NODE)
9432         {
9433           if (id == ridpointers[(int) RID_INT]
9434               || id == ridpointers[(int) RID_CHAR]
9435               || id == ridpointers[(int) RID_BOOL]
9436               || id == ridpointers[(int) RID_WCHAR])
9437             {
9438               if (type)
9439                 {
9440                   if (id == ridpointers[(int) RID_BOOL])
9441                     error ("`bool' is now a keyword");
9442                   else
9443                     cp_error ("extraneous `%T' ignored", id);
9444                 }
9445               else
9446                 {
9447                   if (id == ridpointers[(int) RID_INT])
9448                     explicit_int = 1;
9449                   else if (id == ridpointers[(int) RID_CHAR])
9450                     explicit_char = 1;
9451                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9452                 }
9453               goto found;
9454             }
9455           /* C++ aggregate types.  */
9456           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9457             {
9458               if (type)
9459                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9460               else
9461                 type = IDENTIFIER_TYPE_VALUE (id);
9462               goto found;
9463             }
9464
9465           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9466             {
9467               if (ridpointers[i] == id)
9468                 {
9469                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9470                     {
9471                       if (pedantic && ! in_system_header && warn_long_long)
9472                         pedwarn ("ANSI C++ does not support `long long'");
9473                       if (longlong)
9474                         error ("`long long long' is too long for GCC");
9475                       else
9476                         longlong = 1;
9477                     }
9478                   else if (RIDBIT_SETP (i, specbits))
9479                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9480                   RIDBIT_SET (i, specbits);
9481                   goto found;
9482                 }
9483             }
9484         }
9485       /* C++ aggregate types.  */
9486       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9487         {
9488           if (type)
9489             cp_error ("multiple declarations `%T' and `%T'", type,
9490                       TREE_TYPE (id));
9491           else
9492             {
9493               type = TREE_TYPE (id);
9494               TREE_VALUE (spec) = type;
9495             }
9496           goto found;
9497         }
9498       if (type)
9499         error ("two or more data types in declaration of `%s'", name);
9500       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9501         {
9502           register tree t = lookup_name (id, 1);
9503           if (!t || TREE_CODE (t) != TYPE_DECL)
9504             error ("`%s' fails to be a typedef or built in type",
9505                    IDENTIFIER_POINTER (id));
9506           else
9507             {
9508               type = TREE_TYPE (t);
9509 #if 0
9510               /* See the code below that used this.  */
9511               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9512 #endif
9513               typedef_decl = t;
9514             }
9515         }
9516       else if (id != error_mark_node)
9517         /* Can't change CLASS nodes into RECORD nodes here!  */
9518         type = id;
9519
9520     found: ;
9521     }
9522
9523   typedef_type = type;
9524
9525   /* No type at all: default to `int', and set DEFAULTED_INT
9526      because it was not a user-defined typedef.
9527      Except when we have a `typedef' inside a signature, in
9528      which case the type defaults to `unknown type' and is
9529      instantiated when assigning to a signature pointer or ref.  */
9530
9531   if (type == NULL_TREE
9532       && (RIDBIT_SETP (RID_SIGNED, specbits)
9533           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9534           || RIDBIT_SETP (RID_LONG, specbits)
9535           || RIDBIT_SETP (RID_SHORT, specbits)))
9536     {
9537       /* These imply 'int'.  */
9538       type = integer_type_node;
9539       defaulted_int = 1;
9540     }
9541
9542   if (type == NULL_TREE)
9543     {
9544       explicit_int = -1;
9545       if (return_type == return_dtor)
9546         type = void_type_node;
9547       else if (return_type == return_ctor)
9548         type = build_pointer_type (ctor_return_type);
9549       else if (return_type == return_conversion)
9550         type = ctor_return_type;
9551       else if (current_class_type
9552                && IS_SIGNATURE (current_class_type)
9553                && RIDBIT_SETP (RID_TYPEDEF, specbits)
9554                && (decl_context == FIELD || decl_context == NORMAL))
9555         {
9556           explicit_int = 0;
9557           opaque_typedef = 1;
9558           type = copy_node (opaque_type_node);
9559         }
9560       else
9561         {
9562           /* We handle `main' specially here, because 'main () { }' is so
9563              common.  With no options, it is allowed.  With -Wreturn-type,
9564              it is a warning.  It is only an error with -pedantic-errors.  */
9565           int is_main = (funcdef_flag
9566                          && MAIN_NAME_P (dname)
9567                          && ctype == NULL_TREE
9568                          && in_namespace == NULL_TREE
9569                          && current_namespace == global_namespace);
9570
9571           if (in_system_header)
9572             /* Allow it, sigh.  */;
9573           else if (pedantic || ! is_main)
9574             cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9575                         dname);
9576           else if (warn_return_type)
9577             cp_warning ("ANSI C++ forbids declaration `%D' with no type",
9578                         dname);
9579
9580           type = integer_type_node;
9581         }
9582     }
9583   else if (return_type == return_dtor)
9584     {
9585       error ("return type specification for destructor invalid");
9586       type = void_type_node;
9587     }
9588   else if (return_type == return_ctor)
9589     {
9590       error ("return type specification for constructor invalid");
9591       type = build_pointer_type (ctor_return_type);
9592     }
9593   else if (return_type == return_conversion)
9594     {
9595       if (!same_type_p (type, ctor_return_type))
9596         cp_error ("operator `%T' declared to return `%T'",
9597                   ctor_return_type, type);
9598       else
9599         cp_pedwarn ("return type specified for `operator %T'",
9600                     ctor_return_type);
9601
9602       type = ctor_return_type;
9603     }
9604
9605   ctype = NULL_TREE;
9606
9607   /* Now process the modifiers that were specified
9608      and check for invalid combinations.  */
9609
9610   /* Long double is a special combination.  */
9611
9612   if (RIDBIT_SETP (RID_LONG, specbits)
9613       && TYPE_MAIN_VARIANT (type) == double_type_node)
9614     {
9615       RIDBIT_RESET (RID_LONG, specbits);
9616       type = build_qualified_type (long_double_type_node,
9617                                    CP_TYPE_QUALS (type));
9618     }
9619
9620   /* Check all other uses of type modifiers.  */
9621
9622   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9623       || RIDBIT_SETP (RID_SIGNED, specbits)
9624       || RIDBIT_SETP (RID_LONG, specbits)
9625       || RIDBIT_SETP (RID_SHORT, specbits))
9626     {
9627       int ok = 0;
9628
9629       if (TREE_CODE (type) == REAL_TYPE)
9630         error ("short, signed or unsigned invalid for `%s'", name);
9631       else if (TREE_CODE (type) != INTEGER_TYPE)
9632         error ("long, short, signed or unsigned invalid for `%s'", name);
9633       else if (RIDBIT_SETP (RID_LONG, specbits)
9634                && RIDBIT_SETP (RID_SHORT, specbits))
9635         error ("long and short specified together for `%s'", name);
9636       else if ((RIDBIT_SETP (RID_LONG, specbits)
9637                 || RIDBIT_SETP (RID_SHORT, specbits))
9638                && explicit_char)
9639         error ("long or short specified with char for `%s'", name);
9640       else if ((RIDBIT_SETP (RID_LONG, specbits)
9641                 || RIDBIT_SETP (RID_SHORT, specbits))
9642                && TREE_CODE (type) == REAL_TYPE)
9643         error ("long or short specified with floating type for `%s'", name);
9644       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9645                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9646         error ("signed and unsigned given together for `%s'", name);
9647       else
9648         {
9649           ok = 1;
9650           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9651             {
9652               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9653                        name);
9654               if (flag_pedantic_errors)
9655                 ok = 0;
9656             }
9657         }
9658
9659       /* Discard the type modifiers if they are invalid.  */
9660       if (! ok)
9661         {
9662           RIDBIT_RESET (RID_UNSIGNED, specbits);
9663           RIDBIT_RESET (RID_SIGNED, specbits);
9664           RIDBIT_RESET (RID_LONG, specbits);
9665           RIDBIT_RESET (RID_SHORT, specbits);
9666           longlong = 0;
9667         }
9668     }
9669
9670   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9671       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9672     {
9673       error ("complex invalid for `%s'", name);
9674       RIDBIT_RESET (RID_COMPLEX, specbits);
9675     }
9676
9677   /* Decide whether an integer type is signed or not.
9678      Optionally treat bitfields as signed by default.  */
9679   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9680       || (bitfield && ! flag_signed_bitfields
9681           && (explicit_int || defaulted_int || explicit_char
9682               /* A typedef for plain `int' without `signed'
9683                  can be controlled just like plain `int'.  */
9684               || ! (typedef_decl != NULL_TREE
9685                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9686           && TREE_CODE (type) != ENUMERAL_TYPE
9687           && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
9688     {
9689       if (longlong)
9690         type = long_long_unsigned_type_node;
9691       else if (RIDBIT_SETP (RID_LONG, specbits))
9692         type = long_unsigned_type_node;
9693       else if (RIDBIT_SETP (RID_SHORT, specbits))
9694         type = short_unsigned_type_node;
9695       else if (type == char_type_node)
9696         type = unsigned_char_type_node;
9697       else if (typedef_decl)
9698         type = unsigned_type (type);
9699       else
9700         type = unsigned_type_node;
9701     }
9702   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9703            && type == char_type_node)
9704     type = signed_char_type_node;
9705   else if (longlong)
9706     type = long_long_integer_type_node;
9707   else if (RIDBIT_SETP (RID_LONG, specbits))
9708     type = long_integer_type_node;
9709   else if (RIDBIT_SETP (RID_SHORT, specbits))
9710     type = short_integer_type_node;
9711
9712   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9713     {
9714       /* If we just have "complex", it is equivalent to
9715          "complex double", but if any modifiers at all are specified it is
9716          the complex form of TYPE.  E.g, "complex short" is
9717          "complex short int".  */
9718
9719       if (defaulted_int && ! longlong
9720           && ! (RIDBIT_SETP (RID_LONG, specbits)
9721                 || RIDBIT_SETP (RID_SHORT, specbits)
9722                 || RIDBIT_SETP (RID_SIGNED, specbits)
9723                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9724         type = complex_double_type_node;
9725       else if (type == integer_type_node)
9726         type = complex_integer_type_node;
9727       else if (type == float_type_node)
9728         type = complex_float_type_node;
9729       else if (type == double_type_node)
9730         type = complex_double_type_node;
9731       else if (type == long_double_type_node)
9732         type = complex_long_double_type_node;
9733       else
9734         type = build_complex_type (type);
9735     }
9736
9737   if (return_type == return_conversion
9738       && (RIDBIT_SETP (RID_CONST, specbits)
9739           || RIDBIT_SETP (RID_VOLATILE, specbits)
9740           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9741     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9742               ctor_return_type);
9743
9744   /* Set CONSTP if this declaration is `const', whether by
9745      explicit specification or via a typedef.
9746      Likewise for VOLATILEP.  */
9747
9748   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9749   restrictp =
9750     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9751   volatilep =
9752     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9753   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9754                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9755                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9756   type = cp_build_qualified_type (type, type_quals);
9757   staticp = 0;
9758   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9759   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9760   RIDBIT_RESET (RID_VIRTUAL, specbits);
9761   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9762   RIDBIT_RESET (RID_EXPLICIT, specbits);
9763
9764   if (RIDBIT_SETP (RID_STATIC, specbits))
9765     staticp = 1 + (decl_context == FIELD);
9766
9767   if (virtualp && staticp == 2)
9768     {
9769       cp_error ("member `%D' cannot be declared both virtual and static",
9770                 dname);
9771       staticp = 0;
9772     }
9773   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9774   RIDBIT_RESET (RID_FRIEND, specbits);
9775
9776   /* $7.1.2, Function specifiers */
9777   if (friendp && explicitp)
9778     error ("only declarations of constructors can be `explicit'");
9779
9780   if (RIDBIT_SETP (RID_MUTABLE, specbits))
9781     {
9782       if (decl_context == PARM)
9783         {
9784           error ("non-member `%s' cannot be declared `mutable'", name);
9785           RIDBIT_RESET (RID_MUTABLE, specbits);
9786         }
9787       else if (friendp || decl_context == TYPENAME)
9788         {
9789           error ("non-object member `%s' cannot be declared `mutable'", name);
9790           RIDBIT_RESET (RID_MUTABLE, specbits);
9791         }
9792     }
9793
9794   /* Warn if two storage classes are given. Default to `auto'.  */
9795
9796   if (RIDBIT_ANY_SET (specbits))
9797     {
9798       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9799       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9800       if (decl_context == PARM && nclasses > 0)
9801         error ("storage class specifiers invalid in parameter declarations");
9802       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9803         {
9804           if (decl_context == PARM)
9805             error ("typedef declaration invalid in parameter declaration");
9806           nclasses++;
9807         }
9808       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9809       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9810     }
9811
9812   /* Give error if `virtual' is used outside of class declaration.  */
9813   if (virtualp
9814       && (current_class_name == NULL_TREE || decl_context != FIELD))
9815     {
9816       error ("virtual outside class declaration");
9817       virtualp = 0;
9818     }
9819   if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
9820     {
9821       error ("only members can be declared mutable");
9822       RIDBIT_RESET (RID_MUTABLE, specbits);
9823     }
9824
9825   /* Static anonymous unions are dealt with here.  */
9826   if (staticp && decl_context == TYPENAME
9827       && TREE_CODE (declspecs) == TREE_LIST
9828       && ANON_UNION_TYPE_P (TREE_VALUE (declspecs)))
9829     decl_context = FIELD;
9830
9831   /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9832      is used in a signature member function declaration.  */
9833   if (decl_context == FIELD
9834       && IS_SIGNATURE (current_class_type)
9835       && RIDBIT_NOTSETP (RID_TYPEDEF, specbits))
9836     {
9837       if (type_quals != TYPE_UNQUALIFIED)
9838         {
9839           error ("type qualifiers specified for signature member function `%s'", name);
9840           type_quals = TYPE_UNQUALIFIED;
9841         }
9842       if (inlinep)
9843         {
9844           error ("`inline' specified for signature member function `%s'", name);
9845           /* Later, we'll make signature member functions inline.  */
9846           inlinep = 0;
9847         }
9848       if (friendp)
9849         {
9850           error ("`friend' declaration in signature definition");
9851           friendp = 0;
9852         }
9853       if (virtualp)
9854         {
9855           error ("`virtual' specified for signature member function `%s'",
9856                  name);
9857           /* Later, we'll make signature member functions virtual.  */
9858           virtualp = 0;
9859         }
9860     }
9861
9862   /* Warn about storage classes that are invalid for certain
9863      kinds of declarations (parameters, typenames, etc.).  */
9864
9865   if (nclasses > 1)
9866     error ("multiple storage classes in declaration of `%s'", name);
9867   else if (decl_context != NORMAL && nclasses > 0)
9868     {
9869       if ((decl_context == PARM || decl_context == CATCHPARM)
9870           && (RIDBIT_SETP (RID_REGISTER, specbits)
9871               || RIDBIT_SETP (RID_AUTO, specbits)))
9872         ;
9873       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9874         ;
9875       else if (decl_context == FIELD
9876                && ! IS_SIGNATURE (current_class_type)
9877                /* C++ allows static class elements  */
9878                && RIDBIT_SETP (RID_STATIC, specbits))
9879         /* C++ also allows inlines and signed and unsigned elements,
9880            but in those cases we don't come in here.  */
9881         ;
9882       else
9883         {
9884           if (decl_context == FIELD)
9885             {
9886               tree tmp = NULL_TREE;
9887               register int op = 0;
9888
9889               if (declarator)
9890                 {
9891                   /* Avoid trying to get an operand off an identifier node.  */
9892                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9893                     tmp = declarator;
9894                   else
9895                     tmp = TREE_OPERAND (declarator, 0);
9896                   op = IDENTIFIER_OPNAME_P (tmp);
9897                 }
9898               error ("storage class specified for %s `%s'",
9899                      IS_SIGNATURE (current_class_type)
9900                      ? (op
9901                         ? "signature member operator"
9902                         : "signature member function")
9903                      : (op ? "member operator" : "field"),
9904                      op ? operator_name_string (tmp) : name);
9905             }
9906           else
9907             error (((decl_context == PARM || decl_context == CATCHPARM)
9908                     ? "storage class specified for parameter `%s'"
9909                     : "storage class specified for typename"), name);
9910           RIDBIT_RESET (RID_REGISTER, specbits);
9911           RIDBIT_RESET (RID_AUTO, specbits);
9912           RIDBIT_RESET (RID_EXTERN, specbits);
9913
9914           if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
9915             {
9916               RIDBIT_RESET (RID_STATIC, specbits);
9917               staticp = 0;
9918             }
9919         }
9920     }
9921   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9922     {
9923       if (toplevel_bindings_p ())
9924         {
9925           /* It's common practice (and completely valid) to have a const
9926              be initialized and declared extern.  */
9927           if (!(type_quals & TYPE_QUAL_CONST))
9928             warning ("`%s' initialized and declared `extern'", name);
9929         }
9930       else
9931         error ("`%s' has both `extern' and initializer", name);
9932     }
9933   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
9934            && ! toplevel_bindings_p ())
9935     error ("nested function `%s' declared `extern'", name);
9936   else if (toplevel_bindings_p ())
9937     {
9938       if (RIDBIT_SETP (RID_AUTO, specbits))
9939         error ("top-level declaration of `%s' specifies `auto'", name);
9940     }
9941
9942   if (nclasses > 0 && friendp)
9943     error ("storage class specifiers invalid in friend function declarations");
9944
9945   /* Now figure out the structure of the declarator proper.
9946      Descend through it, creating more complex types, until we reach
9947      the declared identifier (or NULL_TREE, in an absolute declarator).  */
9948
9949   inner_attrs = NULL_TREE;
9950   ignore_attrs = 0;
9951
9952   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
9953          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
9954     {
9955       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9956          an INDIRECT_REF (for *...),
9957          a CALL_EXPR (for ...(...)),
9958          an identifier (for the name being declared)
9959          or a null pointer (for the place in an absolute declarator
9960          where the name was omitted).
9961          For the last two cases, we have just exited the loop.
9962
9963          For C++ it could also be
9964          a SCOPE_REF (for class :: ...).  In this case, we have converted
9965          sensible names to types, and those are the values we use to
9966          qualify the member name.
9967          an ADDR_EXPR (for &...),
9968          a BIT_NOT_EXPR (for destructors)
9969
9970          At this point, TYPE is the type of elements of an array,
9971          or for a function to return, or for a pointer to point to.
9972          After this sequence of ifs, TYPE is the type of the
9973          array or function or pointer, and DECLARATOR has had its
9974          outermost layer removed.  */
9975
9976       if (type == error_mark_node)
9977         {
9978           if (TREE_CODE (declarator) == SCOPE_REF)
9979             declarator = TREE_OPERAND (declarator, 1);
9980           else
9981             declarator = TREE_OPERAND (declarator, 0);
9982           continue;
9983         }
9984       if (quals != NULL_TREE
9985           && (declarator == NULL_TREE
9986               || TREE_CODE (declarator) != SCOPE_REF))
9987         {
9988           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
9989             ctype = TYPE_METHOD_BASETYPE (type);
9990           if (ctype != NULL_TREE)
9991             {
9992               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
9993               ctype = grok_method_quals (ctype, dummy, quals);
9994               type = TREE_TYPE (dummy);
9995               quals = NULL_TREE;
9996             }
9997         }
9998
9999       /* See the comment for the TREE_LIST case, below.  */
10000       if (ignore_attrs)
10001         ignore_attrs = 0;
10002       else if (inner_attrs)
10003         {
10004           decl_attributes (type, inner_attrs, NULL_TREE);
10005           inner_attrs = NULL_TREE;
10006         }
10007
10008       switch (TREE_CODE (declarator))
10009         {
10010         case TREE_LIST:
10011           {
10012             /* We encode a declarator with embedded attributes using
10013                a TREE_LIST.  The attributes apply to the declarator
10014                directly inside them, so we have to skip an iteration
10015                before applying them to the type.  If the declarator just
10016                inside is the declarator-id, we apply the attrs to the
10017                decl itself.  */
10018             inner_attrs = TREE_PURPOSE (declarator);
10019             ignore_attrs = 1;
10020             declarator = TREE_VALUE (declarator);
10021           }
10022           break;
10023
10024         case ARRAY_REF:
10025           {
10026             register tree itype = NULL_TREE;
10027             register tree size = TREE_OPERAND (declarator, 1);
10028             /* The index is a signed object `sizetype' bits wide.  */
10029             tree index_type = signed_type (sizetype);
10030
10031             declarator = TREE_OPERAND (declarator, 0);
10032
10033             /* Check for some types that there cannot be arrays of.  */
10034
10035             if (TREE_CODE (type) == VOID_TYPE)
10036               {
10037                 cp_error ("declaration of `%D' as array of voids", dname);
10038                 type = error_mark_node;
10039               }
10040
10041             if (TREE_CODE (type) == FUNCTION_TYPE)
10042               {
10043                 cp_error ("declaration of `%D' as array of functions", dname);
10044                 type = error_mark_node;
10045               }
10046
10047             /* ARM $8.4.3: Since you can't have a pointer to a reference,
10048                you can't have arrays of references.  If we allowed them,
10049                then we'd be saying x[i] is valid for an array x, but
10050                then you'd have to ask: what does `*(x + i)' mean?  */
10051             if (TREE_CODE (type) == REFERENCE_TYPE)
10052               {
10053                 if (decl_context == TYPENAME)
10054                   cp_error ("cannot make arrays of references");
10055                 else
10056                   cp_error ("declaration of `%D' as array of references",
10057                             dname);
10058                 type = error_mark_node;
10059               }
10060
10061             if (TREE_CODE (type) == OFFSET_TYPE)
10062               {
10063                   cp_error ("declaration of `%D' as array of data members",
10064                             dname);
10065                 type = error_mark_node;
10066               }
10067
10068             if (TREE_CODE (type) == METHOD_TYPE)
10069               {
10070                 cp_error ("declaration of `%D' as array of function members",
10071                           dname);
10072                 type = error_mark_node;
10073               }
10074
10075             if (size == error_mark_node)
10076               type = error_mark_node;
10077             else if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
10078               {
10079                 /* [dcl.array]
10080
10081                    the constant expressions that specify the bounds of
10082                    the arrays can be omitted only for the first member
10083                    of the sequence.  */
10084                 cp_error ("declaration of `%D' as multidimensional array",
10085                           dname);
10086                 cp_error ("must have bounds for all dimensions except the first");
10087                 type = error_mark_node;
10088               }
10089
10090             if (type == error_mark_node)
10091               continue;
10092
10093             /* VC++ spells a zero-sized array with [].  */
10094             if (size == NULL_TREE && decl_context == FIELD && ! staticp)
10095               size = integer_zero_node;
10096
10097             if (size)
10098               {
10099                 /* Must suspend_momentary here because the index
10100                    type may need to live until the end of the function.
10101                    For example, it is used in the declaration of a
10102                    variable which requires destructing at the end of
10103                    the function; then build_vec_delete will need this
10104                    value.  */
10105                 int yes = suspend_momentary ();
10106                 /* Might be a cast. */
10107                 if (TREE_CODE (size) == NOP_EXPR
10108                     && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
10109                   size = TREE_OPERAND (size, 0);
10110
10111                 /* If this involves a template parameter, it will be a
10112                    constant at instantiation time, but we don't know
10113                    what the value is yet.  Even if no template
10114                    parameters are involved, we may an expression that
10115                    is not a constant; we don't even simplify `1 + 2'
10116                    when processing a template.  */
10117                 if (processing_template_decl)
10118                   {
10119                     /* Resolve a qualified reference to an enumerator or
10120                        static const data member of ours.  */
10121                     if (TREE_CODE (size) == SCOPE_REF
10122                         && TREE_OPERAND (size, 0) == current_class_type)
10123                       {
10124                         tree t = lookup_field (current_class_type,
10125                                                TREE_OPERAND (size, 1), 0, 0);
10126                         if (t)
10127                           size = t;
10128                       }
10129
10130                     itype = make_node (INTEGER_TYPE);
10131                     TYPE_MIN_VALUE (itype) = size_zero_node;
10132                     TYPE_MAX_VALUE (itype) = build_min
10133                       (MINUS_EXPR, sizetype, size, integer_one_node);
10134                     goto dont_grok_size;
10135                   }
10136
10137                 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
10138                     && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
10139                     && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
10140                   {
10141                     cp_error ("size of array `%D' has non-integer type",
10142                               dname);
10143                     size = integer_one_node;
10144                   }
10145                 if (TREE_READONLY_DECL_P (size))
10146                   size = decl_constant_value (size);
10147                 if (pedantic && integer_zerop (size))
10148                   cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
10149                 if (TREE_CONSTANT (size))
10150                   {
10151                     int old_flag_pedantic_errors = flag_pedantic_errors;
10152                     int old_pedantic = pedantic;
10153                     pedantic = flag_pedantic_errors = 1;
10154                     /* Always give overflow errors on array subscripts.  */
10155                     constant_expression_warning (size);
10156                     pedantic = old_pedantic;
10157                     flag_pedantic_errors = old_flag_pedantic_errors;
10158                     if (INT_CST_LT (size, integer_zero_node))
10159                       {
10160                         cp_error ("size of array `%D' is negative", dname);
10161                         size = integer_one_node;
10162                       }
10163                   }
10164                 else
10165                   {
10166                     if (pedantic)
10167                       {
10168                         if (dname)
10169                           cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
10170                                       dname);
10171                         else
10172                           cp_pedwarn ("ANSI C++ forbids variable-size array");
10173                       }
10174                   }
10175
10176                 itype
10177                   = fold (build_binary_op (MINUS_EXPR,
10178                                            cp_convert (index_type, size),
10179                                            cp_convert (index_type,
10180                                                        integer_one_node), 1));
10181                 if (! TREE_CONSTANT (itype))
10182                   itype = variable_size (itype);
10183                 else if (TREE_OVERFLOW (itype))
10184                   {
10185                     error ("overflow in array dimension");
10186                     TREE_OVERFLOW (itype) = 0;
10187                   }
10188
10189                 /* If we're a parm, we need to have a permanent type so
10190                    mangling checks for re-use will work right.  If both the
10191                    element and index types are permanent, the array type
10192                    will be, too.  */
10193                 if (decl_context == PARM
10194                     && allocation_temporary_p () && TREE_PERMANENT (type))
10195                   {
10196                     push_obstacks (&permanent_obstack, &permanent_obstack);
10197                     itype = build_index_type (itype);
10198                     pop_obstacks ();
10199                   }
10200                 else
10201                   itype = build_index_type (itype);
10202
10203               dont_grok_size:
10204                 resume_momentary (yes);
10205               }
10206
10207             type = build_cplus_array_type (type, itype);
10208             ctype = NULL_TREE;
10209           }
10210           break;
10211
10212         case CALL_EXPR:
10213           {
10214             tree arg_types;
10215             int funcdecl_p;
10216             tree inner_parms = TREE_OPERAND (declarator, 1);
10217             tree inner_decl = TREE_OPERAND (declarator, 0);
10218
10219             /* Declaring a function type.
10220                Make sure we have a valid type for the function to return.  */
10221
10222             /* We now know that the TYPE_QUALS don't apply to the
10223                decl, but to its return type.  */
10224             type_quals = TYPE_UNQUALIFIED;
10225
10226             /* Warn about some types functions can't return.  */
10227
10228             if (TREE_CODE (type) == FUNCTION_TYPE)
10229               {
10230                 error ("`%s' declared as function returning a function", name);
10231                 type = integer_type_node;
10232               }
10233             if (TREE_CODE (type) == ARRAY_TYPE)
10234               {
10235                 error ("`%s' declared as function returning an array", name);
10236                 type = integer_type_node;
10237               }
10238
10239             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10240               inner_decl = TREE_OPERAND (inner_decl, 1);
10241
10242             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10243               inner_decl = dname;
10244
10245             /* Pick up type qualifiers which should be applied to `this'.  */
10246             quals = TREE_OPERAND (declarator, 2);
10247
10248             /* Pick up the exception specifications.  */
10249             raises = TREE_TYPE (declarator);
10250
10251             /* Say it's a definition only for the CALL_EXPR
10252                closest to the identifier.  */
10253             funcdecl_p
10254               = inner_decl
10255               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10256                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10257                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10258
10259             if (ctype == NULL_TREE
10260                 && decl_context == FIELD
10261                 && funcdecl_p
10262                 && (friendp == 0 || dname == current_class_name))
10263               ctype = current_class_type;
10264
10265             if (ctype && return_type == return_conversion)
10266               TYPE_HAS_CONVERSION (ctype) = 1;
10267             if (ctype && constructor_name (ctype) == dname)
10268               {
10269                 /* We are within a class's scope. If our declarator name
10270                    is the same as the class name, and we are defining
10271                    a function, then it is a constructor/destructor, and
10272                    therefore returns a void type.  */
10273
10274                 if (flags == DTOR_FLAG)
10275                   {
10276                     /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
10277                        not be declared const or volatile.  A destructor
10278                        may not be static.  */
10279                     if (staticp == 2)
10280                       error ("destructor cannot be static member function");
10281                     if (quals)
10282                       {
10283                         cp_error ("destructors may not be `%s'",
10284                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10285                         quals = NULL_TREE;
10286                       }
10287                     if (decl_context == FIELD)
10288                       {
10289                         if (! member_function_or_else (ctype, current_class_type,
10290                                                        "destructor for alien class `%s' cannot be a member"))
10291                           return void_type_node;
10292                       }
10293                   }
10294                 else            /* It's a constructor.  */
10295                   {
10296                     if (explicitp == 1)
10297                       explicitp = 2;
10298                     /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
10299                        not be declared const or volatile.  A constructor may
10300                        not be virtual.  A constructor may not be static.  */
10301                     if (staticp == 2)
10302                       error ("constructor cannot be static member function");
10303                     if (virtualp)
10304                       {
10305                         pedwarn ("constructors cannot be declared virtual");
10306                         virtualp = 0;
10307                       }
10308                     if (quals)
10309                       {
10310                         cp_error ("constructors may not be `%s'",
10311                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10312                         quals = NULL_TREE;
10313                       }
10314                     {
10315                       RID_BIT_TYPE tmp_bits;
10316                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10317                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10318                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10319                       if (RIDBIT_ANY_SET (tmp_bits))
10320                         error ("return value type specifier for constructor ignored");
10321                     }
10322                     type = build_pointer_type (ctype);
10323                     if (decl_context == FIELD
10324                         && IS_SIGNATURE (current_class_type))
10325                       {
10326                         error ("constructor not allowed in signature");
10327                         return void_type_node;
10328                       }
10329                     else if (decl_context == FIELD)
10330                       {
10331                         if (! member_function_or_else (ctype, current_class_type,
10332                                                        "constructor for alien class `%s' cannot be member"))
10333                           return void_type_node;
10334                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10335                         if (return_type != return_ctor)
10336                           return NULL_TREE;
10337                       }
10338                   }
10339                 if (decl_context == FIELD)
10340                   staticp = 0;
10341               }
10342             else if (friendp)
10343               {
10344                 if (initialized)
10345                   error ("can't initialize friend function `%s'", name);
10346                 if (virtualp)
10347                   {
10348                     /* Cannot be both friend and virtual.  */
10349                     error ("virtual functions cannot be friends");
10350                     RIDBIT_RESET (RID_FRIEND, specbits);
10351                     friendp = 0;
10352                   }
10353                 if (decl_context == NORMAL)
10354                   error ("friend declaration not in class definition");
10355                 if (current_function_decl && funcdef_flag)
10356                   cp_error ("can't define friend function `%s' in a local class definition",
10357                             name);
10358               }
10359
10360             /* Construct the function type and go to the next
10361                inner layer of declarator.  */
10362
10363             declarator = TREE_OPERAND (declarator, 0);
10364
10365             /* FIXME: This is where default args should be fully
10366                processed.  */
10367
10368             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10369
10370             if (declarator && flags == DTOR_FLAG)
10371               {
10372                 /* A destructor declared in the body of a class will
10373                    be represented as a BIT_NOT_EXPR.  But, we just
10374                    want the underlying IDENTIFIER.  */
10375                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10376                   declarator = TREE_OPERAND (declarator, 0);
10377
10378                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10379                   arg_types = void_list_node;
10380                 else if (arg_types == NULL_TREE
10381                          || arg_types != void_list_node)
10382                   {
10383                     cp_error ("destructors may not have parameters");
10384                     arg_types = void_list_node;
10385                     last_function_parms = NULL_TREE;
10386                   }
10387               }
10388
10389             /* ANSI says that `const int foo ();'
10390                does not make the function foo const.  */
10391             type = build_function_type (type, arg_types);
10392
10393             {
10394               tree t;
10395               for (t = arg_types; t; t = TREE_CHAIN (t))
10396                 if (TREE_PURPOSE (t)
10397                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10398                   {
10399                     add_defarg_fn (type);
10400                     break;
10401                   }
10402             }
10403           }
10404           break;
10405
10406         case ADDR_EXPR:
10407         case INDIRECT_REF:
10408           /* Filter out pointers-to-references and references-to-references.
10409              We can get these if a TYPE_DECL is used.  */
10410
10411           if (TREE_CODE (type) == REFERENCE_TYPE)
10412             {
10413               error ("cannot declare %s to references",
10414                      TREE_CODE (declarator) == ADDR_EXPR
10415                      ? "references" : "pointers");
10416               declarator = TREE_OPERAND (declarator, 0);
10417               continue;
10418             }
10419
10420           if (TREE_CODE (type) == OFFSET_TYPE
10421               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10422                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10423             {
10424               cp_error ("cannot declare pointer to `%#T' member",
10425                         TREE_TYPE (type));
10426               type = TREE_TYPE (type);
10427             }
10428
10429           /* Merge any constancy or volatility into the target type
10430              for the pointer.  */
10431
10432           /* We now know that the TYPE_QUALS don't apply to the decl,
10433              but to the target of the pointer.  */
10434           type_quals = TYPE_UNQUALIFIED;
10435
10436           if (IS_SIGNATURE (type))
10437             {
10438               if (TREE_CODE (declarator) == ADDR_EXPR)
10439                 {
10440                   if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
10441                       && TYPE_SIZE (type))
10442                     cp_warning ("empty signature `%T' used in signature reference declaration",
10443                                 type);
10444 #if 0
10445                   type = build_signature_reference_type (type);
10446 #else
10447                   sorry ("signature reference");
10448                   return NULL_TREE;
10449 #endif
10450                 }
10451               else
10452                 {
10453                   if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
10454                       && TYPE_SIZE (type))
10455                     cp_warning ("empty signature `%T' used in signature pointer declaration",
10456                                 type);
10457                   type = build_signature_pointer_type (type);
10458                 }
10459             }
10460           else if (TREE_CODE (declarator) == ADDR_EXPR)
10461             {
10462               if (TREE_CODE (type) == VOID_TYPE)
10463                 error ("invalid type: `void &'");
10464               else
10465                 type = build_reference_type (type);
10466             }
10467           else if (TREE_CODE (type) == METHOD_TYPE)
10468             type = build_ptrmemfunc_type (build_pointer_type (type));
10469           else
10470             type = build_pointer_type (type);
10471
10472           /* Process a list of type modifier keywords (such as
10473              const or volatile) that were given inside the `*' or `&'.  */
10474
10475           if (TREE_TYPE (declarator))
10476             {
10477               register tree typemodlist;
10478               int erred = 0;
10479
10480               constp = 0;
10481               volatilep = 0;
10482               restrictp = 0;
10483               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10484                    typemodlist = TREE_CHAIN (typemodlist))
10485                 {
10486                   tree qualifier = TREE_VALUE (typemodlist);
10487
10488                   if (qualifier == ridpointers[(int) RID_CONST])
10489                     constp++;
10490                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10491                     volatilep++;
10492                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10493                     restrictp++;
10494                   else if (!erred)
10495                     {
10496                       erred = 1;
10497                       error ("invalid type modifier within pointer declarator");
10498                     }
10499                 }
10500               if (constp > 1)
10501                 pedwarn ("duplicate `const'");
10502               if (volatilep > 1)
10503                 pedwarn ("duplicate `volatile'");
10504               if (restrictp > 1)
10505                 pedwarn ("duplicate `restrict'");
10506
10507               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10508                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10509                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10510               if (TREE_CODE (declarator) == ADDR_EXPR
10511                   && (constp || volatilep))
10512                 {
10513                   if (constp)
10514                     pedwarn ("discarding `const' applied to a reference");
10515                   if (volatilep)
10516                     pedwarn ("discarding `volatile' applied to a reference");
10517                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10518                 }
10519               type = cp_build_qualified_type (type, type_quals);
10520             }
10521           declarator = TREE_OPERAND (declarator, 0);
10522           ctype = NULL_TREE;
10523           break;
10524
10525         case SCOPE_REF:
10526           {
10527             /* We have converted type names to NULL_TREE if the
10528                name was bogus, or to a _TYPE node, if not.
10529
10530                The variable CTYPE holds the type we will ultimately
10531                resolve to.  The code here just needs to build
10532                up appropriate member types.  */
10533             tree sname = TREE_OPERAND (declarator, 1);
10534             tree t;
10535
10536             /* Destructors can have their visibilities changed as well.  */
10537             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10538               sname = TREE_OPERAND (sname, 0);
10539
10540             if (TREE_COMPLEXITY (declarator) == 0)
10541               /* This needs to be here, in case we are called
10542                  multiple times.  */ ;
10543             else if (TREE_COMPLEXITY (declarator) == -1)
10544               /* Namespace member. */
10545               pop_decl_namespace ();
10546             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10547               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10548             else if (! IS_AGGR_TYPE_CODE
10549                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10550               ;
10551             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10552               {
10553                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10554                    that refer to ctype.  They couldn't be resolved earlier
10555                    because we hadn't pushed into the class yet.
10556                    Example: resolve 'B<T>::type' in
10557                    'B<typename B<T>::type> B<T>::f () { }'.  */
10558                 if (current_template_parms
10559                     && uses_template_parms (type)
10560                     && uses_template_parms (current_class_type))
10561                   {
10562                     tree args = current_template_args ();
10563                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10564                   }
10565
10566                 /* This pop_nested_class corresponds to the
10567                    push_nested_class used to push into class scope for
10568                    parsing the argument list of a function decl, in
10569                    qualified_id.  */
10570                 pop_nested_class (1);
10571                 TREE_COMPLEXITY (declarator) = current_class_depth;
10572               }
10573             else
10574               my_friendly_abort (16);
10575
10576             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10577               {
10578                 /* We had a reference to a global decl, or
10579                    perhaps we were given a non-aggregate typedef,
10580                    in which case we cleared this out, and should just
10581                    keep going as though it wasn't there.  */
10582                 declarator = sname;
10583                 continue;
10584               }
10585             ctype = TREE_OPERAND (declarator, 0);
10586
10587             t = ctype;
10588             while (t != NULL_TREE && CLASS_TYPE_P (t))
10589               {
10590                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10591                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10592                   template_count += 1;
10593                 t = TYPE_MAIN_DECL (t);
10594                 if (DECL_LANG_SPECIFIC (t))
10595                   t = DECL_CLASS_CONTEXT (t);
10596                 else
10597                   t = NULL_TREE;
10598               }
10599
10600             if (sname == NULL_TREE)
10601               goto done_scoping;
10602
10603             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10604               {
10605                 /* This is the `standard' use of the scoping operator:
10606                    basetype :: member .  */
10607
10608                 if (ctype == current_class_type)
10609                   {
10610                     /* class A {
10611                          void A::f ();
10612                        };
10613
10614                        Is this ill-formed?  */
10615
10616                     if (pedantic)
10617                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10618                                   ctype, name);
10619                   }
10620                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10621                   {
10622                     if (current_class_type == NULL_TREE
10623                         || friendp)
10624                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10625                                                       TYPE_ARG_TYPES (type));
10626                     else
10627                       {
10628                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10629                                   ctype, name, current_class_type);
10630                         return void_type_node;
10631                       }
10632                   }
10633                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10634                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10635                   {
10636                     /* Have to move this code elsewhere in this function.
10637                        this code is used for i.e., typedef int A::M; M *pm;
10638
10639                        It is?  How? jason 10/2/94 */
10640
10641                     if (current_class_type)
10642                       {
10643                         cp_error ("cannot declare member `%T::%s' within `%T'",
10644                                   ctype, name, current_class_type);
10645                         return void_type_node;
10646                       }
10647                     type = build_offset_type (ctype, type);
10648                   }
10649                 else if (uses_template_parms (ctype))
10650                   {
10651                     if (TREE_CODE (type) == FUNCTION_TYPE)
10652                       type
10653                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10654                                                    TYPE_ARG_TYPES (type));
10655                   }
10656                 else
10657                   {
10658                     cp_error ("structure `%T' not yet defined", ctype);
10659                     return error_mark_node;
10660                   }
10661
10662                 declarator = sname;
10663               }
10664             else if (TREE_CODE (sname) == SCOPE_REF)
10665               my_friendly_abort (17);
10666             else
10667               {
10668               done_scoping:
10669                 declarator = TREE_OPERAND (declarator, 1);
10670                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10671                   /* In this case, we will deal with it later.  */
10672                   ;
10673                 else
10674                   {
10675                     if (TREE_CODE (type) == FUNCTION_TYPE)
10676                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10677                                                       TYPE_ARG_TYPES (type));
10678                     else
10679                       type = build_offset_type (ctype, type);
10680                   }
10681               }
10682           }
10683           break;
10684
10685         case BIT_NOT_EXPR:
10686           declarator = TREE_OPERAND (declarator, 0);
10687           break;
10688
10689         case RECORD_TYPE:
10690         case UNION_TYPE:
10691         case ENUMERAL_TYPE:
10692           declarator = NULL_TREE;
10693           break;
10694
10695         case ERROR_MARK:
10696           declarator = NULL_TREE;
10697           break;
10698
10699         default:
10700           my_friendly_abort (158);
10701         }
10702     }
10703
10704   /* See the comment for the TREE_LIST case, above.  */
10705   if (inner_attrs)
10706     {
10707       if (! ignore_attrs)
10708         decl_attributes (type, inner_attrs, NULL_TREE);
10709       else if (attrlist)
10710         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10711       else
10712         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10713     }
10714
10715   if (explicitp == 1)
10716     {
10717       error ("only constructors can be declared `explicit'");
10718       explicitp = 0;
10719     }
10720
10721   /* Now TYPE has the actual type.  */
10722
10723   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10724
10725   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10726     {
10727       if (type_quals & TYPE_QUAL_CONST)
10728         {
10729           error ("const `%s' cannot be declared `mutable'", name);
10730           RIDBIT_RESET (RID_MUTABLE, specbits);
10731         }
10732       else if (staticp)
10733         {
10734           error ("static `%s' cannot be declared `mutable'", name);
10735           RIDBIT_RESET (RID_MUTABLE, specbits);
10736         }
10737     }
10738
10739   if (declarator == NULL_TREE
10740       || TREE_CODE (declarator) == IDENTIFIER_NODE
10741       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10742           && (TREE_CODE (type) == FUNCTION_TYPE
10743               || TREE_CODE (type) == METHOD_TYPE)))
10744     /* OK */;
10745   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10746     {
10747       cp_error ("template-id `%D' used as a declarator", declarator);
10748       declarator = dname;
10749     }
10750   else
10751     my_friendly_abort (990210);
10752
10753   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10754     {
10755       tree decl;
10756
10757       /* Note that the grammar rejects storage classes
10758          in typenames, fields or parameters.  */
10759       if (current_lang_name == lang_name_java)
10760         TYPE_FOR_JAVA (type) = 1;
10761
10762       if (decl_context == FIELD)
10763         {
10764           if (declarator == constructor_name (current_class_type))
10765             cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10766                         declarator);
10767           decl = build_lang_decl (TYPE_DECL, declarator, type);
10768           if (IS_SIGNATURE (current_class_type) && opaque_typedef)
10769             SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
10770         }
10771       else
10772         {
10773           /* Make sure this typedef lives as long as its type,
10774              since it might be used as a template parameter. */
10775           if (type != error_mark_node)
10776             push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
10777           decl = build_decl (TYPE_DECL, declarator, type);
10778           if (type != error_mark_node)
10779             pop_obstacks ();
10780         }
10781
10782       /* If the user declares "struct {...} foo" then `foo' will have
10783          an anonymous name.  Fill that name in now.  Nothing can
10784          refer to it, so nothing needs know about the name change.
10785          The TYPE_NAME field was filled in by build_struct_xref.  */
10786       if (type != error_mark_node
10787           && TYPE_NAME (type)
10788           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10789           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
10790         {
10791           /* FIXME: This is bogus; we should not be doing this for
10792                     cv-qualified types.  */
10793
10794           /* For anonymous structs that are cv-qualified, need to use
10795              TYPE_MAIN_VARIANT so that name will mangle correctly. As
10796              type not referenced after this block, don't bother
10797              resetting type to original type, ie. TREE_TYPE (decl). */
10798           type = TYPE_MAIN_VARIANT (type);
10799
10800           /* Replace the anonymous name with the real name everywhere.  */
10801           lookup_tag_reverse (type, declarator);
10802           TYPE_NAME (type) = decl;
10803
10804           if (TYPE_LANG_SPECIFIC (type))
10805             TYPE_WAS_ANONYMOUS (type) = 1;
10806
10807           /* If this is a typedef within a template class, the nested
10808              type is a (non-primary) template.  The name for the
10809              template needs updating as well.  */
10810           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10811             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10812               = TYPE_IDENTIFIER (type);
10813
10814           /* XXX Temporarily set the scope.
10815              When returning, start_decl expects it as NULL_TREE,
10816              and will then then set it using pushdecl. */
10817           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10818           if (current_class_type)
10819             DECL_CONTEXT (decl) = current_class_type;
10820           else
10821             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10822
10823           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10824           DECL_ASSEMBLER_NAME (decl)
10825             = get_identifier (build_overload_name (type, 1, 1));
10826           DECL_CONTEXT (decl) = NULL_TREE;
10827
10828           /* FIXME remangle member functions; member functions of a
10829              type with external linkage have external linkage.  */
10830         }
10831
10832       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10833         {
10834           cp_error_at ("typedef name may not be class-qualified", decl);
10835           return NULL_TREE;
10836         }
10837       else if (quals)
10838         {
10839           if (ctype == NULL_TREE)
10840             {
10841               if (TREE_CODE (type) != METHOD_TYPE)
10842                 cp_error_at ("invalid type qualifier for non-method type", decl);
10843               else
10844                 ctype = TYPE_METHOD_BASETYPE (type);
10845             }
10846           if (ctype != NULL_TREE)
10847             grok_method_quals (ctype, decl, quals);
10848         }
10849
10850       if (RIDBIT_SETP (RID_SIGNED, specbits)
10851           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10852         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10853
10854       if (RIDBIT_SETP (RID_MUTABLE, specbits))
10855         error ("non-object member `%s' cannot be declared mutable", name);
10856
10857       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10858                       inlinep, friendp, raises != NULL_TREE);
10859
10860       if (initialized)
10861         error ("typedef declaration includes an initializer");
10862
10863       return decl;
10864     }
10865
10866   /* Detect the case of an array type of unspecified size
10867      which came, as such, direct from a typedef name.
10868      We must copy the type, so that each identifier gets
10869      a distinct type, so that each identifier's size can be
10870      controlled separately by its own initializer.  */
10871
10872   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10873       && TYPE_DOMAIN (type) == NULL_TREE)
10874     {
10875       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10876     }
10877
10878   /* If this is a type name (such as, in a cast or sizeof),
10879      compute the type and return it now.  */
10880
10881   if (decl_context == TYPENAME)
10882     {
10883       /* Note that the grammar rejects storage classes
10884          in typenames, fields or parameters.  */
10885       if (type_quals != TYPE_UNQUALIFIED)
10886         {
10887           if (IS_SIGNATURE (type))
10888             error ("type qualifiers specified for signature type");
10889           type_quals = TYPE_UNQUALIFIED;
10890         }
10891
10892       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10893       if (friendp)
10894         {
10895           if (type_quals != TYPE_UNQUALIFIED)
10896             {
10897               cp_error ("type qualifiers specified for friend class declaration");
10898               type_quals = TYPE_UNQUALIFIED;
10899             }
10900           if (inlinep)
10901             {
10902               cp_error ("`inline' specified for friend class declaration");
10903               inlinep = 0;
10904             }
10905
10906           /* Only try to do this stuff if we didn't already give up.  */
10907           if (type != integer_type_node)
10908             {
10909               /* A friendly class?  */
10910               if (current_class_type)
10911                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10912               else
10913                 error ("trying to make class `%s' a friend of global scope",
10914                        TYPE_NAME_STRING (type));
10915               type = void_type_node;
10916             }
10917         }
10918       else if (quals)
10919         {
10920           tree dummy = build_decl (TYPE_DECL, declarator, type);
10921           if (ctype == NULL_TREE)
10922             {
10923               my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10924               ctype = TYPE_METHOD_BASETYPE (type);
10925             }
10926           grok_method_quals (ctype, dummy, quals);
10927           type = TREE_TYPE (dummy);
10928         }
10929
10930       return type;
10931     }
10932   else if (declarator == NULL_TREE && decl_context != PARM
10933            && decl_context != CATCHPARM
10934            && TREE_CODE (type) != UNION_TYPE
10935            && ! bitfield)
10936     {
10937       cp_error ("abstract declarator `%T' used as declaration", type);
10938       declarator = make_anon_name ();
10939     }
10940
10941   /* `void' at top level (not within pointer)
10942      is allowed only in typedefs or type names.
10943      We don't complain about parms either, but that is because
10944      a better error message can be made later.  */
10945
10946   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10947     {
10948       if (! declarator)
10949         error ("unnamed variable or field declared void");
10950       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10951         {
10952           if (IDENTIFIER_OPNAME_P (declarator))
10953             my_friendly_abort (356);
10954           else
10955             error ("variable or field `%s' declared void", name);
10956         }
10957       else
10958         error ("variable or field declared void");
10959       type = integer_type_node;
10960     }
10961
10962   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10963      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10964
10965   if (decl_context == PARM || decl_context == CATCHPARM)
10966     {
10967       if (ctype || in_namespace)
10968         error ("cannot use `::' in parameter declaration");
10969
10970       /* A parameter declared as an array of T is really a pointer to T.
10971          One declared as a function is really a pointer to a function.
10972          One declared as a member is really a pointer to member.  */
10973
10974       if (TREE_CODE (type) == ARRAY_TYPE)
10975         {
10976           /* Transfer const-ness of array into that of type pointed to.  */
10977           type = build_pointer_type (TREE_TYPE (type));
10978           type_quals = TYPE_UNQUALIFIED;
10979         }
10980       else if (TREE_CODE (type) == FUNCTION_TYPE)
10981         type = build_pointer_type (type);
10982       else if (TREE_CODE (type) == OFFSET_TYPE)
10983         type = build_pointer_type (type);
10984       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10985         {
10986           error ("declaration of `%s' as void", name);
10987           return NULL_TREE;
10988         }
10989     }
10990
10991   {
10992     register tree decl;
10993
10994     if (decl_context == PARM)
10995       {
10996         decl = build_decl (PARM_DECL, declarator, type);
10997
10998         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10999                         inlinep, friendp, raises != NULL_TREE);
11000         if (current_class_type
11001             && IS_SIGNATURE (current_class_type))
11002           {
11003             if (inlinep)
11004               error ("parameter of signature member function declared `inline'");
11005             if (RIDBIT_SETP (RID_AUTO, specbits))
11006               error ("parameter of signature member function declared `auto'");
11007             if (RIDBIT_SETP (RID_REGISTER, specbits))
11008               error ("parameter of signature member function declared `register'");
11009           }
11010
11011         /* Compute the type actually passed in the parmlist,
11012            for the case where there is no prototype.
11013            (For example, shorts and chars are passed as ints.)
11014            When there is a prototype, this is overridden later.  */
11015
11016         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11017       }
11018     else if (decl_context == FIELD)
11019       {
11020         if (type == error_mark_node)
11021           {
11022             /* Happens when declaring arrays of sizes which
11023                are error_mark_node, for example.  */
11024             decl = NULL_TREE;
11025           }
11026         else if (in_namespace && !friendp)
11027           {
11028             /* Something like struct S { int N::j; };  */
11029             cp_error ("invalid use of `::'");
11030             decl = NULL_TREE;
11031           }
11032         else if (TREE_CODE (type) == FUNCTION_TYPE)
11033           {
11034             int publicp = 0;
11035             tree function_context;
11036
11037             /* We catch the others as conflicts with the builtin
11038                typedefs.  */
11039             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11040               {
11041                 cp_error ("function `%D' cannot be declared friend",
11042                           declarator);
11043                 friendp = 0;
11044               }
11045
11046             if (friendp == 0)
11047               {
11048                 if (ctype == NULL_TREE)
11049                   ctype = current_class_type;
11050
11051                 if (ctype == NULL_TREE)
11052                   {
11053                     cp_error ("can't make `%D' into a method -- not in a class",
11054                               declarator);
11055                     return void_type_node;
11056                   }
11057
11058                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11059                    ARM 9.5 */
11060                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11061                   {
11062                     cp_error ("function `%D' declared virtual inside a union",
11063                               declarator);
11064                     return void_type_node;
11065                   }
11066
11067                 if (declarator == ansi_opname[(int) NEW_EXPR]
11068                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11069                     || declarator == ansi_opname[(int) DELETE_EXPR]
11070                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11071                   {
11072                     if (virtualp)
11073                       {
11074                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11075                                   declarator);
11076                         virtualp = 0;
11077                       }
11078                   }
11079                 else if (staticp < 2)
11080                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11081                                                   TYPE_ARG_TYPES (type));
11082               }
11083
11084             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11085             function_context = (ctype != NULL_TREE) ?
11086               hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11087             publicp = (! friendp || ! staticp)
11088               && function_context == NULL_TREE;
11089             decl = grokfndecl (ctype, type,
11090                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11091                                ? declarator : dname,
11092                                declarator,
11093                                virtualp, flags, quals, raises, attrlist,
11094                                friendp ? -1 : 0, friendp, publicp, inlinep,
11095                                funcdef_flag, template_count, in_namespace);
11096             if (decl == NULL_TREE)
11097               return decl;
11098 #if 0
11099             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11100             /* The decl and setting of decl_machine_attr is also turned off.  */
11101             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11102 #endif
11103
11104             /* [class.conv.ctor]
11105
11106                A constructor declared without the function-specifier
11107                explicit that can be called with a single parameter
11108                specifies a conversion from the type of its first
11109                parameter to the type of its class.  Such a constructor
11110                is called a converting constructor.  */
11111             if (explicitp == 2)
11112               DECL_NONCONVERTING_P (decl) = 1;
11113             else if (DECL_CONSTRUCTOR_P (decl))
11114               {
11115                 /* The constructor can be called with exactly one
11116                    parameter if there is at least one parameter, and
11117                    any subsequent parameters have default arguments.
11118                    We don't look at the first parameter, which is
11119                    really just the `this' parameter for the new
11120                    object.  */
11121                 tree arg_types =
11122                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11123
11124                 /* Skip the `in_chrg' argument too, if present.  */
11125                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11126                   arg_types = TREE_CHAIN (arg_types);
11127
11128                 if (arg_types == void_list_node
11129                     || (arg_types
11130                         && TREE_CHAIN (arg_types)
11131                         && TREE_CHAIN (arg_types) != void_list_node
11132                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11133                   DECL_NONCONVERTING_P (decl) = 1;
11134               }
11135           }
11136         else if (TREE_CODE (type) == METHOD_TYPE)
11137           {
11138             /* We only get here for friend declarations of
11139                members of other classes.  */
11140             /* All method decls are public, so tell grokfndecl to set
11141                TREE_PUBLIC, also.  */
11142             decl = grokfndecl (ctype, type, declarator, declarator,
11143                                virtualp, flags, quals, raises, attrlist,
11144                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11145                                template_count, in_namespace);
11146             if (decl == NULL_TREE)
11147               return NULL_TREE;
11148           }
11149         else if (!staticp && ! processing_template_decl
11150                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11151                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11152           {
11153             if (declarator)
11154               cp_error ("field `%D' has incomplete type", declarator);
11155             else
11156               cp_error ("name `%T' has incomplete type", type);
11157
11158             /* If we're instantiating a template, tell them which
11159                instantiation made the field's type be incomplete.  */
11160             if (current_class_type
11161                 && TYPE_NAME (current_class_type)
11162                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11163                 && declspecs && TREE_VALUE (declspecs)
11164                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11165               cp_error ("  in instantiation of template `%T'",
11166                         current_class_type);
11167
11168             type = error_mark_node;
11169             decl = NULL_TREE;
11170           }
11171         else
11172           {
11173             if (friendp)
11174               {
11175                 error ("`%s' is neither function nor method; cannot be declared friend",
11176                        IDENTIFIER_POINTER (declarator));
11177                 friendp = 0;
11178               }
11179             decl = NULL_TREE;
11180           }
11181
11182         if (friendp)
11183           {
11184             /* Friends are treated specially.  */
11185             if (ctype == current_class_type)
11186               warning ("member functions are implicitly friends of their class");
11187             else
11188               {
11189                 tree t = NULL_TREE;
11190                 if (decl && DECL_NAME (decl))
11191                   {
11192                     if (template_class_depth (current_class_type) == 0)
11193                       {
11194                         decl
11195                           = check_explicit_specialization
11196                           (declarator, decl,
11197                            template_count, 2 * (funcdef_flag != 0) + 4);
11198                         if (decl == error_mark_node)
11199                           return error_mark_node;
11200                       }
11201
11202                     t = do_friend (ctype, declarator, decl,
11203                                    last_function_parms, flags, quals,
11204                                    funcdef_flag);
11205                   }
11206                 if (t && funcdef_flag)
11207                   return t;
11208
11209                 return void_type_node;
11210               }
11211           }
11212
11213         /* Structure field.  It may not be a function, except for C++ */
11214
11215         if (decl == NULL_TREE)
11216           {
11217             if (initialized)
11218               {
11219                 if (!staticp)
11220                   {
11221                     /* An attempt is being made to initialize a non-static
11222                        member.  But, from [class.mem]:
11223
11224                        4 A member-declarator can contain a
11225                        constant-initializer only if it declares a static
11226                        member (_class.static_) of integral or enumeration
11227                        type, see _class.static.data_.
11228
11229                        This used to be relatively common practice, but
11230                        the rest of the compiler does not correctly
11231                        handle the initialization unless the member is
11232                        static so we make it static below.  */
11233                     cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11234                                 declarator);
11235                     cp_pedwarn ("making `%D' static", declarator);
11236                     staticp = 1;
11237                   }
11238
11239                 if (uses_template_parms (type))
11240                   /* We'll check at instantiation time.  */
11241                   ;
11242                 else if (check_static_variable_definition (declarator,
11243                                                            type))
11244                   /* If we just return the declaration, crashes
11245                      will sometimes occur.  We therefore return
11246                      void_type_node, as if this was a friend
11247                      declaration, to cause callers to completely
11248                      ignore this declaration.  */
11249                   return void_type_node;
11250               }
11251
11252             /* 9.2p13 [class.mem] */
11253             if (declarator == constructor_name (current_class_type)
11254                 /* Divergence from the standard:  In extern "C", we
11255                    allow non-static data members here, because C does
11256                    and /usr/include/netinet/in.h uses that.  */
11257                 && (staticp || ! in_system_header))
11258               cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11259                           declarator);
11260
11261             if (staticp)
11262               {
11263                 /* C++ allows static class members.
11264                    All other work for this is done by grokfield.
11265                    This VAR_DCL is built by build_lang_field_decl.
11266                    All other VAR_DECLs are built by build_decl.  */
11267                 decl = build_lang_field_decl (VAR_DECL, declarator, type);
11268                 TREE_STATIC (decl) = 1;
11269                 /* In class context, 'static' means public access.  */
11270                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11271               }
11272             else
11273               {
11274                 decl = build_lang_field_decl (FIELD_DECL, declarator, type);
11275                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11276                   {
11277                     DECL_MUTABLE_P (decl) = 1;
11278                     RIDBIT_RESET (RID_MUTABLE, specbits);
11279                   }
11280               }
11281
11282             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11283                             inlinep, friendp, raises != NULL_TREE);
11284           }
11285       }
11286     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11287       {
11288         tree original_name;
11289         int publicp = 0;
11290
11291         if (! declarator)
11292           return NULL_TREE;
11293
11294         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11295           original_name = dname;
11296         else
11297           original_name = declarator;
11298
11299         if (RIDBIT_SETP (RID_AUTO, specbits))
11300           error ("storage class `auto' invalid for function `%s'", name);
11301         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11302           error ("storage class `register' invalid for function `%s'", name);
11303
11304         /* Function declaration not at top level.
11305            Storage classes other than `extern' are not allowed
11306            and `extern' makes no difference.  */
11307         if (! toplevel_bindings_p ()
11308             && (RIDBIT_SETP (RID_STATIC, specbits)
11309                 || RIDBIT_SETP (RID_INLINE, specbits))
11310             && pedantic)
11311           {
11312             if (RIDBIT_SETP (RID_STATIC, specbits))
11313               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11314             else
11315               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11316           }
11317
11318         if (ctype == NULL_TREE)
11319           {
11320             if (virtualp)
11321               {
11322                 error ("virtual non-class function `%s'", name);
11323                 virtualp = 0;
11324               }
11325           }
11326         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11327           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11328                                           TYPE_ARG_TYPES (type));
11329
11330         /* Record presence of `static'.  */
11331         publicp = (ctype != NULL_TREE
11332                    || RIDBIT_SETP (RID_EXTERN, specbits)
11333                    || !RIDBIT_SETP (RID_STATIC, specbits));
11334
11335         decl = grokfndecl (ctype, type, original_name, declarator,
11336                            virtualp, flags, quals, raises, attrlist,
11337                            1, friendp,
11338                            publicp, inlinep, funcdef_flag,
11339                            template_count, in_namespace);
11340         if (decl == NULL_TREE)
11341           return NULL_TREE;
11342
11343         if (staticp == 1)
11344           {
11345             int illegal_static = 0;
11346
11347             /* Don't allow a static member function in a class, and forbid
11348                declaring main to be static.  */
11349             if (TREE_CODE (type) == METHOD_TYPE)
11350               {
11351                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11352                 illegal_static = 1;
11353               }
11354             else if (current_function_decl)
11355               {
11356                 /* FIXME need arm citation */
11357                 error ("cannot declare static function inside another function");
11358                 illegal_static = 1;
11359               }
11360
11361             if (illegal_static)
11362               {
11363                 staticp = 0;
11364                 RIDBIT_RESET (RID_STATIC, specbits);
11365               }
11366           }
11367       }
11368     else
11369       {
11370         /* It's a variable.  */
11371
11372         /* An uninitialized decl with `extern' is a reference.  */
11373         decl = grokvardecl (type, declarator, &specbits,
11374                             initialized,
11375                             (type_quals & TYPE_QUAL_CONST) != 0,
11376                             in_namespace);
11377         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11378                         inlinep, friendp, raises != NULL_TREE);
11379
11380         if (ctype)
11381           {
11382             DECL_CONTEXT (decl) = ctype;
11383             if (staticp == 1)
11384               {
11385                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11386                 staticp = 0;
11387                 RIDBIT_RESET (RID_STATIC, specbits);
11388               }
11389             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11390               {
11391                 cp_error ("static member `%D' declared `register'", decl);
11392                 RIDBIT_RESET (RID_REGISTER, specbits);
11393               }
11394             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11395               {
11396                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11397                             decl);
11398                 RIDBIT_RESET (RID_EXTERN, specbits);
11399               }
11400           }
11401       }
11402
11403     if (RIDBIT_SETP (RID_MUTABLE, specbits))
11404       {
11405         error ("`%s' cannot be declared mutable", name);
11406       }
11407
11408     /* Record `register' declaration for warnings on &
11409        and in case doing stupid register allocation.  */
11410
11411     if (RIDBIT_SETP (RID_REGISTER, specbits))
11412       DECL_REGISTER (decl) = 1;
11413
11414     if (RIDBIT_SETP (RID_EXTERN, specbits))
11415       DECL_THIS_EXTERN (decl) = 1;
11416
11417     if (RIDBIT_SETP (RID_STATIC, specbits))
11418       DECL_THIS_STATIC (decl) = 1;
11419
11420     /* Record constancy and volatility.  */
11421     /* FIXME: Disallow `restrict' pointer-to-member declarations.  */
11422     c_apply_type_quals_to_decl (type_quals, decl);
11423
11424     return decl;
11425   }
11426 }
11427 \f
11428 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11429    An empty exprlist is a parmlist.  An exprlist which
11430    contains only identifiers at the global level
11431    is a parmlist.  Otherwise, it is an exprlist.  */
11432
11433 int
11434 parmlist_is_exprlist (exprs)
11435      tree exprs;
11436 {
11437   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11438     return 0;
11439
11440   if (toplevel_bindings_p ())
11441     {
11442       /* At the global level, if these are all identifiers,
11443          then it is a parmlist.  */
11444       while (exprs)
11445         {
11446           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11447             return 1;
11448           exprs = TREE_CHAIN (exprs);
11449         }
11450       return 0;
11451     }
11452   return 1;
11453 }
11454
11455 /* Subroutine of start_function.  Ensure that each of the parameter
11456    types (as listed in PARMS) is complete, as is required for a
11457    function definition.  */
11458
11459 static void
11460 require_complete_types_for_parms (parms)
11461      tree parms;
11462 {
11463   while (parms)
11464     {
11465       tree type = TREE_TYPE (parms);
11466       if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
11467         {
11468           if (DECL_NAME (parms))
11469             error ("parameter `%s' has incomplete type",
11470                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11471           else
11472             error ("parameter has incomplete type");
11473           TREE_TYPE (parms) = error_mark_node;
11474         }
11475       else
11476         layout_decl (parms, 0);
11477
11478       parms = TREE_CHAIN (parms);
11479     }
11480 }
11481
11482 /* Returns DECL if DECL is a local variable (or parameter).  Returns
11483    NULL_TREE otherwise.  */
11484
11485 static tree
11486 local_variable_p (t)
11487      tree t;
11488 {
11489   if ((TREE_CODE (t) == VAR_DECL
11490        /* A VAR_DECL with a context that is a _TYPE is a static data
11491           member.  */
11492        && !TYPE_P (CP_DECL_CONTEXT (t))
11493        /* Any other non-local variable must be at namespace scope.  */
11494        && TREE_CODE (CP_DECL_CONTEXT (t)) != NAMESPACE_DECL)
11495       || (TREE_CODE (t) == PARM_DECL))
11496     return t;
11497
11498   return NULL_TREE;
11499 }
11500
11501 /* Check that ARG, which is a default-argument expression for a
11502    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11503    something goes wrong.  DECL may also be a _TYPE node, rather than a
11504    DECL, if there is no DECL available.  */
11505
11506 tree
11507 check_default_argument (decl, arg)
11508      tree decl;
11509      tree arg;
11510 {
11511   tree var;
11512   tree decl_type;
11513
11514   if (TREE_CODE (arg) == DEFAULT_ARG)
11515     /* We get a DEFAULT_ARG when looking at an in-class declaration
11516        with a default argument.  Ignore the argument for now; we'll
11517        deal with it after the class is complete.  */
11518     return arg;
11519
11520   if (processing_template_decl || uses_template_parms (arg))
11521     /* We don't do anything checking until instantiation-time.  Note
11522        that there may be uninstantiated arguments even for an
11523        instantiated function, since default arguments are not
11524        instantiated until they are needed.  */
11525     return arg;
11526
11527   if (TYPE_P (decl))
11528     {
11529       decl_type = decl;
11530       decl = NULL_TREE;
11531     }
11532   else
11533     decl_type = TREE_TYPE (decl);
11534
11535   if (arg == error_mark_node
11536       || decl == error_mark_node
11537       || TREE_TYPE (arg) == error_mark_node
11538       || decl_type == error_mark_node)
11539     /* Something already went wrong.  There's no need to check
11540        further.  */
11541     return error_mark_node;
11542
11543   /* [dcl.fct.default]
11544
11545      A default argument expression is implicitly converted to the
11546      parameter type.  */
11547   if (!TREE_TYPE (arg)
11548       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11549     {
11550       if (decl)
11551         cp_error ("default argument for `%#D' has type `%T'",
11552                   decl, TREE_TYPE (arg));
11553       else
11554         cp_error ("default argument for paramter of type `%T' has type `%T'",
11555                   decl_type, TREE_TYPE (arg));
11556
11557       return error_mark_node;
11558     }
11559
11560   /* [dcl.fct.default]
11561
11562      Local variables shall not be used in default argument
11563      expressions.
11564
11565      The keyword `this' shall not be used in a default argument of a
11566      member function.  */
11567   var = search_tree (arg, local_variable_p);
11568   if (var)
11569     {
11570       cp_error ("default argument `%E' uses local variable `%D'",
11571                 arg, var);
11572       return error_mark_node;
11573     }
11574
11575   /* All is well.  */
11576   return arg;
11577 }
11578
11579 /* Decode the list of parameter types for a function type.
11580    Given the list of things declared inside the parens,
11581    return a list of types.
11582
11583    The list we receive can have three kinds of elements:
11584    an IDENTIFIER_NODE for names given without types,
11585    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11586    or void_type_node, to mark the end of an argument list
11587    when additional arguments are not permitted (... was not used).
11588
11589    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11590    a mere declaration.  A nonempty identifier-list gets an error message
11591    when FUNCDEF_FLAG is zero.
11592    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11593    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11594
11595    If all elements of the input list contain types,
11596    we return a list of the types.
11597    If all elements contain no type (except perhaps a void_type_node
11598    at the end), we return a null list.
11599    If some have types and some do not, it is an error, and we
11600    return a null list.
11601
11602    Also set last_function_parms to either
11603    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11604    A list of names is converted to a chain of PARM_DECLs
11605    by store_parm_decls so that ultimately it is always a chain of decls.
11606
11607    Note that in C++, parameters can take default values.  These default
11608    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11609    an error to specify default values which are followed by parameters
11610    that have no default values, or an ELLIPSES.  For simplicities sake,
11611    only parameters which are specified with their types can take on
11612    default values.  */
11613
11614 static tree
11615 grokparms (first_parm, funcdef_flag)
11616      tree first_parm;
11617      int funcdef_flag;
11618 {
11619   tree result = NULL_TREE;
11620   tree decls = NULL_TREE;
11621
11622   if (first_parm != NULL_TREE
11623       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11624     {
11625       if (! funcdef_flag)
11626         pedwarn ("parameter names (without types) in function declaration");
11627       last_function_parms = first_parm;
11628       return NULL_TREE;
11629     }
11630   else if (first_parm != NULL_TREE
11631            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11632            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11633     my_friendly_abort (145);
11634   else
11635     {
11636       /* Types were specified.  This is a list of declarators
11637          each represented as a TREE_LIST node.  */
11638       register tree parm, chain;
11639       int any_init = 0, any_error = 0;
11640
11641       if (first_parm != NULL_TREE)
11642         {
11643           tree last_result = NULL_TREE;
11644           tree last_decl = NULL_TREE;
11645
11646           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11647             {
11648               tree type = NULL_TREE, list_node = parm;
11649               register tree decl = TREE_VALUE (parm);
11650               tree init = TREE_PURPOSE (parm);
11651
11652               chain = TREE_CHAIN (parm);
11653               /* @@ weak defense against parse errors.  */
11654               if (TREE_CODE (decl) != VOID_TYPE
11655                   && TREE_CODE (decl) != TREE_LIST)
11656                 {
11657                   /* Give various messages as the need arises.  */
11658                   if (TREE_CODE (decl) == STRING_CST)
11659                     cp_error ("invalid string constant `%E'", decl);
11660                   else if (TREE_CODE (decl) == INTEGER_CST)
11661                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11662                   continue;
11663                 }
11664
11665               if (TREE_CODE (decl) != VOID_TYPE)
11666                 {
11667                   decl = grokdeclarator (TREE_VALUE (decl),
11668                                          TREE_PURPOSE (decl),
11669                                          PARM, init != NULL_TREE,
11670                                          NULL_TREE);
11671                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11672                     continue;
11673
11674                   /* Top-level qualifiers on the parameters are
11675                      ignored for function types.  */
11676                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11677
11678                   if (TREE_CODE (type) == VOID_TYPE)
11679                     decl = void_type_node;
11680                   else if (TREE_CODE (type) == METHOD_TYPE)
11681                     {
11682                       if (DECL_NAME (decl))
11683                         /* Cannot use the decl here because
11684                            we don't have DECL_CONTEXT set up yet.  */
11685                         cp_error ("parameter `%D' invalidly declared method type",
11686                                   DECL_NAME (decl));
11687                       else
11688                         error ("parameter invalidly declared method type");
11689                       type = build_pointer_type (type);
11690                       TREE_TYPE (decl) = type;
11691                     }
11692                   else if (TREE_CODE (type) == OFFSET_TYPE)
11693                     {
11694                       if (DECL_NAME (decl))
11695                         cp_error ("parameter `%D' invalidly declared offset type",
11696                                   DECL_NAME (decl));
11697                       else
11698                         error ("parameter invalidly declared offset type");
11699                       type = build_pointer_type (type);
11700                       TREE_TYPE (decl) = type;
11701                     }
11702                   else if (TREE_CODE (type) == RECORD_TYPE
11703                            && TYPE_LANG_SPECIFIC (type)
11704                            && CLASSTYPE_ABSTRACT_VIRTUALS (type))
11705                     {
11706                       abstract_virtuals_error (decl, type);
11707                       any_error = 1;  /* Seems like a good idea. */
11708                     }
11709                   else if (TREE_CODE (type) == RECORD_TYPE
11710                            && TYPE_LANG_SPECIFIC (type)
11711                            && IS_SIGNATURE (type))
11712                     {
11713                       signature_error (decl, type);
11714                       any_error = 1;  /* Seems like a good idea. */
11715                     }
11716                   else if (POINTER_TYPE_P (type))
11717                     {
11718                       tree t = type;
11719                       while (POINTER_TYPE_P (t)
11720                              || (TREE_CODE (t) == ARRAY_TYPE
11721                                  && TYPE_DOMAIN (t) != NULL_TREE))
11722                         t = TREE_TYPE (t);
11723                       if (TREE_CODE (t) == ARRAY_TYPE)
11724                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11725                                   type,
11726                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11727                     }
11728                 }
11729
11730               if (TREE_CODE (decl) == VOID_TYPE)
11731                 {
11732                   if (result == NULL_TREE)
11733                     {
11734                       result = void_list_node;
11735                       last_result = result;
11736                     }
11737                   else
11738                     {
11739                       TREE_CHAIN (last_result) = void_list_node;
11740                       last_result = void_list_node;
11741                     }
11742                   if (chain
11743                       && (chain != void_list_node || TREE_CHAIN (chain)))
11744                     error ("`void' in parameter list must be entire list");
11745                   break;
11746                 }
11747
11748               /* Since there is a prototype, args are passed in their own types.  */
11749               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11750 #ifdef PROMOTE_PROTOTYPES
11751               if ((TREE_CODE (type) == INTEGER_TYPE
11752                    || TREE_CODE (type) == ENUMERAL_TYPE)
11753                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11754                 DECL_ARG_TYPE (decl) = integer_type_node;
11755 #endif
11756               if (!any_error && init)
11757                 {
11758                   any_init++;
11759                   init = check_default_argument (decl, init);
11760                 }
11761               else
11762                 init = NULL_TREE;
11763
11764               if (decls == NULL_TREE)
11765                 {
11766                   decls = decl;
11767                   last_decl = decls;
11768                 }
11769               else
11770                 {
11771                   TREE_CHAIN (last_decl) = decl;
11772                   last_decl = decl;
11773                 }
11774               if (! current_function_decl && TREE_PERMANENT (list_node))
11775                 {
11776                   TREE_PURPOSE (list_node) = init;
11777                   TREE_VALUE (list_node) = type;
11778                   TREE_CHAIN (list_node) = NULL_TREE;
11779                 }
11780               else
11781                 list_node = saveable_tree_cons (init, type, NULL_TREE);
11782               if (result == NULL_TREE)
11783                 {
11784                   result = list_node;
11785                   last_result = result;
11786                 }
11787               else
11788                 {
11789                   TREE_CHAIN (last_result) = list_node;
11790                   last_result = list_node;
11791                 }
11792             }
11793           if (last_result)
11794             TREE_CHAIN (last_result) = NULL_TREE;
11795           /* If there are no parameters, and the function does not end
11796              with `...', then last_decl will be NULL_TREE.  */
11797           if (last_decl != NULL_TREE)
11798             TREE_CHAIN (last_decl) = NULL_TREE;
11799         }
11800     }
11801
11802   last_function_parms = decls;
11803
11804   return result;
11805 }
11806
11807 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11808    FUNCTION_TYPE with the newly parsed version of its default argument, which
11809    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11810
11811 void
11812 replace_defarg (arg, init)
11813      tree arg, init;
11814 {
11815   if (! processing_template_decl
11816       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11817     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11818                 TREE_TYPE (init), TREE_VALUE (arg));
11819   TREE_PURPOSE (arg) = init;
11820 }
11821 \f
11822 int
11823 copy_args_p (d)
11824      tree d;
11825 {
11826   tree t = FUNCTION_ARG_CHAIN (d);
11827   if (DECL_CONSTRUCTOR_P (d)
11828       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11829     t = TREE_CHAIN (t);
11830   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11831       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11832           == DECL_CLASS_CONTEXT (d))
11833       && (TREE_CHAIN (t) == NULL_TREE
11834           || TREE_CHAIN (t) == void_list_node
11835           || TREE_PURPOSE (TREE_CHAIN (t))))
11836     return 1;
11837   return 0;
11838 }
11839
11840 /* These memoizing functions keep track of special properties which
11841    a class may have.  `grok_ctor_properties' notices whether a class
11842    has a constructor of the form X(X&), and also complains
11843    if the class has a constructor of the form X(X).
11844    `grok_op_properties' takes notice of the various forms of
11845    operator= which are defined, as well as what sorts of type conversion
11846    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11847
11848 int
11849 grok_ctor_properties (ctype, decl)
11850      tree ctype, decl;
11851 {
11852   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11853   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11854
11855   /* When a type has virtual baseclasses, a magical first int argument is
11856      added to any ctor so we can tell if the class has been initialized
11857      yet.  This could screw things up in this function, so we deliberately
11858      ignore the leading int if we're in that situation.  */
11859   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11860     {
11861       my_friendly_assert (parmtypes
11862                           && TREE_VALUE (parmtypes) == integer_type_node,
11863                           980529);
11864       parmtypes = TREE_CHAIN (parmtypes);
11865       parmtype = TREE_VALUE (parmtypes);
11866     }
11867
11868   /* [class.copy]
11869
11870      A non-template constructor for class X is a copy constructor if
11871      its first parameter is of type X&, const X&, volatile X& or const
11872      volatile X&, and either there are no other parameters or else all
11873      other parameters have default arguments.  */
11874   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11875       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11876       && (TREE_CHAIN (parmtypes) == NULL_TREE
11877           || TREE_CHAIN (parmtypes) == void_list_node
11878           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11879       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11880            && is_member_template (DECL_TI_TEMPLATE (decl))))
11881     {
11882       TYPE_HAS_INIT_REF (ctype) = 1;
11883       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11884         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11885     }
11886   /* [class.copy]
11887
11888      A declaration of a constructor for a class X is ill-formed if its
11889      first parameter is of type (optionally cv-qualified) X and either
11890      there are no other parameters or else all other parameters have
11891      default arguments.
11892
11893      We *don't* complain about member template instantiations that
11894      have this form, though; they can occur as we try to decide what
11895      constructor to use during overload resolution.  Since overload
11896      resolution will never prefer such a constructor to the
11897      non-template copy constructor (which is either explicitly or
11898      implicitly defined), there's no need to worry about their
11899      existence.  Theoretically, they should never even be
11900      instantiated, but that's hard to forestall.  */
11901   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11902            && (TREE_CHAIN (parmtypes) == NULL_TREE
11903                || TREE_CHAIN (parmtypes) == void_list_node
11904                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11905            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11906                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11907     {
11908       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11909                 ctype, ctype);
11910       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11911       return 0;
11912     }
11913   else if (TREE_CODE (parmtype) == VOID_TYPE
11914            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11915     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11916
11917   return 1;
11918 }
11919
11920 /* An operator with this name can be either unary or binary.  */
11921
11922 static int
11923 ambi_op_p (name)
11924      tree name;
11925 {
11926   return (name == ansi_opname [(int) INDIRECT_REF]
11927           || name == ansi_opname [(int) ADDR_EXPR]
11928           || name == ansi_opname [(int) NEGATE_EXPR]
11929           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11930           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11931           || name == ansi_opname [(int) CONVERT_EXPR]);
11932 }
11933
11934 /* An operator with this name can only be unary.  */
11935
11936 static int
11937 unary_op_p (name)
11938      tree name;
11939 {
11940   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11941           || name == ansi_opname [(int) BIT_NOT_EXPR]
11942           || name == ansi_opname [(int) COMPONENT_REF]
11943           || IDENTIFIER_TYPENAME_P (name));
11944 }
11945
11946 /* Do a little sanity-checking on how they declared their operator.  */
11947
11948 void
11949 grok_op_properties (decl, virtualp, friendp)
11950      tree decl;
11951      int virtualp, friendp;
11952 {
11953   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11954   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11955   tree name = DECL_NAME (decl);
11956
11957   if (current_class_type == NULL_TREE)
11958     friendp = 1;
11959
11960   if (! friendp)
11961     {
11962       /* [class.copy]
11963
11964          A user-declared copy assignment operator X::operator= is a
11965          non-static non-template member function of class X with
11966          exactly one parameter of type X, X&, const X&, volatile X& or
11967          const volatile X&.  */
11968       if (name == ansi_opname[(int) MODIFY_EXPR]
11969           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11970                && is_member_template (DECL_TI_TEMPLATE (decl))))
11971         ;
11972       else if (name == ansi_opname[(int) CALL_EXPR])
11973         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11974       else if (name == ansi_opname[(int) ARRAY_REF])
11975         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11976       else if (name == ansi_opname[(int) COMPONENT_REF]
11977                || name == ansi_opname[(int) MEMBER_REF])
11978         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11979       else if (name == ansi_opname[(int) NEW_EXPR])
11980         TYPE_GETS_NEW (current_class_type) |= 1;
11981       else if (name == ansi_opname[(int) DELETE_EXPR])
11982         TYPE_GETS_DELETE (current_class_type) |= 1;
11983       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11984         TYPE_GETS_NEW (current_class_type) |= 2;
11985       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11986         TYPE_GETS_DELETE (current_class_type) |= 2;
11987     }
11988
11989   if (name == ansi_opname[(int) NEW_EXPR]
11990       || name == ansi_opname[(int) VEC_NEW_EXPR])
11991     {
11992       /* When the compiler encounters the definition of A::operator new, it
11993          doesn't look at the class declaration to find out if it's static.  */
11994       if (methodp)
11995         revert_static_member_fn (&decl, NULL, NULL);
11996
11997       /* Take care of function decl if we had syntax errors.  */
11998       if (argtypes == NULL_TREE)
11999         TREE_TYPE (decl)
12000           = build_function_type (ptr_type_node,
12001                                  hash_tree_chain (integer_type_node,
12002                                                   void_list_node));
12003       else
12004         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12005     }
12006   else if (name == ansi_opname[(int) DELETE_EXPR]
12007            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12008     {
12009       if (methodp)
12010         revert_static_member_fn (&decl, NULL, NULL);
12011
12012       if (argtypes == NULL_TREE)
12013         TREE_TYPE (decl)
12014           = build_function_type (void_type_node,
12015                                  hash_tree_chain (ptr_type_node,
12016                                                   void_list_node));
12017       else
12018         {
12019           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12020
12021           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
12022               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
12023                   != void_list_node))
12024             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
12025         }
12026     }
12027   else
12028     {
12029       /* An operator function must either be a non-static member function
12030          or have at least one parameter of a class, a reference to a class,
12031          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12032       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12033         {
12034           if (IDENTIFIER_TYPENAME_P (name)
12035               || name == ansi_opname[(int) CALL_EXPR]
12036               || name == ansi_opname[(int) MODIFY_EXPR]
12037               || name == ansi_opname[(int) COMPONENT_REF]
12038               || name == ansi_opname[(int) ARRAY_REF])
12039             cp_error ("`%D' must be a nonstatic member function", decl);
12040           else
12041             {
12042               tree p = argtypes;
12043
12044               if (DECL_STATIC_FUNCTION_P (decl))
12045                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12046
12047               if (p)
12048                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12049                   {
12050                     tree arg = TREE_VALUE (p);
12051                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12052                       arg = TREE_TYPE (arg);
12053
12054                     /* This lets bad template code slip through.  */
12055                     if (IS_AGGR_TYPE (arg)
12056                         || TREE_CODE (arg) == ENUMERAL_TYPE
12057                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12058                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12059                       goto foundaggr;
12060                   }
12061               cp_error
12062                 ("`%D' must have an argument of class or enumerated type",
12063                  decl);
12064             foundaggr:
12065               ;
12066             }
12067         }
12068
12069       if (name == ansi_opname[(int) CALL_EXPR])
12070         return;                 /* No restrictions on args. */
12071
12072       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12073         {
12074           tree t = TREE_TYPE (name);
12075           if (TREE_CODE (t) == VOID_TYPE)
12076             pedwarn ("void is not a valid type conversion operator");
12077           else if (! friendp)
12078             {
12079               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12080               const char *what = 0;
12081               if (ref)
12082                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12083
12084               if (t == current_class_type)
12085                 what = "the same type";
12086               /* Don't force t to be complete here.  */
12087               else if (IS_AGGR_TYPE (t)
12088                        && TYPE_SIZE (t)
12089                        && DERIVED_FROM_P (t, current_class_type))
12090                 what = "a base class";
12091
12092               if (what)
12093                 warning ("conversion to %s%s will never use a type conversion operator",
12094                          ref ? "a reference to " : "", what);
12095             }
12096         }
12097
12098       if (name == ansi_opname[(int) MODIFY_EXPR])
12099         {
12100           tree parmtype;
12101
12102           if (list_length (argtypes) != 3 && methodp)
12103             {
12104               cp_error ("`%D' must take exactly one argument", decl);
12105               return;
12106             }
12107           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12108
12109           if (copy_assignment_arg_p (parmtype, virtualp)
12110               && ! friendp)
12111             {
12112               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12113               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12114                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12115                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12116             }
12117         }
12118       else if (name == ansi_opname[(int) COND_EXPR])
12119         {
12120           /* 13.4.0.3 */
12121           pedwarn ("ANSI C++ prohibits overloading operator ?:");
12122           if (list_length (argtypes) != 4)
12123             cp_error ("`%D' must take exactly three arguments", decl);
12124         }
12125       else if (ambi_op_p (name))
12126         {
12127           if (list_length (argtypes) == 2)
12128             /* prefix */;
12129           else if (list_length (argtypes) == 3)
12130             {
12131               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12132                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12133                   && ! processing_template_decl
12134                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12135                 {
12136                   if (methodp)
12137                     cp_error ("postfix `%D' must take `int' as its argument",
12138                               decl);
12139                   else
12140                     cp_error
12141                       ("postfix `%D' must take `int' as its second argument",
12142                        decl);
12143                 }
12144             }
12145           else
12146             {
12147               if (methodp)
12148                 cp_error ("`%D' must take either zero or one argument", decl);
12149               else
12150                 cp_error ("`%D' must take either one or two arguments", decl);
12151             }
12152
12153           /* More Effective C++ rule 6.  */
12154           if (warn_ecpp
12155               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12156                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12157             {
12158               tree arg = TREE_VALUE (argtypes);
12159               tree ret = TREE_TYPE (TREE_TYPE (decl));
12160               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12161                 arg = TREE_TYPE (arg);
12162               arg = TYPE_MAIN_VARIANT (arg);
12163               if (list_length (argtypes) == 2)
12164                 {
12165                   if (TREE_CODE (ret) != REFERENCE_TYPE
12166                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12167                                        arg))
12168                     cp_warning ("prefix `%D' should return `%T'", decl,
12169                                 build_reference_type (arg));
12170                 }
12171               else
12172                 {
12173                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12174                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12175                 }
12176             }
12177         }
12178       else if (unary_op_p (name))
12179         {
12180           if (list_length (argtypes) != 2)
12181             {
12182               if (methodp)
12183                 cp_error ("`%D' must take `void'", decl);
12184               else
12185                 cp_error ("`%D' must take exactly one argument", decl);
12186             }
12187         }
12188       else /* if (binary_op_p (name)) */
12189         {
12190           if (list_length (argtypes) != 3)
12191             {
12192               if (methodp)
12193                 cp_error ("`%D' must take exactly one argument", decl);
12194               else
12195                 cp_error ("`%D' must take exactly two arguments", decl);
12196             }
12197
12198           /* More Effective C++ rule 7.  */
12199           if (warn_ecpp
12200               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12201                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12202                   || name == ansi_opname [COMPOUND_EXPR]))
12203             cp_warning ("user-defined `%D' always evaluates both arguments",
12204                         decl);
12205         }
12206
12207       /* Effective C++ rule 23.  */
12208       if (warn_ecpp
12209           && list_length (argtypes) == 3
12210           && (name == ansi_opname [PLUS_EXPR]
12211               || name == ansi_opname [MINUS_EXPR]
12212               || name == ansi_opname [TRUNC_DIV_EXPR]
12213               || name == ansi_opname [MULT_EXPR])
12214           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12215         cp_warning ("`%D' should return by value", decl);
12216
12217       /* 13.4.0.8 */
12218       if (argtypes)
12219         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12220           if (TREE_PURPOSE (argtypes))
12221             {
12222               TREE_PURPOSE (argtypes) = NULL_TREE;
12223               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12224                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12225                 {
12226                   if (pedantic)
12227                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12228                 }
12229               else
12230                 cp_error ("`%D' cannot have default arguments", decl);
12231             }
12232     }
12233 }
12234 \f
12235 static const char *
12236 tag_name (code)
12237      enum tag_types code;
12238 {
12239   switch (code)
12240     {
12241     case record_type:
12242       return "struct";
12243     case class_type:
12244       return "class";
12245     case union_type:
12246       return "union ";
12247     case enum_type:
12248       return "enum";
12249     case signature_type:
12250       return "signature";
12251     default:
12252       my_friendly_abort (981122);
12253     }
12254 }
12255
12256 /* Get the struct, enum or union (CODE says which) with tag NAME.
12257    Define the tag as a forward-reference if it is not defined.
12258
12259    C++: If a class derivation is given, process it here, and report
12260    an error if multiple derivation declarations are not identical.
12261
12262    If this is a definition, come in through xref_tag and only look in
12263    the current frame for the name (since C++ allows new names in any
12264    scope.)  */
12265
12266 tree
12267 xref_tag (code_type_node, name, globalize)
12268      tree code_type_node;
12269      tree name;
12270      int globalize;
12271 {
12272   enum tag_types tag_code;
12273   enum tree_code code;
12274   int temp = 0;
12275   register tree ref, t;
12276   struct binding_level *b = current_binding_level;
12277   int got_type = 0;
12278   tree attributes = NULL_TREE;
12279
12280   /* If we are called from the parser, code_type_node will sometimes be a
12281      TREE_LIST.  This indicates that the user wrote
12282      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12283      use them later.  */
12284   if (TREE_CODE (code_type_node) == TREE_LIST)
12285     {
12286       attributes = TREE_PURPOSE (code_type_node);
12287       code_type_node = TREE_VALUE (code_type_node);
12288     }
12289
12290   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12291   switch (tag_code)
12292     {
12293     case record_type:
12294     case class_type:
12295     case signature_type:
12296       code = RECORD_TYPE;
12297       break;
12298     case union_type:
12299       code = UNION_TYPE;
12300       break;
12301     case enum_type:
12302       code = ENUMERAL_TYPE;
12303       break;
12304     default:
12305       my_friendly_abort (18);
12306     }
12307
12308   /* If a cross reference is requested, look up the type
12309      already defined for this tag and return it.  */
12310   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12311     {
12312       t = name;
12313       name = TYPE_IDENTIFIER (t);
12314       got_type = 1;
12315     }
12316   else
12317     t = IDENTIFIER_TYPE_VALUE (name);
12318
12319   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12320       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12321     t = NULL_TREE;
12322
12323   if (! globalize)
12324     {
12325       /* If we know we are defining this tag, only look it up in
12326          this scope and don't try to find it as a type.  */
12327       ref = lookup_tag (code, name, b, 1);
12328     }
12329   else
12330     {
12331       if (current_class_type
12332           && template_class_depth (current_class_type)
12333           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12334       /* Since GLOBALIZE is non-zero, we are not looking at a
12335          definition of this tag.  Since, in addition, we are currently
12336          processing a (member) template declaration of a template
12337          class, we don't want to do any lookup at all; consider:
12338
12339            template <class X>
12340            struct S1
12341
12342            template <class U>
12343            struct S2
12344            { template <class V>
12345              friend struct S1; };
12346
12347          Here, the S2::S1 declaration should not be confused with the
12348          outer declaration.  In particular, the inner version should
12349          have a template parameter of level 2, not level 1.  This
12350          would be particularly important if the member declaration
12351          were instead:
12352
12353            template <class V = U> friend struct S1;
12354
12355          say, when we should tsubst into `U' when instantiating S2.  */
12356         ref = NULL_TREE;
12357       else
12358         {
12359           if (t)
12360             {
12361               /* [dcl.type.elab] If the identifier resolves to a
12362                  typedef-name or a template type-parameter, the
12363                  elaborated-type-specifier is ill-formed.  */
12364               if (t != TYPE_MAIN_VARIANT (t)
12365                   || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12366                 cp_pedwarn ("using typedef-name `%D' after `%s'",
12367                             TYPE_NAME (t), tag_name (tag_code));
12368               else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12369                 cp_error ("using template type parameter `%T' after `%s'",
12370                           t, tag_name (tag_code));
12371
12372               ref = t;
12373             }
12374           else
12375             ref = lookup_tag (code, name, b, 0);
12376
12377           if (! ref)
12378             {
12379               /* Try finding it as a type declaration.  If that wins,
12380                  use it.  */
12381               ref = lookup_name (name, 1);
12382
12383               if (ref != NULL_TREE
12384                   && processing_template_decl
12385                   && DECL_CLASS_TEMPLATE_P (ref)
12386                   && template_class_depth (current_class_type) == 0)
12387                 /* Since GLOBALIZE is true, we're declaring a global
12388                template, so we want this type.  */
12389                 ref = DECL_RESULT (ref);
12390
12391               if (ref && TREE_CODE (ref) == TYPE_DECL
12392                   && TREE_CODE (TREE_TYPE (ref)) == code)
12393                 ref = TREE_TYPE (ref);
12394               else
12395                 ref = NULL_TREE;
12396             }
12397         }
12398     }
12399
12400   push_obstacks_nochange ();
12401
12402   if (! ref)
12403     {
12404       /* If no such tag is yet defined, create a forward-reference node
12405          and record it as the "definition".
12406          When a real declaration of this type is found,
12407          the forward-reference will be altered into a real type.  */
12408
12409       /* In C++, since these migrate into the global scope, we must
12410          build them on the permanent obstack.  */
12411
12412       temp = allocation_temporary_p ();
12413       if (temp)
12414         end_temporary_allocation ();
12415
12416       if (code == ENUMERAL_TYPE)
12417         {
12418           cp_error ("use of enum `%#D' without previous declaration", name);
12419
12420           ref = make_node (ENUMERAL_TYPE);
12421
12422           /* Give the type a default layout like unsigned int
12423              to avoid crashing if it does not get defined.  */
12424           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12425           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12426           TREE_UNSIGNED (ref) = 1;
12427           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12428           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12429           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12430
12431           /* Enable us to recognize when a type is created in class context.
12432              To do nested classes correctly, this should probably be cleared
12433              out when we leave this classes scope.  Currently this in only
12434              done in `start_enum'.  */
12435
12436           pushtag (name, ref, globalize);
12437         }
12438       else
12439         {
12440           struct binding_level *old_b = class_binding_level;
12441
12442           ref = make_lang_type (code);
12443
12444           if (tag_code == signature_type)
12445             {
12446               SET_SIGNATURE (ref);
12447               /* Since a signature type will be turned into the type
12448                  of signature tables, it's not only an interface.  */
12449               CLASSTYPE_INTERFACE_ONLY (ref) = 0;
12450               SET_CLASSTYPE_INTERFACE_KNOWN (ref);
12451               /* A signature doesn't have a vtable.  */
12452               CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
12453             }
12454
12455 #ifdef NONNESTED_CLASSES
12456           /* Class types don't nest the way enums do.  */
12457           class_binding_level = (struct binding_level *)0;
12458 #endif
12459           pushtag (name, ref, globalize);
12460           class_binding_level = old_b;
12461         }
12462     }
12463   else
12464     {
12465       /* If it no longer looks like a nested type, make sure it's
12466          in global scope.
12467          If it is not an IDENTIFIER, this is not a declaration */
12468       if (b->namespace_p && !class_binding_level
12469           && TREE_CODE (name) == IDENTIFIER_NODE)
12470         {
12471           if (IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
12472             SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
12473         }
12474
12475       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12476         redeclare_class_template (ref, current_template_parms);
12477     }
12478
12479   /* Until the type is defined, tentatively accept whatever
12480      structure tag the user hands us.  */
12481   if (TYPE_SIZE (ref) == NULL_TREE
12482       && ref != current_class_type
12483       /* Have to check this, in case we have contradictory tag info.  */
12484       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12485     {
12486       if (tag_code == class_type)
12487         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12488       else if (tag_code == record_type || tag_code == signature_type)
12489         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12490     }
12491
12492   pop_obstacks ();
12493
12494   TREE_TYPE (ref) = attributes;
12495
12496   return ref;
12497 }
12498
12499 tree
12500 xref_tag_from_type (old, id, globalize)
12501      tree old, id;
12502      int globalize;
12503 {
12504   tree code_type_node;
12505
12506   if (TREE_CODE (old) == RECORD_TYPE)
12507     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12508                       ? class_type_node : record_type_node);
12509   else
12510     code_type_node = union_type_node;
12511
12512   if (id == NULL_TREE)
12513     id = TYPE_IDENTIFIER (old);
12514
12515   return xref_tag (code_type_node, id, globalize);
12516 }
12517
12518 /* REF is a type (named NAME), for which we have just seen some
12519    baseclasses.  BINFO is a list of those baseclasses; the
12520    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12521    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12522    struct, or union.  */
12523
12524 void
12525 xref_basetypes (code_type_node, name, ref, binfo)
12526      tree code_type_node;
12527      tree name, ref;
12528      tree binfo;
12529 {
12530   /* In the declaration `A : X, Y, ... Z' we mark all the types
12531      (A, X, Y, ..., Z) so we can check for duplicates.  */
12532   tree binfos;
12533   tree base;
12534
12535   int i, len;
12536   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12537
12538   if (tag_code == union_type)
12539     {
12540       cp_error ("derived union `%T' invalid", ref);
12541       return;
12542     }
12543
12544   len = list_length (binfo);
12545   push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
12546
12547   /* First, make sure that any templates in base-classes are
12548      instantiated.  This ensures that if we call ourselves recursively
12549      we do not get confused about which classes are marked and which
12550      are not.  */
12551   for (base = binfo; base; base = TREE_CHAIN (base))
12552     complete_type (TREE_VALUE (base));
12553
12554   SET_CLASSTYPE_MARKED (ref);
12555   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12556
12557   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12558     {
12559       /* The base of a derived struct is public by default.  */
12560       int via_public
12561         = (TREE_PURPOSE (binfo) == access_public_node
12562            || TREE_PURPOSE (binfo) == access_public_virtual_node
12563            || (tag_code != class_type
12564                && (TREE_PURPOSE (binfo) == access_default_node
12565                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12566       int via_protected
12567         = (TREE_PURPOSE (binfo) == access_protected_node
12568            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12569       int via_virtual
12570         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12571            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12572            || TREE_PURPOSE (binfo) == access_public_virtual_node
12573            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12574       tree basetype = TREE_VALUE (binfo);
12575       tree base_binfo;
12576
12577       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12578         basetype = TREE_TYPE (basetype);
12579       if (!basetype
12580           || (TREE_CODE (basetype) != RECORD_TYPE
12581               && TREE_CODE (basetype) != TYPENAME_TYPE
12582               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12583               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12584         {
12585           cp_error ("base type `%T' fails to be a struct or class type",
12586                     TREE_VALUE (binfo));
12587           continue;
12588         }
12589
12590       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12591
12592       /* This code replaces similar code in layout_basetypes.
12593          We put the complete_type first for implicit `typename'.  */
12594       if (TYPE_SIZE (basetype) == NULL_TREE
12595           && ! (current_template_parms && uses_template_parms (basetype)))
12596         {
12597           cp_error ("base class `%T' has incomplete type", basetype);
12598           continue;
12599         }
12600       else
12601         {
12602           if (CLASSTYPE_MARKED (basetype))
12603             {
12604               if (basetype == ref)
12605                 cp_error ("recursive type `%T' undefined", basetype);
12606               else
12607                 cp_error ("duplicate base type `%T' invalid", basetype);
12608               continue;
12609             }
12610
12611           if (TYPE_FOR_JAVA (basetype)
12612               && current_lang_stack == current_lang_base)
12613             TYPE_FOR_JAVA (ref) = 1;
12614
12615           /* Note that the BINFO records which describe individual
12616              inheritances are *not* shared in the lattice!  They
12617              cannot be shared because a given baseclass may be
12618              inherited with different `accessibility' by different
12619              derived classes.  (Each BINFO record describing an
12620              individual inheritance contains flags which say what
12621              the `accessibility' of that particular inheritance is.)  */
12622
12623           base_binfo
12624             = make_binfo (integer_zero_node, basetype,
12625                           CLASS_TYPE_P (basetype)
12626                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12627                           CLASS_TYPE_P (basetype)
12628                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12629
12630           TREE_VEC_ELT (binfos, i) = base_binfo;
12631           TREE_VIA_PUBLIC (base_binfo) = via_public;
12632           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12633           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12634           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12635
12636           /* We need to unshare the binfos now so that lookups during class
12637              definition work.  */
12638           unshare_base_binfos (base_binfo);
12639
12640           SET_CLASSTYPE_MARKED (basetype);
12641
12642           /* We are free to modify these bits because they are meaningless
12643              at top level, and BASETYPE is a top-level type.  */
12644           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12645             {
12646               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12647               TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
12648             }
12649
12650           if (CLASS_TYPE_P (basetype))
12651             {
12652               TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12653               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12654             }
12655
12656           i += 1;
12657         }
12658     }
12659   if (i)
12660     TREE_VEC_LENGTH (binfos) = i;
12661   else
12662     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12663
12664   if (i > 1)
12665     TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12666   else if (i == 1)
12667     {
12668       tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, 0));
12669
12670       if (CLASS_TYPE_P (basetype))
12671         TYPE_USES_MULTIPLE_INHERITANCE (ref)
12672           = TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12673     }
12674
12675   if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
12676     TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
12677
12678   /* Unmark all the types.  */
12679   while (--i >= 0)
12680     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12681   CLEAR_CLASSTYPE_MARKED (ref);
12682
12683   /* Now that we know all the base-classes, set up the list of virtual
12684      bases.  */
12685   CLASSTYPE_VBASECLASSES (ref) = get_vbase_types (ref);
12686
12687   pop_obstacks ();
12688 }
12689
12690 \f
12691 /* Begin compiling the definition of an enumeration type.
12692    NAME is its name (or null if anonymous).
12693    Returns the type object, as yet incomplete.
12694    Also records info about it so that build_enumerator
12695    may be used to declare the individual values as they are read.  */
12696
12697 tree
12698 start_enum (name)
12699      tree name;
12700 {
12701   register tree enumtype = NULL_TREE;
12702   struct binding_level *b = current_binding_level;
12703
12704   /* We are wasting space here and putting these on the permanent_obstack so
12705      that typeid(local enum) will work correctly. */
12706   push_obstacks (&permanent_obstack, &permanent_obstack);
12707
12708   /* If this is the real definition for a previous forward reference,
12709      fill in the contents in the same object that used to be the
12710      forward reference.  */
12711
12712   if (name != NULL_TREE)
12713     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12714
12715   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12716     cp_error ("multiple definition of `%#T'", enumtype);
12717   else
12718     {
12719       enumtype = make_node (ENUMERAL_TYPE);
12720       pushtag (name, enumtype, 0);
12721     }
12722
12723   if (current_class_type)
12724     TREE_ADDRESSABLE (b->tags) = 1;
12725
12726   /* We don't copy this value because build_enumerator needs to do it.  */
12727   enum_next_value = integer_zero_node;
12728   enum_overflow = 0;
12729
12730   GNU_xref_decl (current_function_decl, enumtype);
12731   return enumtype;
12732 }
12733
12734 /* After processing and defining all the values of an enumeration type,
12735    install their decls in the enumeration type and finish it off.
12736    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12737    Returns ENUMTYPE.  */
12738
12739 tree
12740 finish_enum (enumtype)
12741      tree enumtype;
12742 {
12743   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12744   /* Calculate the maximum value of any enumerator in this type.  */
12745
12746   tree values = TYPE_VALUES (enumtype);
12747   if (values)
12748     {
12749       tree pair;
12750
12751       for (pair = values; pair; pair = TREE_CHAIN (pair))
12752         {
12753           tree decl;
12754           tree value;
12755
12756           /* The TREE_VALUE is a CONST_DECL for this enumeration
12757              constant.  */
12758           decl = TREE_VALUE (pair);
12759
12760           /* The DECL_INITIAL will be NULL if we are processing a
12761              template declaration and this enumeration constant had no
12762              explicit initializer.  */
12763           value = DECL_INITIAL (decl);
12764           if (value && !processing_template_decl)
12765             {
12766               /* Set the TREE_TYPE for the VALUE as well.  That's so
12767                  that when we call decl_constant_value we get an
12768                  entity of the right type (but with the constant
12769                  value).  Since we shouldn't ever call
12770                  decl_constant_value on a template type, there's no
12771                  reason to do that when processing_template_decl.
12772                  And, if the expression is something like a
12773                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12774                  wreak havoc on the intended type of the expression.
12775
12776                  Of course, there's also no point in trying to compute
12777                  minimum or maximum values if we're in a template.  */
12778               TREE_TYPE (value) = enumtype;
12779
12780               if (!minnode)
12781                 minnode = maxnode = value;
12782               else if (tree_int_cst_lt (maxnode, value))
12783                 maxnode = value;
12784               else if (tree_int_cst_lt (value, minnode))
12785                 minnode = value;
12786             }
12787
12788           if (processing_template_decl)
12789             /* If this is just a template, leave the CONST_DECL
12790                alone.  That way tsubst_copy will find CONST_DECLs for
12791                CONST_DECLs, and not INTEGER_CSTs.  */
12792             ;
12793           else
12794             /* In the list we're building up, we want the enumeration
12795                values, not the CONST_DECLs.  */
12796             TREE_VALUE (pair) = value;
12797         }
12798     }
12799   else
12800     maxnode = minnode = integer_zero_node;
12801
12802   TYPE_VALUES (enumtype) = nreverse (values);
12803
12804   if (processing_template_decl)
12805     {
12806       tree scope = current_scope ();
12807       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12808         add_tree (build_min (TAG_DEFN, enumtype));
12809     }
12810   else
12811     {
12812       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12813       int lowprec = min_precision (minnode, unsignedp);
12814       int highprec = min_precision (maxnode, unsignedp);
12815       int precision = MAX (lowprec, highprec);
12816       tree tem;
12817
12818       TYPE_SIZE (enumtype) = NULL_TREE;
12819
12820       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12821
12822       TYPE_PRECISION (enumtype) = precision;
12823       if (unsignedp)
12824         fixup_unsigned_type (enumtype);
12825       else
12826         fixup_signed_type (enumtype);
12827
12828       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12829         /* Use the width of the narrowest normal C type which is wide
12830            enough.  */
12831         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12832                                                     (precision, 1));
12833       else
12834         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12835
12836       TYPE_SIZE (enumtype) = 0;
12837       layout_type (enumtype);
12838
12839       /* Fix up all variant types of this enum type.  */
12840       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12841            tem = TYPE_NEXT_VARIANT (tem))
12842         {
12843           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12844           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12845           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12846           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12847           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12848           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12849           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12850           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12851           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12852         }
12853
12854       /* Finish debugging output for this type.  */
12855       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12856     }
12857
12858   /* In start_enum we pushed obstacks.  Here, we must pop them.  */
12859   pop_obstacks ();
12860
12861   return enumtype;
12862 }
12863
12864 /* Build and install a CONST_DECL for an enumeration constant of the
12865    enumeration type TYPE whose NAME and VALUE (if any) are provided.
12866    Assignment of sequential values by default is handled here.  */
12867
12868 tree
12869 build_enumerator (name, value, type)
12870      tree name;
12871      tree value;
12872      tree type;
12873 {
12874   tree decl, result;
12875   tree context;
12876
12877   /* Remove no-op casts from the value.  */
12878   if (value)
12879     STRIP_TYPE_NOPS (value);
12880
12881  if (! processing_template_decl)
12882    {
12883      /* Validate and default VALUE.  */
12884      if (value != NULL_TREE)
12885        {
12886          if (TREE_READONLY_DECL_P (value))
12887            value = decl_constant_value (value);
12888
12889          if (TREE_CODE (value) == INTEGER_CST)
12890            {
12891              value = default_conversion (value);
12892              constant_expression_warning (value);
12893            }
12894          else
12895            {
12896              cp_error ("enumerator value for `%D' not integer constant", name);
12897              value = NULL_TREE;
12898            }
12899        }
12900
12901      /* Default based on previous value.  */
12902      if (value == NULL_TREE && ! processing_template_decl)
12903        {
12904          value = enum_next_value;
12905          if (enum_overflow)
12906            cp_error ("overflow in enumeration values at `%D'", name);
12907        }
12908
12909      /* Remove no-op casts from the value.  */
12910      if (value)
12911        STRIP_TYPE_NOPS (value);
12912 #if 0
12913      /* To fix MAX_VAL enum consts. (bkoz)  */
12914      TREE_TYPE (value) = integer_type_node;
12915 #endif
12916    }
12917
12918  /* We always have to copy here; not all INTEGER_CSTs are unshared.
12919     Even in other cases, we will later (in finish_enum) be setting the
12920     type of VALUE.  */
12921  if (value != NULL_TREE)
12922    value = copy_node (value);
12923
12924   /* C++ associates enums with global, function, or class declarations.  */
12925
12926  context = current_scope ();
12927  if (context && context == current_class_type)
12928    /* This enum declaration is local to the class.  */
12929    decl = build_lang_field_decl (CONST_DECL, name, type);
12930  else
12931    /* It's a global enum, or it's local to a function.  (Note local to
12932       a function could mean local to a class method.  */
12933    decl = build_decl (CONST_DECL, name, type);
12934
12935  DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12936  DECL_INITIAL (decl) = value;
12937  TREE_READONLY (decl) = 1;
12938
12939  if (context && context == current_class_type)
12940    /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12941       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12942       things like `S::i' later.)  */
12943    finish_member_declaration (decl);
12944  else
12945    {
12946      pushdecl (decl);
12947      GNU_xref_decl (current_function_decl, decl);
12948    }
12949
12950  if (! processing_template_decl)
12951    {
12952      /* Set basis for default for next value.  */
12953      enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
12954                                                   integer_one_node, PLUS_EXPR);
12955      enum_overflow = tree_int_cst_lt (enum_next_value, value);
12956    }
12957
12958   result = saveable_tree_cons (name, decl, NULL_TREE);
12959   return result;
12960 }
12961
12962 \f
12963 static int function_depth;
12964
12965 /* Create the FUNCTION_DECL for a function definition.
12966    DECLSPECS and DECLARATOR are the parts of the declaration;
12967    they describe the function's name and the type it returns,
12968    but twisted together in a fashion that parallels the syntax of C.
12969
12970    If PRE_PARSED_P is non-zero then DECLARATOR is really the DECL for
12971    the function we are about to process; DECLSPECS are ignored.  For
12972    example, we set PRE_PARSED_P when processing the definition of
12973    inline function that was defined in-class; the definition is
12974    actually processed when the class is complete.  In this case,
12975    PRE_PARSED_P is 2.  We also set PRE_PARSED_P when instanting the
12976    body of a template function, and when constructing thunk functions
12977    and such; in these cases PRE_PARSED_P is 1.
12978
12979    This function creates a binding context for the function body
12980    as well as setting up the FUNCTION_DECL in current_function_decl.
12981
12982    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12983    (it defines a datum instead), we return 0, which tells
12984    yyparse to report a parse error.
12985
12986    For C++, we must first check whether that datum makes any sense.
12987    For example, "class A local_a(1,2);" means that variable local_a
12988    is an aggregate of type A, which should have a constructor
12989    applied to it with the argument list [1, 2].
12990
12991    @@ There is currently no way to retrieve the storage
12992    @@ allocated to FUNCTION (or all of its parms) if we return
12993    @@ something we had previously.  */
12994
12995 int
12996 start_function (declspecs, declarator, attrs, pre_parsed_p)
12997      tree declspecs, declarator, attrs;
12998      int pre_parsed_p;
12999 {
13000   tree decl1;
13001   tree ctype = NULL_TREE;
13002   tree fntype;
13003   tree restype;
13004   extern int have_extern_spec;
13005   extern int used_extern_spec;
13006   int doing_friend = 0;
13007
13008   /* Sanity check.  */
13009   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13010   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13011
13012   /* Assume, until we see it does.  */
13013   current_function_returns_value = 0;
13014   current_function_returns_null = 0;
13015   named_labels = 0;
13016   shadowed_labels = 0;
13017   current_function_assigns_this = 0;
13018   current_function_just_assigned_this = 0;
13019   current_function_parms_stored = 0;
13020   original_result_rtx = NULL_RTX;
13021   base_init_expr = NULL_TREE;
13022   current_base_init_list = NULL_TREE;
13023   current_member_init_list = NULL_TREE;
13024   ctor_label = dtor_label = NULL_TREE;
13025   static_labelno = 0;
13026
13027   clear_temp_name ();
13028
13029   /* This should only be done once on the top most decl.  */
13030   if (have_extern_spec && !used_extern_spec)
13031     {
13032       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13033       used_extern_spec = 1;
13034     }
13035
13036   if (pre_parsed_p)
13037     {
13038       decl1 = declarator;
13039
13040 #if 0
13041       /* What was this testing for, exactly?  */
13042       if (! DECL_ARGUMENTS (decl1)
13043           && !DECL_STATIC_FUNCTION_P (decl1)
13044           && !DECL_ARTIFICIAL (decl1)
13045           && DECL_CLASS_SCOPE_P (decl1)
13046           && TYPE_IDENTIFIER (DECL_CONTEXT (decl1))
13047           && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1))))
13048         {
13049           tree binding = binding_for_name (DECL_NAME (decl1),
13050                                            current_namespace);
13051           cp_error ("redeclaration of `%#D'", decl1);
13052           if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
13053             cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
13054           else if (BINDING_VALUE (binding))
13055             cp_error_at ("previous declaration here", BINDING_VALUE (binding));
13056         }
13057 #endif
13058
13059       fntype = TREE_TYPE (decl1);
13060       if (TREE_CODE (fntype) == METHOD_TYPE)
13061         ctype = TYPE_METHOD_BASETYPE (fntype);
13062
13063       /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
13064          class is in the (lexical) scope of the class in which it is
13065          defined.  */
13066       if (!ctype && DECL_FRIEND_P (decl1))
13067         {
13068           ctype = DECL_CLASS_CONTEXT (decl1);
13069
13070           /* CTYPE could be null here if we're dealing with a template;
13071              for example, `inline friend float foo()' inside a template
13072              will have no CTYPE set.  */
13073           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13074             ctype = NULL_TREE;
13075           else
13076             doing_friend = 1;
13077         }
13078
13079       last_function_parms = DECL_ARGUMENTS (decl1);
13080       last_function_parm_tags = NULL_TREE;
13081     }
13082   else
13083     {
13084       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13085       /* If the declarator is not suitable for a function definition,
13086          cause a syntax error.  */
13087       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13088
13089       fntype = TREE_TYPE (decl1);
13090
13091       restype = TREE_TYPE (fntype);
13092       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13093         {
13094           cp_error ("semicolon missing after declaration of `%#T'", restype);
13095           shadow_tag (build_expr_list (NULL_TREE, restype));
13096           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13097           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13098             fntype = build_function_type (integer_type_node,
13099                                           TYPE_ARG_TYPES (fntype));
13100           else
13101             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13102                                               integer_type_node,
13103                                               TYPE_ARG_TYPES (fntype));
13104           TREE_TYPE (decl1) = fntype;
13105         }
13106
13107       if (TREE_CODE (fntype) == METHOD_TYPE)
13108         ctype = TYPE_METHOD_BASETYPE (fntype);
13109       else if (DECL_MAIN_P (decl1))
13110         {
13111           /* If this doesn't return integer_type, complain.  */
13112           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13113             {
13114               if (pedantic || warn_return_type)
13115                 pedwarn ("return type for `main' changed to `int'");
13116               TREE_TYPE (decl1) = fntype = default_function_type;
13117             }
13118         }
13119     }
13120
13121   /* Warn if function was previously implicitly declared
13122      (but not if we warned then).  */
13123   if (! warn_implicit
13124       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13125     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13126
13127   announce_function (decl1);
13128
13129   /* Set up current_class_type, and enter the scope of the class, if
13130      appropriate.  */
13131   if (ctype)
13132     push_nested_class (ctype, 1);
13133   else if (DECL_STATIC_FUNCTION_P (decl1))
13134     push_nested_class (DECL_CONTEXT (decl1), 2);
13135
13136   /* Now that we have entered the scope of the class, we must restore
13137      the bindings for any template parameters surrounding DECL1, if it
13138      is an inline member template.  (Order is important; consider the
13139      case where a template parameter has the same name as a field of
13140      the class.)  It is not until after this point that
13141      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13142   if (pre_parsed_p == 2)
13143     maybe_begin_member_template_processing (decl1);
13144
13145   /* We are now in the scope of the function being defined.  */
13146   current_function_decl = decl1;
13147
13148   /* Save the parm names or decls from this function's declarator
13149      where store_parm_decls will find them.  */
13150   current_function_parms = last_function_parms;
13151   current_function_parm_tags = last_function_parm_tags;
13152
13153   if (! processing_template_decl)
13154     {
13155       /* In a function definition, arg types must be complete.  */
13156       require_complete_types_for_parms (current_function_parms);
13157
13158       if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
13159         {
13160           cp_error ("return-type `%#T' is an incomplete type",
13161                     TREE_TYPE (fntype));
13162
13163           /* Make it return void instead, but don't change the
13164              type of the DECL_RESULT, in case we have a named return value.  */
13165           if (ctype)
13166             TREE_TYPE (decl1)
13167               = build_cplus_method_type (build_type_variant (ctype,
13168                                                              TREE_READONLY (decl1),
13169                                                              TREE_SIDE_EFFECTS (decl1)),
13170                                          void_type_node,
13171                                          FUNCTION_ARG_CHAIN (decl1));
13172           else
13173             TREE_TYPE (decl1)
13174               = build_function_type (void_type_node,
13175                                      TYPE_ARG_TYPES (TREE_TYPE (decl1)));
13176           DECL_RESULT (decl1)
13177             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype)));
13178           TREE_READONLY (DECL_RESULT (decl1))
13179             = CP_TYPE_CONST_P (TREE_TYPE (fntype));
13180           TREE_THIS_VOLATILE (DECL_RESULT (decl1))
13181             = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype));
13182         }
13183
13184       if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
13185           && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
13186         abstract_virtuals_error (decl1, TREE_TYPE (fntype));
13187     }
13188
13189   /* Effective C++ rule 15.  See also c_expand_return.  */
13190   if (warn_ecpp
13191       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13192       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13193     cp_warning ("`operator=' should return a reference to `*this'");
13194
13195   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13196      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13197   DECL_INITIAL (decl1) = error_mark_node;
13198
13199 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13200   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13201 #endif
13202
13203   /* This function exists in static storage.
13204      (This does not mean `static' in the C sense!)  */
13205   TREE_STATIC (decl1) = 1;
13206
13207   /* We must call push_template_decl after current_class_type is set
13208      up.  (If we are processing inline definitions after exiting a
13209      class scope, current_class_type will be NULL_TREE until set above
13210      by push_nested_class.)  */
13211   if (processing_template_decl)
13212     decl1 = push_template_decl (decl1);
13213
13214   /* Record the decl so that the function name is defined.
13215      If we already have a decl for this name, and it is a FUNCTION_DECL,
13216      use the old decl.  */
13217   if (!processing_template_decl && pre_parsed_p == 0)
13218     {
13219       /* A specialization is not used to guide overload resolution.  */
13220       if ((flag_guiding_decls
13221            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13222           && ! DECL_FUNCTION_MEMBER_P (decl1))
13223         decl1 = pushdecl (decl1);
13224       else
13225         {
13226           /* We need to set the DECL_CONTEXT. */
13227           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13228             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13229           /* And make sure we have enough default args.  */
13230           check_default_args (decl1);
13231         }
13232       DECL_MAIN_VARIANT (decl1) = decl1;
13233       fntype = TREE_TYPE (decl1);
13234     }
13235
13236   current_function_decl = decl1;
13237
13238   if (DECL_INTERFACE_KNOWN (decl1))
13239     {
13240       tree ctx = hack_decl_function_context (decl1);
13241
13242       if (DECL_NOT_REALLY_EXTERN (decl1))
13243         DECL_EXTERNAL (decl1) = 0;
13244
13245       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13246           && TREE_PUBLIC (ctx))
13247         /* This is a function in a local class in an extern inline
13248            function.  */
13249         comdat_linkage (decl1);
13250     }
13251   /* If this function belongs to an interface, it is public.
13252      If it belongs to someone else's interface, it is also external.
13253      This only affects inlines and template instantiations.  */
13254   else if (interface_unknown == 0
13255            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13256                || flag_alt_external_templates))
13257     {
13258       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13259           || processing_template_decl)
13260         {
13261           DECL_EXTERNAL (decl1)
13262             = (interface_only
13263                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13264                    && !DECL_VINDEX (decl1)));
13265
13266           /* For WIN32 we also want to put these in linkonce sections.  */
13267           maybe_make_one_only (decl1);
13268         }
13269       else
13270         DECL_EXTERNAL (decl1) = 0;
13271       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13272       DECL_INTERFACE_KNOWN (decl1) = 1;
13273     }
13274   else if (interface_unknown && interface_only
13275            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13276                || flag_alt_external_templates))
13277     {
13278       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13279          interface, we will have interface_only set but not
13280          interface_known.  In that case, we don't want to use the normal
13281          heuristics because someone will supply a #pragma implementation
13282          elsewhere, and deducing it here would produce a conflict.  */
13283       comdat_linkage (decl1);
13284       DECL_EXTERNAL (decl1) = 0;
13285       DECL_INTERFACE_KNOWN (decl1) = 1;
13286       DECL_DEFER_OUTPUT (decl1) = 1;
13287     }
13288   else
13289     {
13290       /* This is a definition, not a reference.
13291          So clear DECL_EXTERNAL.  */
13292       DECL_EXTERNAL (decl1) = 0;
13293
13294       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13295           && ! DECL_INTERFACE_KNOWN (decl1)
13296           /* Don't try to defer nested functions for now.  */
13297           && ! hack_decl_function_context (decl1))
13298         DECL_DEFER_OUTPUT (decl1) = 1;
13299       else
13300         DECL_INTERFACE_KNOWN (decl1) = 1;
13301     }
13302
13303   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
13304     {
13305       if (TREE_CODE (fntype) == METHOD_TYPE)
13306         TREE_TYPE (decl1) = fntype
13307           = build_function_type (TREE_TYPE (fntype),
13308                                  TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
13309       current_function_parms = TREE_CHAIN (current_function_parms);
13310       DECL_ARGUMENTS (decl1) = current_function_parms;
13311       ctype = NULL_TREE;
13312     }
13313   restype = TREE_TYPE (fntype);
13314
13315   if (ctype)
13316     {
13317       /* If we're compiling a friend function, neither of the variables
13318          current_class_ptr nor current_class_type will have values.  */
13319       if (! doing_friend)
13320         {
13321           /* We know that this was set up by `grokclassfn'.
13322              We do not wait until `store_parm_decls', since evil
13323              parse errors may never get us to that point.  Here
13324              we keep the consistency between `current_class_type'
13325              and `current_class_ptr'.  */
13326           tree t = current_function_parms;
13327
13328           my_friendly_assert (t != NULL_TREE
13329                               && TREE_CODE (t) == PARM_DECL, 162);
13330
13331           if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
13332             {
13333               int i;
13334
13335               if (! hack_decl_function_context (decl1))
13336                 temporary_allocation ();
13337               i = suspend_momentary ();
13338
13339               /* Normally, build_indirect_ref returns
13340                  current_class_ref whenever current_class_ptr is
13341                  dereferenced.  This time, however, we want it to
13342                  *create* current_class_ref, so we temporarily clear
13343                  current_class_ptr to fool it.  */
13344               current_class_ptr = NULL_TREE;
13345               current_class_ref = build_indirect_ref (t, NULL_PTR);
13346               current_class_ptr = t;
13347
13348               resume_momentary (i);
13349               if (! hack_decl_function_context (decl1))
13350                 end_temporary_allocation ();
13351             }
13352           else
13353             /* We're having a signature pointer here.  */
13354             current_class_ref = current_class_ptr = t;
13355
13356         }
13357     }
13358   else
13359     current_class_ptr = current_class_ref = NULL_TREE;
13360
13361   pushlevel (0);
13362   current_binding_level->parm_flag = 1;
13363
13364   GNU_xref_function (decl1, current_function_parms);
13365
13366   if (attrs)
13367     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13368
13369   make_function_rtl (decl1);
13370
13371   /* Promote the value to int before returning it.  */
13372   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13373     restype = type_promotes_to (restype);
13374
13375   /* If this fcn was already referenced via a block-scope `extern' decl
13376      (or an implicit decl), propagate certain information about the usage.  */
13377   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13378     TREE_ADDRESSABLE (decl1) = 1;
13379
13380   if (DECL_RESULT (decl1) == NULL_TREE)
13381     {
13382       DECL_RESULT (decl1)
13383         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13384       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13385       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13386     }
13387
13388   /* Allocate further tree nodes temporarily during compilation
13389      of this function only.  Tiemann moved up here from bottom of fn.  */
13390   /* If this is a nested function, then we must continue to allocate RTL
13391      on the permanent obstack in case we need to inline it later.  */
13392   if (! hack_decl_function_context (decl1))
13393     temporary_allocation ();
13394
13395   if (processing_template_decl)
13396     {
13397       ++minimal_parse_mode;
13398       last_tree = DECL_SAVED_TREE (decl1)
13399         = build_nt (EXPR_STMT, void_zero_node);
13400     }
13401
13402   ++function_depth;
13403
13404   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13405       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13406     {
13407       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13408       ctor_label = NULL_TREE;
13409     }
13410   else
13411     {
13412       dtor_label = NULL_TREE;
13413       if (DECL_CONSTRUCTOR_P (decl1))
13414         ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13415     }
13416
13417   return 1;
13418 }
13419 \f
13420 /* Called after store_parm_decls for a function-try-block.  We need to update
13421    last_parm_cleanup_insn so that the base initializers for a constructor
13422    are run within this block, not before it.  */
13423
13424 void
13425 expand_start_early_try_stmts ()
13426 {
13427   expand_start_try_stmts ();
13428   last_parm_cleanup_insn = get_last_insn ();
13429 }
13430
13431 /* Store the parameter declarations into the current function declaration.
13432    This is called after parsing the parameter declarations, before
13433    digesting the body of the function.
13434
13435    Also install to binding contour return value identifier, if any.  */
13436
13437 void
13438 store_parm_decls ()
13439 {
13440   register tree fndecl = current_function_decl;
13441   register tree parm;
13442   int parms_have_cleanups = 0;
13443   tree cleanups = NULL_TREE;
13444
13445   /* This is either a chain of PARM_DECLs (when a prototype is used).  */
13446   tree specparms = current_function_parms;
13447
13448   /* This is a list of types declared among parms in a prototype.  */
13449   tree parmtags = current_function_parm_tags;
13450
13451   /* This is a chain of any other decls that came in among the parm
13452      declarations.  If a parm is declared with  enum {foo, bar} x;
13453      then CONST_DECLs for foo and bar are put here.  */
13454   tree nonparms = NULL_TREE;
13455
13456   if (toplevel_bindings_p ())
13457     fatal ("parse errors have confused me too much");
13458
13459   /* Initialize RTL machinery.  */
13460   init_function_start (fndecl, input_filename, lineno);
13461
13462   /* Create a binding level for the parms.  */
13463   expand_start_bindings (0);
13464
13465   if (specparms != NULL_TREE)
13466     {
13467       /* This case is when the function was defined with an ANSI prototype.
13468          The parms already have decls, so we need not do anything here
13469          except record them as in effect
13470          and complain if any redundant old-style parm decls were written.  */
13471
13472       register tree next;
13473
13474       /* Must clear this because it might contain TYPE_DECLs declared
13475          at class level.  */
13476       storedecls (NULL_TREE);
13477
13478       for (parm = nreverse (specparms); parm; parm = next)
13479         {
13480           next = TREE_CHAIN (parm);
13481           if (TREE_CODE (parm) == PARM_DECL)
13482             {
13483               tree cleanup;
13484               if (DECL_NAME (parm) == NULL_TREE)
13485                 {
13486                   pushdecl (parm);
13487                 }
13488               else if (TREE_CODE (TREE_TYPE (parm)) == VOID_TYPE)
13489                 cp_error ("parameter `%D' declared void", parm);
13490               else
13491                 {
13492                   /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
13493                      A parameter is assumed not to have any side effects.
13494                      If this should change for any reason, then this
13495                      will have to wrap the bashed reference type in a save_expr.
13496
13497                      Also, if the parameter type is declared to be an X
13498                      and there is an X(X&) constructor, we cannot lay it
13499                      into the stack (any more), so we make this parameter
13500                      look like it is really of reference type.  Functions
13501                      which pass parameters to this function will know to
13502                      create a temporary in their frame, and pass a reference
13503                      to that.  */
13504
13505                   if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
13506                       && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
13507                     SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
13508
13509                   pushdecl (parm);
13510                 }
13511               if (! processing_template_decl
13512                   && (cleanup = maybe_build_cleanup (parm), cleanup))
13513                 {
13514                   expand_decl (parm);
13515                   parms_have_cleanups = 1;
13516
13517                   /* Keep track of the cleanups.  */
13518                   cleanups = tree_cons (parm, cleanup, cleanups);
13519                 }
13520             }
13521           else
13522             {
13523               /* If we find an enum constant or a type tag,
13524                  put it aside for the moment.  */
13525               TREE_CHAIN (parm) = NULL_TREE;
13526               nonparms = chainon (nonparms, parm);
13527             }
13528         }
13529
13530       /* Get the decls in their original chain order
13531          and record in the function.  This is all and only the
13532          PARM_DECLs that were pushed into scope by the loop above.  */
13533       DECL_ARGUMENTS (fndecl) = getdecls ();
13534
13535       storetags (chainon (parmtags, gettags ()));
13536     }
13537   else
13538     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13539
13540   /* Now store the final chain of decls for the arguments
13541      as the decl-chain of the current lexical scope.
13542      Put the enumerators in as well, at the front so that
13543      DECL_ARGUMENTS is not modified.  */
13544
13545   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13546
13547   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
13548   declare_function_name ();
13549
13550   /* Initialize the RTL code for the function.  */
13551   DECL_SAVED_INSNS (fndecl) = NULL_RTX;
13552   if (! processing_template_decl)
13553     expand_function_start (fndecl, parms_have_cleanups);
13554
13555   current_function_parms_stored = 1;
13556
13557   /* If this function is `main', emit a call to `__main'
13558      to run global initializers, etc.  */
13559   if (DECL_MAIN_P (fndecl))
13560     expand_main_function ();
13561
13562   /* Now that we have initialized the parms, we can start their
13563      cleanups.  We cannot do this before, since expand_decl_cleanup
13564      should not be called before the parm can be used.  */
13565   if (cleanups
13566       && ! processing_template_decl)
13567     {
13568       for (cleanups = nreverse (cleanups); cleanups; cleanups = TREE_CHAIN (cleanups))
13569         {
13570           if (! expand_decl_cleanup (TREE_PURPOSE (cleanups), TREE_VALUE (cleanups)))
13571             cp_error ("parser lost in parsing declaration of `%D'",
13572                       TREE_PURPOSE (cleanups));
13573         }
13574     }
13575
13576   /* Create a binding contour which can be used to catch
13577      cleanup-generated temporaries.  Also, if the return value needs or
13578      has initialization, deal with that now.  */
13579   if (parms_have_cleanups)
13580     {
13581       pushlevel (0);
13582       expand_start_bindings (0);
13583     }
13584
13585   if (! processing_template_decl && flag_exceptions)
13586     {
13587       /* Do the starting of the exception specifications, if we have any.  */
13588       if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13589         expand_start_eh_spec ();
13590     }
13591
13592   last_parm_cleanup_insn = get_last_insn ();
13593   last_dtor_insn = get_last_insn ();
13594 }
13595
13596 /* Bind a name and initialization to the return value of
13597    the current function.  */
13598
13599 void
13600 store_return_init (return_id, init)
13601      tree return_id, init;
13602 {
13603   tree decl = DECL_RESULT (current_function_decl);
13604
13605   if (pedantic)
13606     /* Give this error as many times as there are occurrences,
13607        so that users can use Emacs compilation buffers to find
13608        and fix all such places.  */
13609     pedwarn ("ANSI C++ does not permit named return values");
13610
13611   if (return_id != NULL_TREE)
13612     {
13613       if (DECL_NAME (decl) == NULL_TREE)
13614         {
13615           DECL_NAME (decl) = return_id;
13616           DECL_ASSEMBLER_NAME (decl) = return_id;
13617         }
13618       else
13619         cp_error ("return identifier `%D' already in place", decl);
13620     }
13621
13622   /* Can't let this happen for constructors.  */
13623   if (DECL_CONSTRUCTOR_P (current_function_decl))
13624     {
13625       error ("can't redefine default return value for constructors");
13626       return;
13627     }
13628
13629   /* If we have a named return value, put that in our scope as well.  */
13630   if (DECL_NAME (decl) != NULL_TREE)
13631     {
13632       /* If this named return value comes in a register,
13633          put it in a pseudo-register.  */
13634       if (DECL_REGISTER (decl))
13635         {
13636           original_result_rtx = DECL_RTL (decl);
13637           DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
13638         }
13639
13640       /* Let `cp_finish_decl' know that this initializer is ok.  */
13641       DECL_INITIAL (decl) = init;
13642       pushdecl (decl);
13643
13644       if (minimal_parse_mode)
13645         add_tree (build_min_nt (RETURN_INIT, return_id,
13646                                 copy_to_permanent (init)));
13647       else
13648         cp_finish_decl (decl, init, NULL_TREE, 0, 0);
13649     }
13650 }
13651
13652 \f
13653 /* Finish up a function declaration and compile that function
13654    all the way to assembler language output.  The free the storage
13655    for the function definition.
13656
13657    This is called after parsing the body of the function definition.
13658    LINENO is the current line number.
13659
13660    FLAGS is a bitwise or of the following values:
13661      1 - CALL_POPLEVEL
13662        An extra call to poplevel (and expand_end_bindings) must be
13663        made to take care of the binding contour for the base
13664        initializers.  This is only relevant for constructors.
13665      2 - INCLASS_INLINE
13666        We just finished processing the body of an in-class inline
13667        function definition.  (This processing will have taken place
13668        after the class definition is complete.)
13669
13670    NESTED is nonzero if we were in the middle of compiling another function
13671    when we started on this one.  */
13672
13673 void
13674 finish_function (lineno, flags, nested)
13675      int lineno;
13676      int flags;
13677      int nested;
13678 {
13679   register tree fndecl = current_function_decl;
13680   tree fntype, ctype = NULL_TREE;
13681   rtx last_parm_insn, insns;
13682   /* Label to use if this function is supposed to return a value.  */
13683   tree no_return_label = NULL_TREE;
13684   tree decls = NULL_TREE;
13685   int call_poplevel = (flags & 1) != 0;
13686   int inclass_inline = (flags & 2) != 0;
13687   int in_template;
13688
13689   /* When we get some parse errors, we can end up without a
13690      current_function_decl, so cope.  */
13691   if (fndecl == NULL_TREE)
13692     return;
13693
13694   if (! nested && function_depth > 1)
13695     nested = 1;
13696
13697   fntype = TREE_TYPE (fndecl);
13698
13699 /*  TREE_READONLY (fndecl) = 1;
13700     This caused &foo to be of type ptr-to-const-function
13701     which then got a warning when stored in a ptr-to-function variable.  */
13702
13703   /* This happens on strange parse errors.  */
13704   if (! current_function_parms_stored)
13705     {
13706       call_poplevel = 0;
13707       store_parm_decls ();
13708     }
13709
13710   if (processing_template_decl)
13711     {
13712       if (DECL_CONSTRUCTOR_P (fndecl) && call_poplevel)
13713         {
13714           decls = getdecls ();
13715           expand_end_bindings (decls, decls != NULL_TREE, 0);
13716           poplevel (decls != NULL_TREE, 0, 0);
13717         }
13718     }
13719   else
13720     {
13721       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13722         {
13723           tree ttype = target_type (fntype);
13724           tree parmdecl;
13725
13726           if (IS_AGGR_TYPE (ttype))
13727             /* Let debugger know it should output info for this type.  */
13728             note_debug_info_needed (ttype);
13729
13730           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13731             {
13732               ttype = target_type (TREE_TYPE (parmdecl));
13733               if (IS_AGGR_TYPE (ttype))
13734                 /* Let debugger know it should output info for this type.  */
13735                 note_debug_info_needed (ttype);
13736             }
13737         }
13738
13739       /* Clean house because we will need to reorder insns here.  */
13740       do_pending_stack_adjust ();
13741
13742       if (dtor_label)
13743         {
13744           tree binfo = TYPE_BINFO (current_class_type);
13745           tree cond = integer_one_node;
13746           tree exprstmt;
13747           tree in_charge_node = lookup_name (in_charge_identifier, 0);
13748           tree virtual_size;
13749           int ok_to_optimize_dtor = 0;
13750           int empty_dtor = get_last_insn () == last_dtor_insn;
13751
13752           if (current_function_assigns_this)
13753             cond = build (NE_EXPR, boolean_type_node,
13754                           current_class_ptr, integer_zero_node);
13755           else
13756             {
13757               int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
13758
13759               /* If this destructor is empty, then we don't need to check
13760                  whether `this' is NULL in some cases.  */
13761               if ((flag_this_is_variable & 1) == 0)
13762                 ok_to_optimize_dtor = 1;
13763               else if (empty_dtor)
13764                 ok_to_optimize_dtor
13765                   = (n_baseclasses == 0
13766                      || (n_baseclasses == 1
13767                          && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
13768             }
13769
13770           /* These initializations might go inline.  Protect
13771              the binding level of the parms.  */
13772           pushlevel (0);
13773           expand_start_bindings (0);
13774
13775           if (current_function_assigns_this)
13776             {
13777               current_function_assigns_this = 0;
13778               current_function_just_assigned_this = 0;
13779             }
13780
13781           /* Generate the code to call destructor on base class.
13782              If this destructor belongs to a class with virtual
13783              functions, then set the virtual function table
13784              pointer to represent the type of our base class.  */
13785
13786           /* This side-effect makes call to `build_delete' generate the
13787              code we have to have at the end of this destructor.
13788              `build_delete' will set the flag again.  */
13789           TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13790
13791           /* These are two cases where we cannot delegate deletion.  */
13792           if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13793               || TYPE_GETS_REG_DELETE (current_class_type))
13794             exprstmt = build_delete (current_class_type, current_class_ref, integer_zero_node,
13795                                      LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
13796           else
13797             exprstmt = build_delete (current_class_type, current_class_ref, in_charge_node,
13798                                      LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
13799
13800           /* If we did not assign to this, then `this' is non-zero at
13801              the end of a destructor.  As a special optimization, don't
13802              emit test if this is an empty destructor.  If it does nothing,
13803              it does nothing.  If it calls a base destructor, the base
13804              destructor will perform the test.  */
13805
13806           if (exprstmt != error_mark_node
13807               && (TREE_CODE (exprstmt) != NOP_EXPR
13808                   || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13809                   || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13810             {
13811               expand_label (dtor_label);
13812               if (cond != integer_one_node)
13813                 expand_start_cond (cond, 0);
13814               if (exprstmt != void_zero_node)
13815                 /* Don't call `expand_expr_stmt' if we're not going to do
13816                    anything, since -Wall will give a diagnostic.  */
13817                 expand_expr_stmt (exprstmt);
13818
13819               /* Run destructor on all virtual baseclasses.  */
13820               if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13821                 {
13822                   tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13823                   expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
13824                                             in_charge_node, integer_two_node), 0);
13825                   while (vbases)
13826                     {
13827                       if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13828                         {
13829                           tree vb = get_vbase
13830                             (BINFO_TYPE (vbases),
13831                              TYPE_BINFO (current_class_type));
13832                           expand_expr_stmt
13833                             (build_scoped_method_call
13834                              (current_class_ref, vb, dtor_identifier,
13835                               build_expr_list (NULL_TREE, integer_zero_node)));
13836                         }
13837                       vbases = TREE_CHAIN (vbases);
13838                     }
13839                   expand_end_cond ();
13840                 }
13841
13842               do_pending_stack_adjust ();
13843               if (cond != integer_one_node)
13844                 expand_end_cond ();
13845             }
13846
13847           virtual_size = c_sizeof (current_class_type);
13848
13849           /* At the end, call delete if that's what's requested.  */
13850
13851           /* FDIS sez: At the point of definition of a virtual destructor
13852                (including an implicit definition), non-placement operator
13853                delete shall be looked up in the scope of the destructor's
13854                class and if found shall be accessible and unambiguous.
13855
13856              This is somewhat unclear, but I take it to mean that if the
13857              class only defines placement deletes we don't do anything here.
13858              So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13859              for us if they ever try to delete one of these.  */
13860
13861           if (TYPE_GETS_REG_DELETE (current_class_type)
13862               || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13863             exprstmt = build_op_delete_call
13864               (DELETE_EXPR, current_class_ptr, virtual_size,
13865                LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13866           else
13867             exprstmt = NULL_TREE;
13868
13869           if (exprstmt)
13870             {
13871               cond = build (BIT_AND_EXPR, integer_type_node,
13872                             in_charge_node, integer_one_node);
13873               expand_start_cond (cond, 0);
13874               expand_expr_stmt (exprstmt);
13875               expand_end_cond ();
13876             }
13877
13878           /* End of destructor.  */
13879           expand_end_bindings (NULL_TREE, getdecls () != NULL_TREE, 0);
13880           poplevel (getdecls () != NULL_TREE, 0, 0);
13881
13882           /* Back to the top of destructor.  */
13883           /* Don't execute destructor code if `this' is NULL.  */
13884
13885           start_sequence ();
13886
13887           /* If the dtor is empty, and we know there is not possible way we
13888              could use any vtable entries, before they are possibly set by
13889              a base class dtor, we don't have to setup the vtables, as we
13890              know that any base class dtoring will set up any vtables it
13891              needs.  We avoid MI, because one base class dtor can do a
13892              virtual dispatch to an overridden function that would need to
13893              have a non-related vtable set up, we cannot avoid setting up
13894              vtables in that case.  We could change this to see if there is
13895              just one vtable.  */
13896           if (! empty_dtor || TYPE_USES_COMPLEX_INHERITANCE (current_class_type))
13897             {
13898               /* Make all virtual function table pointers in non-virtual base
13899                  classes point to CURRENT_CLASS_TYPE's virtual function
13900                  tables.  */
13901               expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_ptr);
13902
13903               if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13904                 expand_indirect_vtbls_init (binfo, current_class_ref, current_class_ptr);
13905             }
13906
13907           if (! ok_to_optimize_dtor)
13908             {
13909               cond = build_binary_op (NE_EXPR,
13910                                       current_class_ptr, integer_zero_node, 1);
13911               expand_start_cond (cond, 0);
13912             }
13913
13914           insns = get_insns ();
13915           end_sequence ();
13916
13917           last_parm_insn = get_first_nonparm_insn ();
13918           if (last_parm_insn == NULL_RTX)
13919             last_parm_insn = get_last_insn ();
13920           else
13921             last_parm_insn = previous_insn (last_parm_insn);
13922
13923           emit_insns_after (insns, last_parm_insn);
13924
13925           if (! ok_to_optimize_dtor)
13926             expand_end_cond ();
13927         }
13928       else if (current_function_assigns_this)
13929         {
13930           /* Does not need to call emit_base_init, because
13931              that is done (if needed) just after assignment to this
13932              is seen.  */
13933
13934           if (DECL_CONSTRUCTOR_P (current_function_decl))
13935             {
13936               end_protect_partials ();
13937               expand_label (ctor_label);
13938               ctor_label = NULL_TREE;
13939
13940               if (call_poplevel)
13941                 {
13942                   decls = getdecls ();
13943                   expand_end_bindings (decls, decls != NULL_TREE, 0);
13944                   poplevel (decls != NULL_TREE, 0, 0);
13945                 }
13946               /* c_expand_return knows to return 'this' from a constructor.  */
13947               c_expand_return (NULL_TREE);
13948             }
13949           else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl))) != VOID_TYPE
13950                    && return_label != NULL_RTX)
13951             no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13952
13953           current_function_assigns_this = 0;
13954           current_function_just_assigned_this = 0;
13955           base_init_expr = NULL_TREE;
13956         }
13957       else if (DECL_CONSTRUCTOR_P (fndecl))
13958         {
13959           tree cond = NULL_TREE, thenclause = NULL_TREE;
13960           /* Allow constructor for a type to get a new instance of the object
13961              using `build_new'.  */
13962           tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
13963           CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
13964
13965           DECL_RETURNS_FIRST_ARG (fndecl) = 1;
13966
13967           if (flag_this_is_variable > 0)
13968             {
13969               cond = build_binary_op (EQ_EXPR,
13970                                       current_class_ptr, integer_zero_node, 1);
13971               thenclause = build_modify_expr (current_class_ptr, NOP_EXPR,
13972                                               build_new (NULL_TREE, current_class_type, void_type_node, 0));
13973             }
13974
13975           CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
13976
13977           start_sequence ();
13978
13979           if (flag_this_is_variable > 0)
13980             {
13981               expand_start_cond (cond, 0);
13982               expand_expr_stmt (thenclause);
13983               expand_end_cond ();
13984             }
13985
13986           /* Emit insns from `emit_base_init' which sets up virtual
13987              function table pointer(s).  */
13988           if (base_init_expr)
13989             {
13990               expand_expr_stmt (base_init_expr);
13991               base_init_expr = NULL_TREE;
13992             }
13993
13994           insns = get_insns ();
13995           end_sequence ();
13996
13997           /* This is where the body of the constructor begins.  */
13998
13999           emit_insns_after (insns, last_parm_cleanup_insn);
14000
14001           end_protect_partials ();
14002
14003           /* This is where the body of the constructor ends.  */
14004           expand_label (ctor_label);
14005           ctor_label = NULL_TREE;
14006
14007           if (call_poplevel)
14008             {
14009               decls = getdecls ();
14010               expand_end_bindings (decls, decls != NULL_TREE, 0);
14011               poplevel (decls != NULL_TREE, 1, 0);
14012             }
14013
14014           /* c_expand_return knows to return 'this' from a constructor.  */
14015           c_expand_return (NULL_TREE);
14016
14017           current_function_assigns_this = 0;
14018           current_function_just_assigned_this = 0;
14019         }
14020       else if (DECL_MAIN_P (fndecl))
14021         {
14022           /* Make it so that `main' always returns 0 by default.  */
14023 #ifdef VMS
14024           c_expand_return (integer_one_node);
14025 #else
14026           c_expand_return (integer_zero_node);
14027 #endif
14028         }
14029       else if (return_label != NULL_RTX
14030                && current_function_return_value == NULL_TREE
14031                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14032         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14033
14034       if (flag_exceptions)
14035         expand_exception_blocks ();
14036
14037       /* If this function is supposed to return a value, ensure that
14038          we do not fall into the cleanups by mistake.  The end of our
14039          function will look like this:
14040
14041          user code (may have return stmt somewhere)
14042          goto no_return_label
14043          cleanup_label:
14044          cleanups
14045          goto return_label
14046          no_return_label:
14047          NOTE_INSN_FUNCTION_END
14048          return_label:
14049          things for return
14050
14051          If the user omits a return stmt in the USER CODE section, we
14052          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14053          Otherwise, we won't.  */
14054       if (no_return_label)
14055         {
14056           DECL_CONTEXT (no_return_label) = fndecl;
14057           DECL_INITIAL (no_return_label) = error_mark_node;
14058           DECL_SOURCE_FILE (no_return_label) = input_filename;
14059           DECL_SOURCE_LINE (no_return_label) = lineno;
14060           expand_goto (no_return_label);
14061         }
14062
14063       if (cleanup_label)
14064         {
14065           /* Remove the binding contour which is used
14066              to catch cleanup-generated temporaries.  */
14067           expand_end_bindings (0, 0, 0);
14068           poplevel (0, 0, 0);
14069
14070           /* Emit label at beginning of cleanup code for parameters.  */
14071           emit_label (cleanup_label);
14072         }
14073
14074       /* Get return value into register if that's where it's supposed to be.  */
14075       if (original_result_rtx)
14076         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14077
14078       /* Finish building code that will trigger warnings if users forget
14079          to make their functions return values.  */
14080       if (no_return_label || cleanup_label)
14081         emit_jump (return_label);
14082       if (no_return_label)
14083         {
14084           /* We don't need to call `expand_*_return' here because we
14085              don't need any cleanups here--this path of code is only
14086              for error checking purposes.  */
14087           expand_label (no_return_label);
14088         }
14089
14090       /* Generate rtl for function exit.  */
14091       expand_function_end (input_filename, lineno, 1);
14092     }
14093
14094   /* If we're processing a template, squirrel away the definition
14095      until we do an instantiation.  */
14096   if (processing_template_decl)
14097     {
14098       --minimal_parse_mode;
14099       DECL_SAVED_TREE (fndecl) = TREE_CHAIN (DECL_SAVED_TREE (fndecl));
14100       /* We have to save this value here in case
14101          maybe_end_member_template_processing decides to pop all the
14102          template parameters.  */
14103       in_template = 1;
14104     }
14105   else
14106     in_template = 0;
14107
14108   /* This must come after expand_function_end because cleanups might
14109      have declarations (from inline functions) that need to go into
14110      this function's blocks.  */
14111   if (current_binding_level->parm_flag != 1)
14112     my_friendly_abort (122);
14113   poplevel (1, 0, 1);
14114
14115   /* If this is a in-class inline definition, we may have to pop the
14116      bindings for the template parameters that we added in
14117      maybe_begin_member_template_processing when start_function was
14118      called.  */
14119   if (inclass_inline)
14120     maybe_end_member_template_processing ();
14121
14122   /* Reset scope for C++: if we were in the scope of a class,
14123      then when we finish this function, we are not longer so.
14124      This cannot be done until we know for sure that no more
14125      class members will ever be referenced in this function
14126      (i.e., calls to destructors).  */
14127   if (current_class_name)
14128     {
14129       ctype = current_class_type;
14130       pop_nested_class (1);
14131     }
14132
14133   /* Must mark the RESULT_DECL as being in this function.  */
14134   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14135
14136   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14137      to the FUNCTION_DECL node itself.  */
14138   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14139
14140   if (!in_template)
14141     {
14142       int saved_flag_keep_inline_functions =
14143         flag_keep_inline_functions;
14144
14145       /* So we can tell if jump_optimize sets it to 1.  */
14146       can_reach_end = 0;
14147
14148       if (DECL_CONTEXT (fndecl) != NULL_TREE
14149           && hack_decl_function_context (fndecl))
14150         /* Trick rest_of_compilation into not deferring output of this
14151            function, even if it is inline, since the rtl_obstack for
14152            this function is the function_obstack of the enclosing
14153            function and will be deallocated when the enclosing
14154            function is gone.  See save_tree_status.  */
14155         flag_keep_inline_functions = 1;
14156
14157       /* Run the optimizers and output the assembler code for this
14158          function.  */
14159
14160       if (DECL_ARTIFICIAL (fndecl))
14161         {
14162           /* Do we really *want* to inline this synthesized method?  */
14163
14164           int save_fif = flag_inline_functions;
14165           flag_inline_functions = 1;
14166
14167           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14168              will check our size.  */
14169           DECL_INLINE (fndecl) = 0;
14170
14171           rest_of_compilation (fndecl);
14172           flag_inline_functions = save_fif;
14173         }
14174       else
14175         rest_of_compilation (fndecl);
14176
14177       flag_keep_inline_functions = saved_flag_keep_inline_functions;
14178
14179       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14180         {
14181           /* Set DECL_EXTERNAL so that assemble_external will be called as
14182              necessary.  We'll clear it again in finish_file.  */
14183           if (! DECL_EXTERNAL (fndecl))
14184             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14185           DECL_EXTERNAL (fndecl) = 1;
14186           mark_inline_for_output (fndecl);
14187         }
14188
14189       if (ctype && TREE_ASM_WRITTEN (fndecl))
14190         note_debug_info_needed (ctype);
14191
14192       current_function_returns_null |= can_reach_end;
14193
14194       /* Since we don't normally go through c_expand_return for constructors,
14195          this normally gets the wrong value.
14196          Also, named return values have their return codes emitted after
14197          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14198       if (DECL_CONSTRUCTOR_P (fndecl)
14199           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14200         current_function_returns_null = 0;
14201
14202       if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
14203         cp_warning ("`noreturn' function `%D' does return", fndecl);
14204       else if ((warn_return_type || pedantic)
14205                && current_function_returns_null
14206                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14207         {
14208           /* If this function returns non-void and control can drop through,
14209              complain.  */
14210           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14211         }
14212       /* With just -W, complain only if function returns both with
14213          and without a value.  */
14214       else if (extra_warnings
14215                && current_function_returns_value && current_function_returns_null)
14216         warning ("this function may return with or without a value");
14217     }
14218
14219   --function_depth;
14220
14221   /* Free all the tree nodes making up this function.  */
14222   /* Switch back to allocating nodes permanently
14223      until we start another function.  */
14224   if (! nested)
14225     permanent_allocation (1);
14226
14227   if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
14228     {
14229       tree t;
14230
14231       /* Stop pointing to the local nodes about to be freed.  */
14232       /* But DECL_INITIAL must remain nonzero so we know this
14233          was an actual function definition.  */
14234       DECL_INITIAL (fndecl) = error_mark_node;
14235       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14236         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14237     }
14238
14239   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14240     static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
14241   if (DECL_STATIC_DESTRUCTOR (fndecl))
14242     static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
14243
14244   if (! nested)
14245     {
14246       /* Let the error reporting routines know that we're outside a
14247          function.  For a nested function, this value is used in
14248          pop_cp_function_context and then reset via pop_function_context.  */
14249       current_function_decl = NULL_TREE;
14250     }
14251
14252   named_label_uses = NULL;
14253   current_class_ptr = NULL_TREE;
14254   current_class_ref = NULL_TREE;
14255 }
14256 \f
14257 /* Create the FUNCTION_DECL for a function definition.
14258    DECLSPECS and DECLARATOR are the parts of the declaration;
14259    they describe the return type and the name of the function,
14260    but twisted together in a fashion that parallels the syntax of C.
14261
14262    This function creates a binding context for the function body
14263    as well as setting up the FUNCTION_DECL in current_function_decl.
14264
14265    Returns a FUNCTION_DECL on success.
14266
14267    If the DECLARATOR is not suitable for a function (it defines a datum
14268    instead), we return 0, which tells yyparse to report a parse error.
14269
14270    May return void_type_node indicating that this method is actually
14271    a friend.  See grokfield for more details.
14272
14273    Came here with a `.pushlevel' .
14274
14275    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14276    CHANGES TO CODE IN `grokfield'.  */
14277
14278 tree
14279 start_method (declspecs, declarator, attrlist)
14280      tree declarator, declspecs, attrlist;
14281 {
14282   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14283                                 attrlist);
14284
14285   /* Something too ugly to handle.  */
14286   if (fndecl == NULL_TREE)
14287     return NULL_TREE;
14288
14289   /* Pass friends other than inline friend functions back.  */
14290   if (fndecl == void_type_node)
14291     return fndecl;
14292
14293   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14294     /* Not a function, tell parser to report parse error.  */
14295     return NULL_TREE;
14296
14297   if (IS_SIGNATURE (current_class_type))
14298     IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
14299
14300   if (DECL_IN_AGGR_P (fndecl))
14301     {
14302       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14303         {
14304           if (DECL_CONTEXT (fndecl)
14305               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14306             cp_error ("`%D' is already defined in class %s", fndecl,
14307                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14308         }
14309       return void_type_node;
14310     }
14311
14312   check_template_shadow (fndecl);
14313
14314   DECL_THIS_INLINE (fndecl) = 1;
14315
14316   if (flag_default_inline)
14317     DECL_INLINE (fndecl) = 1;
14318
14319   /* We process method specializations in finish_struct_1.  */
14320   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14321     fndecl = push_template_decl (fndecl);
14322
14323   /* We read in the parameters on the maybepermanent_obstack,
14324      but we won't be getting back to them until after we
14325      may have clobbered them.  So the call to preserve_data
14326      will keep them safe.  */
14327   preserve_data ();
14328
14329   if (! DECL_FRIEND_P (fndecl))
14330     {
14331       if (TREE_CHAIN (fndecl))
14332         {
14333           fndecl = copy_node (fndecl);
14334           TREE_CHAIN (fndecl) = NULL_TREE;
14335         }
14336
14337       if (DECL_CONSTRUCTOR_P (fndecl))
14338         {
14339           if (! grok_ctor_properties (current_class_type, fndecl))
14340             return void_type_node;
14341         }
14342       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14343         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14344     }
14345
14346   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
14347
14348   /* Make a place for the parms */
14349   pushlevel (0);
14350   current_binding_level->parm_flag = 1;
14351
14352   DECL_IN_AGGR_P (fndecl) = 1;
14353   return fndecl;
14354 }
14355
14356 /* Go through the motions of finishing a function definition.
14357    We don't compile this method until after the whole class has
14358    been processed.
14359
14360    FINISH_METHOD must return something that looks as though it
14361    came from GROKFIELD (since we are defining a method, after all).
14362
14363    This is called after parsing the body of the function definition.
14364    STMTS is the chain of statements that makes up the function body.
14365
14366    DECL is the ..._DECL that `start_method' provided.  */
14367
14368 tree
14369 finish_method (decl)
14370      tree decl;
14371 {
14372   register tree fndecl = decl;
14373   tree old_initial;
14374
14375   register tree link;
14376
14377   if (decl == void_type_node)
14378     return decl;
14379
14380   old_initial = DECL_INITIAL (fndecl);
14381
14382   /* Undo the level for the parms (from start_method).
14383      This is like poplevel, but it causes nothing to be
14384      saved.  Saving information here confuses symbol-table
14385      output routines.  Besides, this information will
14386      be correctly output when this method is actually
14387      compiled.  */
14388
14389   /* Clear out the meanings of the local variables of this level;
14390      also record in each decl which block it belongs to.  */
14391
14392   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14393     {
14394       if (DECL_NAME (link) != NULL_TREE)
14395         pop_binding (DECL_NAME (link), link);
14396       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14397       DECL_CONTEXT (link) = NULL_TREE;
14398     }
14399
14400   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14401                       (HOST_WIDE_INT) current_binding_level->level_chain,
14402                       current_binding_level->parm_flag,
14403                       current_binding_level->keep);
14404
14405   poplevel (0, 0, 0);
14406
14407   DECL_INITIAL (fndecl) = old_initial;
14408
14409   /* We used to check if the context of FNDECL was different from
14410      current_class_type as another way to get inside here.  This didn't work
14411      for String.cc in libg++.  */
14412   if (DECL_FRIEND_P (fndecl))
14413     {
14414       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14415         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14416       decl = void_type_node;
14417     }
14418
14419   return decl;
14420 }
14421 \f
14422 /* Called when a new struct TYPE is defined.
14423    If this structure or union completes the type of any previous
14424    variable declaration, lay it out and output its rtl.  */
14425
14426 void
14427 hack_incomplete_structures (type)
14428      tree type;
14429 {
14430   tree *list;
14431
14432   if (current_binding_level->incomplete == NULL_TREE)
14433     return;
14434
14435   if (!type) /* Don't do this for class templates.  */
14436     return;
14437
14438   for (list = &current_binding_level->incomplete; *list; )
14439     {
14440       tree decl = TREE_VALUE (*list);
14441       if ((decl && TREE_TYPE (decl) == type)
14442           || (TREE_TYPE (decl)
14443               && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14444               && TREE_TYPE (TREE_TYPE (decl)) == type))
14445         {
14446           int toplevel = toplevel_bindings_p ();
14447           if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14448               && TREE_TYPE (TREE_TYPE (decl)) == type)
14449             layout_type (TREE_TYPE (decl));
14450           layout_decl (decl, 0);
14451           rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14452           if (! toplevel)
14453             {
14454               tree cleanup;
14455               expand_decl (decl);
14456               cleanup = maybe_build_cleanup (decl);
14457               expand_decl_init (decl);
14458               if (! expand_decl_cleanup (decl, cleanup))
14459                 cp_error ("parser lost in parsing declaration of `%D'",
14460                           decl);
14461             }
14462           *list = TREE_CHAIN (*list);
14463         }
14464       else
14465         list = &TREE_CHAIN (*list);
14466     }
14467 }
14468
14469 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14470    See build_delete for information about AUTO_DELETE.
14471
14472    Don't build these on the momentary obstack; they must live
14473    the life of the binding contour.  */
14474
14475 static tree
14476 maybe_build_cleanup_1 (decl, auto_delete)
14477      tree decl, auto_delete;
14478 {
14479   tree type = TREE_TYPE (decl);
14480   if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14481     {
14482       int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14483       tree rval;
14484
14485       if (TREE_CODE (decl) != PARM_DECL)
14486         temp = suspend_momentary ();
14487
14488       if (TREE_CODE (type) == ARRAY_TYPE)
14489         rval = decl;
14490       else
14491         {
14492           mark_addressable (decl);
14493           rval = build_unary_op (ADDR_EXPR, decl, 0);
14494         }
14495
14496       /* Optimize for space over speed here.  */
14497       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14498           || flag_expensive_optimizations)
14499         flags |= LOOKUP_NONVIRTUAL;
14500
14501       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14502
14503       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14504           && ! TYPE_HAS_DESTRUCTOR (type))
14505         rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
14506                                                build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
14507
14508       if (TREE_CODE (decl) != PARM_DECL)
14509         resume_momentary (temp);
14510
14511       return rval;
14512     }
14513   return 0;
14514 }
14515
14516 /* If DECL is of a type which needs a cleanup, build that cleanup
14517    here.  The cleanup does free the storage with a call to delete.  */
14518
14519 tree
14520 maybe_build_cleanup_and_delete (decl)
14521      tree decl;
14522 {
14523   return maybe_build_cleanup_1 (decl, integer_three_node);
14524 }
14525
14526 /* If DECL is of a type which needs a cleanup, build that cleanup
14527    here.  The cleanup does not free the storage with a call a delete.  */
14528
14529 tree
14530 maybe_build_cleanup (decl)
14531      tree decl;
14532 {
14533   return maybe_build_cleanup_1 (decl, integer_two_node);
14534 }
14535 \f
14536 /* Expand a C++ expression at the statement level.
14537    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14538    The C++ type checker should get all of these out when
14539    expressions are combined with other, type-providing, expressions,
14540    leaving only orphan expressions, such as:
14541
14542    &class::bar;         / / takes its address, but does nothing with it.  */
14543
14544 void
14545 cplus_expand_expr_stmt (exp)
14546      tree exp;
14547 {
14548   if (processing_template_decl)
14549     {
14550       add_tree (build_min_nt (EXPR_STMT, exp));
14551       return;
14552     }
14553
14554   /* Arrange for all temps to disappear.  */
14555   expand_start_target_temps ();
14556
14557   exp = require_complete_type_in_void (exp);
14558
14559   if (TREE_CODE (exp) == FUNCTION_DECL)
14560     {
14561       cp_warning ("reference, not call, to function `%D'", exp);
14562       warning ("at this point in file");
14563     }
14564
14565 #if 0
14566   /* We should do this eventually, but right now this causes regex.o from
14567      libg++ to miscompile, and tString to core dump.  */
14568   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14569 #endif
14570
14571   /* Strip unused implicit INDIRECT_REFs of references.  */
14572   if (TREE_CODE (exp) == INDIRECT_REF
14573       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
14574     exp = TREE_OPERAND (exp, 0);
14575
14576   /* If we don't do this, we end up down inside expand_expr
14577      trying to do TYPE_MODE on the ERROR_MARK, and really
14578      go outside the bounds of the type.  */
14579   if (exp != error_mark_node)
14580     expand_expr_stmt (break_out_cleanups (exp));
14581
14582   /* Clean up any pending cleanups.  This happens when a function call
14583      returns a cleanup-needing value that nobody uses.  */
14584   expand_end_target_temps ();
14585 }
14586
14587 /* When a stmt has been parsed, this function is called.
14588
14589    Currently, this function only does something within a
14590    constructor's scope: if a stmt has just assigned to this,
14591    and we are in a derived class, we call `emit_base_init'.  */
14592
14593 void
14594 finish_stmt ()
14595 {
14596   extern struct nesting *cond_stack, *loop_stack, *case_stack;
14597
14598
14599   if (current_function_assigns_this
14600       || ! current_function_just_assigned_this)
14601     return;
14602   if (DECL_CONSTRUCTOR_P (current_function_decl))
14603     {
14604       /* Constructors must wait until we are out of control
14605          zones before calling base constructors.  */
14606       if (cond_stack || loop_stack || case_stack)
14607         return;
14608       expand_expr_stmt (base_init_expr);
14609       check_base_init (current_class_type);
14610     }
14611   current_function_assigns_this = 1;
14612 }
14613
14614 /* Change a static member function definition into a FUNCTION_TYPE, instead
14615    of the METHOD_TYPE that we create when it's originally parsed.
14616
14617    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14618    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14619    other decls.  Either pass the addresses of local variables or NULL.  */
14620
14621 void
14622 revert_static_member_fn (decl, fn, argtypes)
14623      tree *decl, *fn, *argtypes;
14624 {
14625   tree tmp;
14626   tree function = fn ? *fn : TREE_TYPE (*decl);
14627   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14628
14629   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14630       != TYPE_UNQUALIFIED)
14631     cp_error ("static member function `%#D' declared with type qualifiers",
14632               *decl);
14633
14634   args = TREE_CHAIN (args);
14635   tmp = build_function_type (TREE_TYPE (function), args);
14636   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14637   tmp = build_exception_variant (tmp,
14638                                  TYPE_RAISES_EXCEPTIONS (function));
14639   TREE_TYPE (*decl) = tmp;
14640   if (DECL_ARGUMENTS (*decl))
14641     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14642   DECL_STATIC_FUNCTION_P (*decl) = 1;
14643   if (fn)
14644     *fn = tmp;
14645   if (argtypes)
14646     *argtypes = args;
14647 }
14648
14649 struct cp_function
14650 {
14651   int returns_value;
14652   int returns_null;
14653   int assigns_this;
14654   int just_assigned_this;
14655   int parms_stored;
14656   int temp_name_counter;
14657   tree named_labels;
14658   struct named_label_list *named_label_uses;
14659   tree shadowed_labels;
14660   tree ctor_label;
14661   tree dtor_label;
14662   rtx last_dtor_insn;
14663   rtx last_parm_cleanup_insn;
14664   tree base_init_list;
14665   tree member_init_list;
14666   tree base_init_expr;
14667   tree current_class_ptr;
14668   tree current_class_ref;
14669   rtx result_rtx;
14670   struct cp_function *next;
14671   struct binding_level *binding_level;
14672   int static_labelno;
14673 };
14674
14675 static struct cp_function *cp_function_chain;
14676
14677 extern int temp_name_counter;
14678
14679 /* Save and reinitialize the variables
14680    used during compilation of a C++ function.  */
14681
14682 void
14683 push_cp_function_context (context)
14684      tree context;
14685 {
14686   struct cp_function *p
14687     = (struct cp_function *) xmalloc (sizeof (struct cp_function));
14688
14689   push_function_context_to (context);
14690
14691   p->next = cp_function_chain;
14692   cp_function_chain = p;
14693
14694   p->named_labels = named_labels;
14695   p->named_label_uses = named_label_uses;
14696   p->shadowed_labels = shadowed_labels;
14697   p->returns_value = current_function_returns_value;
14698   p->returns_null = current_function_returns_null;
14699   p->binding_level = current_binding_level;
14700   p->ctor_label = ctor_label;
14701   p->dtor_label = dtor_label;
14702   p->last_dtor_insn = last_dtor_insn;
14703   p->last_parm_cleanup_insn = last_parm_cleanup_insn;
14704   p->assigns_this = current_function_assigns_this;
14705   p->just_assigned_this = current_function_just_assigned_this;
14706   p->parms_stored = current_function_parms_stored;
14707   p->result_rtx = original_result_rtx;
14708   p->base_init_expr = base_init_expr;
14709   p->temp_name_counter = temp_name_counter;
14710   p->base_init_list = current_base_init_list;
14711   p->member_init_list = current_member_init_list;
14712   p->current_class_ptr = current_class_ptr;
14713   p->current_class_ref = current_class_ref;
14714   p->static_labelno = static_labelno;
14715 }
14716
14717 /* Restore the variables used during compilation of a C++ function.  */
14718
14719 void
14720 pop_cp_function_context (context)
14721      tree context;
14722 {
14723   struct cp_function *p = cp_function_chain;
14724   tree link;
14725
14726   /* Bring back all the labels that were shadowed.  */
14727   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
14728     if (DECL_NAME (TREE_VALUE (link)) != 0)
14729       SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
14730                                   TREE_VALUE (link));
14731
14732   pop_function_context_from (context);
14733
14734   cp_function_chain = p->next;
14735
14736   named_labels = p->named_labels;
14737   named_label_uses = p->named_label_uses;
14738   shadowed_labels = p->shadowed_labels;
14739   current_function_returns_value = p->returns_value;
14740   current_function_returns_null = p->returns_null;
14741   current_binding_level = p->binding_level;
14742   ctor_label = p->ctor_label;
14743   dtor_label = p->dtor_label;
14744   last_dtor_insn = p->last_dtor_insn;
14745   last_parm_cleanup_insn = p->last_parm_cleanup_insn;
14746   current_function_assigns_this = p->assigns_this;
14747   current_function_just_assigned_this = p->just_assigned_this;
14748   current_function_parms_stored = p->parms_stored;
14749   original_result_rtx = p->result_rtx;
14750   base_init_expr = p->base_init_expr;
14751   temp_name_counter = p->temp_name_counter;
14752   current_base_init_list = p->base_init_list;
14753   current_member_init_list = p->member_init_list;
14754   current_class_ptr = p->current_class_ptr;
14755   current_class_ref = p->current_class_ref;
14756   static_labelno = p->static_labelno;
14757
14758   free (p);
14759 }
14760
14761 int
14762 in_function_p ()
14763 {
14764   return function_depth != 0;
14765 }