gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 92-97, 1998 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
  45 #define obstack_chunk_alloc xmalloc
  46 #define obstack_chunk_free free
  47
  48 extern tree builtin_return_address_fndecl;
  49
  50 extern struct obstack permanent_obstack;
  51 extern struct obstack* saveable_obstack;
  52
  53 extern int current_class_depth;
  54
  55 extern tree static_ctors, static_dtors;
  56
  57 extern int static_labelno;
  58
  59 extern tree current_namespace;
  60 extern tree global_namespace;
  61
  62 extern void (*print_error_function) PROTO((char *));
  63
  64 /* Stack of places to restore the search obstack back to.  */
  65
  66 /* Obstack used for remembering local class declarations (like
  67    enums and static (const) members.  */
  68 #include "stack.h"
  69 struct obstack decl_obstack;
  70 static struct stack_level *decl_stack;
  71
  72 #ifndef CHAR_TYPE_SIZE
  73 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  74 #endif
  75
  76 #ifndef SHORT_TYPE_SIZE
  77 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
  78 #endif
  79
  80 #ifndef INT_TYPE_SIZE
  81 #define INT_TYPE_SIZE BITS_PER_WORD
  82 #endif
  83
  84 #ifndef LONG_TYPE_SIZE
  85 #define LONG_TYPE_SIZE BITS_PER_WORD
  86 #endif
  87
  88 #ifndef LONG_LONG_TYPE_SIZE
  89 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
  90 #endif
  91
  92 #ifndef WCHAR_UNSIGNED
  93 #define WCHAR_UNSIGNED 0
  94 #endif
  95
  96 #ifndef FLOAT_TYPE_SIZE
  97 #define FLOAT_TYPE_SIZE BITS_PER_WORD
  98 #endif
  99
 100 #ifndef DOUBLE_TYPE_SIZE
 101 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 102 #endif
 103
 104 #ifndef LONG_DOUBLE_TYPE_SIZE
 105 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 106 #endif
 107
 108 #ifndef BOOL_TYPE_SIZE
 109 #ifdef SLOW_BYTE_ACCESS
 110 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
 111 #else
 112 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
 113 #endif
 114 #endif
 115
 116 /* We let tm.h override the types used here, to handle trivial differences
 117    such as the choice of unsigned int or long unsigned int for size_t.
 118    When machines start needing nontrivial differences in the size type,
 119    it would be best to do something here to figure out automatically
 120    from other information what type to use.  */
 121
 122 #ifndef SIZE_TYPE
 123 #define SIZE_TYPE "long unsigned int"
 124 #endif
 125
 126 #ifndef PTRDIFF_TYPE
 127 #define PTRDIFF_TYPE "long int"
 128 #endif
 129
 130 #ifndef WCHAR_TYPE
 131 #define WCHAR_TYPE "int"
 132 #endif
 133
 134 static tree grokparms                           PROTO((tree, int));
 135 static tree lookup_nested_type                  PROTO((tree, tree));
 136 static char *redeclaration_error_message        PROTO((tree, tree));
 137 static tree push_overloaded_decl                PROTO((tree, int));
 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 int namespace_bindings_p PROTO((void));
 148 static void declare_namespace_level PROTO((void));
 149 static void signal_catch PROTO((int));
 150 static void storedecls PROTO((tree));
 151 static void storetags PROTO((tree));
 152 static void require_complete_types_for_parms PROTO((tree));
 153 static void push_overloaded_decl_1 PROTO((tree));
 154 static int ambi_op_p PROTO((tree));
 155 static int unary_op_p PROTO((tree));
 156 static tree store_bindings PROTO((tree, tree));
 157 static tree lookup_tag_reverse PROTO((tree, tree));
 158 static tree obscure_complex_init PROTO((tree, tree));
 159 static tree maybe_build_cleanup_1 PROTO((tree, tree));
 160 static tree lookup_name_real PROTO((tree, int, int, int));
 161 static void warn_extern_redeclared_static PROTO((tree, tree));
 162 static void grok_reference_init PROTO((tree, tree, tree));
 163 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
 164                               enum overload_flags, tree,
 165                               tree, tree, int, int, int, int, int, int, tree));
 166 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
 167 static tree lookup_tag PROTO((enum tree_code, tree,
 168                               struct binding_level *, int));
 169 static void set_identifier_type_value_with_scope
 170         PROTO((tree, tree, struct binding_level *));
 171 static void record_builtin_type PROTO((enum rid, char *, tree));
 172 static void record_unknown_type PROTO((tree, char *));
 173 static int member_function_or_else PROTO((tree, tree, char *));
 174 static void bad_specifiers PROTO((tree, char *, int, int, int, int,
 175                                   int));
 176 static void lang_print_error_function PROTO((char *));
 177
 178 #if defined (DEBUG_CP_BINDING_LEVELS)
 179 static void indent PROTO((void));
 180 #endif
 181
 182 /* A node which has tree code ERROR_MARK, and whose type is itself.
 183    All erroneous expressions are replaced with this node.  All functions
 184    that accept nodes as arguments should avoid generating error messages
 185    if this node is one of the arguments, since it is undesirable to get
 186    multiple error messages from one error in the input.  */
 187
 188 tree error_mark_node;
 189
 190 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 191 tree error_mark_list;
 192
 193 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
 194
 195 tree short_integer_type_node;
 196 tree integer_type_node;
 197 tree long_integer_type_node;
 198 tree long_long_integer_type_node;
 199
 200 tree short_unsigned_type_node;
 201 tree unsigned_type_node;
 202 tree long_unsigned_type_node;
 203 tree long_long_unsigned_type_node;
 204
 205 tree ptrdiff_type_node;
 206
 207 tree unsigned_char_type_node;
 208 tree signed_char_type_node;
 209 tree char_type_node;
 210 tree wchar_type_node;
 211 tree signed_wchar_type_node;
 212 tree unsigned_wchar_type_node;
 213
 214 tree wchar_decl_node;
 215
 216 tree float_type_node;
 217 tree double_type_node;
 218 tree long_double_type_node;
 219
 220 tree complex_integer_type_node;
 221 tree complex_float_type_node;
 222 tree complex_double_type_node;
 223 tree complex_long_double_type_node;
 224
 225 tree intQI_type_node;
 226 tree intHI_type_node;
 227 tree intSI_type_node;
 228 tree intDI_type_node;
 229 tree intTI_type_node;
 230
 231 tree unsigned_intQI_type_node;
 232 tree unsigned_intHI_type_node;
 233 tree unsigned_intSI_type_node;
 234 tree unsigned_intDI_type_node;
 235 tree unsigned_intTI_type_node;
 236
 237 tree java_byte_type_node;
 238 tree java_short_type_node;
 239 tree java_int_type_node;
 240 tree java_long_type_node;
 241 tree java_float_type_node;
 242 tree java_double_type_node;
 243 tree java_char_type_node;
 244 tree java_boolean_type_node;
 245
 246 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST.  */
 247
 248 tree void_type_node, void_list_node;
 249 tree void_zero_node;
 250
 251 /* Nodes for types `void *' and `const void *'.  */
 252
 253 tree ptr_type_node;
 254 tree const_ptr_type_node;
 255
 256 /* Nodes for types `char *' and `const char *'.  */
 257
 258 tree string_type_node, const_string_type_node;
 259
 260 /* Type `char[256]' or something like it.
 261    Used when an array of char is needed and the size is irrelevant.  */
 262
 263 tree char_array_type_node;
 264
 265 /* Type `int[256]' or something like it.
 266    Used when an array of int needed and the size is irrelevant.  */
 267
 268 tree int_array_type_node;
 269
 270 /* Type `wchar_t[256]' or something like it.
 271    Used when a wide string literal is created.  */
 272
 273 tree wchar_array_type_node;
 274
 275 /* The bool data type, and constants */
 276 tree boolean_type_node, boolean_true_node, boolean_false_node;
 277
 278 /* Type `int ()' -- used for implicit declaration of functions.  */
 279
 280 tree default_function_type;
 281
 282 /* Function types `double (double)' and `double (double, double)', etc.  */
 283
 284 static tree double_ftype_double, double_ftype_double_double;
 285 static tree int_ftype_int, long_ftype_long;
 286 static tree float_ftype_float;
 287 static tree ldouble_ftype_ldouble;
 288
 289 /* Function type `int (const void *, const void *, size_t)' */
 290 static tree int_ftype_cptr_cptr_sizet;
 291
 292 /* C++ extensions */
 293 tree vtable_entry_type;
 294 tree delta_type_node;
 295 #if 0
 296 /* Old rtti stuff.  */
 297 tree __baselist_desc_type_node;
 298 tree __i_desc_type_node, __m_desc_type_node;
 299 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 300 #endif
 301 tree __t_desc_type_node;
 302 #if 0
 303 tree __tp_desc_type_node;
 304 #endif
 305 tree __access_mode_type_node;
 306 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
 307 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
 308 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
 309 #if 0
 310 /* Not needed yet?  May be needed one day?  */
 311 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 312 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 313 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 314 #endif
 315
 316 /* Indicates that there is a type value in some namespace, although
 317    that is not necessarily in scope at the moment. */
 318
 319 static tree global_type_node;
 320
 321 tree class_star_type_node;
 322 tree class_type_node, record_type_node, union_type_node, enum_type_node;
 323 tree unknown_type_node;
 324 tree opaque_type_node, signature_type_node;
 325 tree sigtable_entry_type;
 326
 327 /* Array type `vtable_entry_type[]' */
 328 tree vtbl_type_node;
 329
 330 /* namespace std */
 331 tree std_node;
 332 int in_std = 0;
 333
 334 /* Expect only namespace names now. */
 335 static int only_namespace_names;
 336
 337 /* In a destructor, the point at which all derived class destroying
 338    has been done, just before any base class destroying will be done.  */
 339
 340 tree dtor_label;
 341
 342 /* In a destructor, the last insn emitted after the start of the
 343    function and the parms.  */
 344
 345 static rtx last_dtor_insn;
 346
 347 /* In a constructor, the last insn emitted after the start of the
 348    function and the parms, the exception specification and any
 349    function-try-block.  The constructor initializers are emitted after
 350    this insn.  */
 351
 352 static rtx last_parm_cleanup_insn;
 353
 354 /* In a constructor, the point at which we are ready to return
 355    the pointer to the initialized object.  */
 356
 357 tree ctor_label;
 358
 359 /* A FUNCTION_DECL which can call `abort'.  Not necessarily the
 360    one that the user will declare, but sufficient to be called
 361    by routines that want to abort the program.  */
 362
 363 tree abort_fndecl;
 364
 365 extern rtx cleanup_label, return_label;
 366
 367 /* If original DECL_RESULT of current function was a register,
 368    but due to being an addressable named return value, would up
 369    on the stack, this variable holds the named return value's
 370    original location.  */
 371 static rtx original_result_rtx;
 372
 373 /* Sequence of insns which represents base initialization.  */
 374 tree base_init_expr;
 375
 376 /* C++: Keep these around to reduce calls to `get_identifier'.
 377    Identifiers for `this' in member functions and the auto-delete
 378    parameter for destructors.  */
 379 tree this_identifier, in_charge_identifier;
 380 tree ctor_identifier, dtor_identifier;
 381 /* Used in pointer to member functions, in vtables, and in sigtables.  */
 382 tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
 383 tree pfn_or_delta2_identifier, tag_identifier;
 384 tree vt_off_identifier;
 385
 386 struct named_label_list
 387 {
 388   struct binding_level *binding_level;
 389   tree names_in_scope;
 390   tree label_decl;
 391   char *filename_o_goto;
 392   int lineno_o_goto;
 393   struct named_label_list *next;
 394 };
 395
 396 /* A list (chain of TREE_LIST nodes) of named label uses.
 397    The TREE_PURPOSE field is the list of variables defined
 398    in the label's scope defined at the point of use.
 399    The TREE_VALUE field is the LABEL_DECL used.
 400    The TREE_TYPE field holds `current_binding_level' at the
 401    point of the label's use.
 402
 403    BWAHAHAAHAHahhahahahaah.  No, no, no, said the little chicken.
 404
 405    Look at the pretty struct named_label_list. See the pretty struct
 406    with the pretty named fields that describe what they do. See the
 407    pretty lack of gratuitous casts. Notice the code got a lot cleaner.
 408
 409    Used only for jumps to as-yet undefined labels, since
 410    jumps to defined labels can have their validity checked
 411    by stmt.c.  */
 412
 413 static struct named_label_list *named_label_uses = NULL;
 414
 415 /* A list of objects which have constructors or destructors
 416    which reside in the global scope.  The decl is stored in
 417    the TREE_VALUE slot and the initializer is stored
 418    in the TREE_PURPOSE slot.  */
 419 tree static_aggregates;
 420
 421 /* -- end of C++ */
 422
 423 /* Two expressions that are constants with value zero.
 424    The first is of type `int', the second of type `void *'.  */
 425
 426 tree integer_zero_node;
 427 tree null_pointer_node;
 428
 429 /* The value for __null (NULL), either of type `void *' or, with -ansi,
 430    an integer type of the same size.  */
 431
 432 tree null_node;
 433
 434 /* A node for the integer constants 1, 2, and 3.  */
 435
 436 tree integer_one_node, integer_two_node, integer_three_node;
 437
 438 /* While defining an enum type, this is 1 plus the last enumerator
 439    constant value.  */
 440
 441 static tree enum_next_value;
 442
 443 /* Nonzero means that there was overflow computing enum_next_value.  */
 444
 445 static int enum_overflow;
 446
 447 /* Parsing a function declarator leaves a list of parameter names
 448    or a chain or parameter decls here.  */
 449
 450 tree last_function_parms;
 451
 452 /* Parsing a function declarator leaves here a chain of structure
 453    and enum types declared in the parmlist.  */
 454
 455 static tree last_function_parm_tags;
 456
 457 /* After parsing the declarator that starts a function definition,
 458    `start_function' puts here the list of parameter names or chain of decls.
 459    `store_parm_decls' finds it here.  */
 460
 461 static tree current_function_parms;
 462
 463 /* Similar, for last_function_parm_tags.  */
 464 static tree current_function_parm_tags;
 465
 466 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 467    that have names.  Here so we can clear out their names' definitions
 468    at the end of the function.  */
 469
 470 static tree named_labels;
 471
 472 /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
 473
 474 static tree shadowed_labels;
 475
 476 /* The FUNCTION_DECL for the function currently being compiled,
 477    or 0 if between functions.  */
 478 tree current_function_decl;
 479
 480 /* Set to 0 at beginning of a function definition, set to 1 if
 481    a return statement that specifies a return value is seen.  */
 482
 483 int current_function_returns_value;
 484
 485 /* Set to 0 at beginning of a function definition, set to 1 if
 486    a return statement with no argument is seen.  */
 487
 488 int current_function_returns_null;
 489
 490 /* Set to 0 at beginning of a function definition, and whenever
 491    a label (case or named) is defined.  Set to value of expression
 492    returned from function when that value can be transformed into
 493    a named return value.  */
 494
 495 tree current_function_return_value;
 496
 497 /* Set to nonzero by `grokdeclarator' for a function
 498    whose return type is defaulted, if warnings for this are desired.  */
 499
 500 static int warn_about_return_type;
 501
 502 /* Nonzero means give `double' the same size as `float'.  */
 503
 504 extern int flag_short_double;
 505
 506 /* Nonzero means don't recognize any builtin functions.  */
 507
 508 extern int flag_no_builtin;
 509
 510 /* Nonzero means don't recognize the non-ANSI builtin functions.
 511    -ansi sets this.  */
 512
 513 extern int flag_no_nonansi_builtin;
 514
 515 /* Nonzero means enable obscure ANSI features and disable GNU extensions
 516    that might cause ANSI-compliant code to be miscompiled.  */
 517
 518 extern int flag_ansi;
 519
 520 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 521    objects.  */
 522 extern int flag_huge_objects;
 523
 524 /* Nonzero if we want to conserve space in the .o files.  We do this
 525    by putting uninitialized data and runtime initialized data into
 526    .common instead of .data at the expense of not flagging multiple
 527    definitions.  */
 528 extern int flag_conserve_space;
 529
 530 /* Pointers to the base and current top of the language name stack.  */
 531
 532 extern tree *current_lang_base, *current_lang_stack;
 533 \f
 534 /* C and C++ flags are in decl2.c.  */
 535
 536 /* Set to 0 at beginning of a constructor, set to 1
 537    if that function does an allocation before referencing its
 538    instance variable.  */
 539 static int current_function_assigns_this;
 540 int current_function_just_assigned_this;
 541
 542 /* Set to 0 at beginning of a function.  Set non-zero when
 543    store_parm_decls is called.  Don't call store_parm_decls
 544    if this flag is non-zero!  */
 545 int current_function_parms_stored;
 546
 547 /* Flag used when debugging spew.c */
 548
 549 extern int spew_debug;
 550
 551 /* This is a copy of the class_shadowed list of the previous class binding
 552    contour when at global scope.  It's used to reset IDENTIFIER_CLASS_VALUEs
 553    when entering another class scope (i.e. a cache miss).  */
 554 extern tree previous_class_values;
 555
 556 /* A expression of value 0 with the same precision as a sizetype
 557    node, but signed.  */
 558 tree signed_size_zero_node;
 559
 560 \f
 561 /* Allocate a level of searching.  */
 562
 563 static
 564 struct stack_level *
 565 push_decl_level (stack, obstack)
 566      struct stack_level *stack;
 567      struct obstack *obstack;
 568 {
 569   struct stack_level tem;
 570   tem.prev = stack;
 571
 572   return push_stack_level (obstack, (char *)&tem, sizeof (tem));
 573 }
 574 \f
 575 /* For each binding contour we allocate a binding_level structure
 576    which records the names defined in that contour.
 577    Contours include:
 578     0) the global one
 579     1) one for each function definition,
 580        where internal declarations of the parameters appear.
 581     2) one for each compound statement,
 582        to record its declarations.
 583
 584    The current meaning of a name can be found by searching the levels
 585    from the current one out to the global one.
 586
 587    Off to the side, may be the class_binding_level.  This exists only
 588    to catch class-local declarations.  It is otherwise nonexistent.
 589
 590    Also there may be binding levels that catch cleanups that must be
 591    run when exceptions occur.  */
 592
 593 /* Note that the information in the `names' component of the global contour
 594    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 595
 596 struct binding_level
 597   {
 598     /* A chain of _DECL nodes for all variables, constants, functions,
 599        and typedef types.  These are in the reverse of the order
 600        supplied.  */
 601     tree names;
 602
 603     /* A list of structure, union and enum definitions, for looking up
 604        tag names.
 605        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 606        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 607        or ENUMERAL_TYPE node.
 608
 609        C++: the TREE_VALUE nodes can be simple types for
 610        component_bindings.  */
 611     tree tags;
 612
 613     /* A list of USING_DECL nodes. */
 614     tree usings;
 615
 616     /* For each level, a list of shadowed outer-level local definitions
 617        to be restored when this level is popped.
 618        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 619        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 620     tree shadowed;
 621
 622     /* Same, for IDENTIFIER_CLASS_VALUE.  */
 623     tree class_shadowed;
 624
 625     /* Same, for IDENTIFIER_TYPE_VALUE.  */
 626     tree type_shadowed;
 627
 628     /* For each level (except not the global one),
 629        a chain of BLOCK nodes for all the levels
 630        that were entered and exited one level down.  */
 631     tree blocks;
 632
 633     /* The BLOCK node for this level, if one has been preallocated.
 634        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 635     tree this_block;
 636
 637     /* The binding level which this one is contained in (inherits from).  */
 638     struct binding_level *level_chain;
 639
 640     /* List of decls in `names' that have incomplete
 641        structure or union types.  */
 642     tree incomplete;
 643
 644     /* List of VAR_DECLS saved from a previous for statement.
 645        These would be dead in ANSI-conforming code, but might
 646        be referenced in ARM-era code.  */
 647     tree dead_vars_from_for;
 648
 649     /* 1 for the level that holds the parameters of a function.
 650        2 for the level that holds a class declaration.
 651        3 for levels that hold parameter declarations.  */
 652     unsigned parm_flag : 4;
 653
 654     /* 1 means make a BLOCK for this level regardless of all else.
 655        2 for temporary binding contours created by the compiler.  */
 656     unsigned keep : 3;
 657
 658     /* Nonzero if this level "doesn't exist" for tags.  */
 659     unsigned tag_transparent : 1;
 660
 661     /* Nonzero if this level can safely have additional
 662        cleanup-needing variables added to it.  */
 663     unsigned more_cleanups_ok : 1;
 664     unsigned have_cleanups : 1;
 665
 666     /* Nonzero if this level is for storing the decls for template
 667        parameters and generic decls; these decls will be discarded and
 668        replaced with a TEMPLATE_DECL.  */
 669     unsigned pseudo_global : 1;
 670
 671     /* This is set for a namespace binding level.  */
 672     unsigned namespace_p : 1;
 673
 674     /* True if this level is that of a for-statement where we need to
 675        worry about ambiguous (ARM or ANSI) scope rules.  */
 676     unsigned is_for_scope : 1;
 677
 678     /* Two bits left for this word.  */
 679
 680 #if defined(DEBUG_CP_BINDING_LEVELS)
 681     /* Binding depth at which this level began.  */
 682     unsigned binding_depth;
 683 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 684   };
 685
 686 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 687
 688 /* The (non-class) binding level currently in effect.  */
 689
 690 static struct binding_level *current_binding_level;
 691
 692 /* The binding level of the current class, if any.  */
 693
 694 static struct binding_level *class_binding_level;
 695
 696 /* The current (class or non-class) binding level currently in effect.  */
 697
 698 #define inner_binding_level \
 699   (class_binding_level ? class_binding_level : current_binding_level)
 700
 701 /* A chain of binding_level structures awaiting reuse.  */
 702
 703 static struct binding_level *free_binding_level;
 704
 705 /* The outermost binding level, for names of file scope.
 706    This is created when the compiler is started and exists
 707    through the entire run.  */
 708
 709 static struct binding_level *global_binding_level;
 710
 711 /* Binding level structures are initialized by copying this one.  */
 712
 713 static struct binding_level clear_binding_level;
 714
 715 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 716
 717 static int keep_next_level_flag;
 718
 719 #if defined(DEBUG_CP_BINDING_LEVELS)
 720 static int binding_depth = 0;
 721 static int is_class_level = 0;
 722
 723 static void
 724 indent ()
 725 {
 726   register unsigned i;
 727
 728   for (i = 0; i < binding_depth*2; i++)
 729     putc (' ', stderr);
 730 }
 731 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 732
 733 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
 734
 735 static void
 736 push_binding_level (newlevel, tag_transparent, keep)
 737      struct binding_level *newlevel;
 738      int tag_transparent, keep;
 739 {
 740   /* Add this level to the front of the chain (stack) of levels that
 741      are active.  */
 742   *newlevel = clear_binding_level;
 743   if (class_binding_level)
 744     {
 745       newlevel->level_chain = class_binding_level;
 746       class_binding_level = (struct binding_level *)0;
 747     }
 748   else
 749     {
 750       newlevel->level_chain = current_binding_level;
 751     }
 752   current_binding_level = newlevel;
 753   newlevel->tag_transparent = tag_transparent;
 754   newlevel->more_cleanups_ok = 1;
 755   newlevel->keep = keep;
 756 #if defined(DEBUG_CP_BINDING_LEVELS)
 757   newlevel->binding_depth = binding_depth;
 758   indent ();
 759   fprintf (stderr, "push %s level 0x%08x line %d\n",
 760            (is_class_level) ? "class" : "block", newlevel, lineno);
 761   is_class_level = 0;
 762   binding_depth++;
 763 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 764 }
 765
 766 static void
 767 pop_binding_level ()
 768 {
 769   if (class_binding_level)
 770     current_binding_level = class_binding_level;
 771
 772   if (global_binding_level)
 773     {
 774       /* Cannot pop a level, if there are none left to pop.  */
 775       if (current_binding_level == global_binding_level)
 776         my_friendly_abort (123);
 777     }
 778   /* Pop the current level, and free the structure for reuse.  */
 779 #if defined(DEBUG_CP_BINDING_LEVELS)
 780   binding_depth--;
 781   indent ();
 782   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 783           (is_class_level) ? "class" : "block",
 784           current_binding_level, lineno);
 785   if (is_class_level != (current_binding_level == class_binding_level))
 786     {
 787       indent ();
 788       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 789     }
 790   is_class_level = 0;
 791 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 792   {
 793     register struct binding_level *level = current_binding_level;
 794     current_binding_level = current_binding_level->level_chain;
 795     level->level_chain = free_binding_level;
 796 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 797     if (level->binding_depth != binding_depth)
 798       abort ();
 799 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 800       free_binding_level = level;
 801
 802     class_binding_level = current_binding_level;
 803     if (class_binding_level->parm_flag != 2)
 804       class_binding_level = 0;
 805     while (current_binding_level->parm_flag == 2)
 806       current_binding_level = current_binding_level->level_chain;
 807   }
 808 }
 809
 810 static void
 811 suspend_binding_level ()
 812 {
 813   if (class_binding_level)
 814     current_binding_level = class_binding_level;
 815
 816   if (global_binding_level)
 817     {
 818       /* Cannot suspend a level, if there are none left to suspend.  */
 819       if (current_binding_level == global_binding_level)
 820         my_friendly_abort (123);
 821     }
 822   /* Suspend the current level.  */
 823 #if defined(DEBUG_CP_BINDING_LEVELS)
 824   binding_depth--;
 825   indent ();
 826   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 827           (is_class_level) ? "class" : "block",
 828           current_binding_level, lineno);
 829   if (is_class_level != (current_binding_level == class_binding_level))
 830     {
 831       indent ();
 832       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 833     }
 834   is_class_level = 0;
 835 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 836   {
 837     current_binding_level = current_binding_level->level_chain;
 838     class_binding_level = current_binding_level;
 839     if (class_binding_level->parm_flag != 2)
 840       class_binding_level = 0;
 841     while (current_binding_level->parm_flag == 2)
 842       current_binding_level = current_binding_level->level_chain;
 843   }
 844 }
 845
 846 static void
 847 resume_binding_level (b)
 848      struct binding_level *b;
 849 {
 850   /* Resuming binding levels is meant only for namespaces,
 851      and those cannot nest into classes. */
 852   my_friendly_assert(!class_binding_level, 386);
 853   /* Also, resuming a non-directly nested namespace is a no-no.  */
 854   my_friendly_assert(b->level_chain == current_binding_level, 386);
 855   current_binding_level = b;
 856 #if defined(DEBUG_CP_BINDING_LEVELS)
 857   b->binding_depth = binding_depth;
 858   indent ();
 859   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 860            (is_class_level) ? "class" : "block", b, lineno);
 861   is_class_level = 0;
 862   binding_depth++;
 863 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 864 }
 865 \f
 866 /* Create a new `struct binding_level'.  */
 867
 868 static
 869 struct binding_level *
 870 make_binding_level ()
 871 {
 872   /* NOSTRICT */
 873   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 874 }
 875
 876 /* Nonzero if we are currently in the global binding level.  */
 877
 878 int
 879 global_bindings_p ()
 880 {
 881   return current_binding_level == global_binding_level;
 882 }
 883
 884 /* Nonzero if we are currently in a toplevel binding level.  This
 885    means either the global binding level or a namespace in a toplevel
 886    binding level.
 887    Since there are no non-toplevel namespace levels, this really
 888    means any namespace or pseudo-global level.  */
 889
 890 int
 891 toplevel_bindings_p ()
 892 {
 893   return current_binding_level->namespace_p
 894     || current_binding_level->pseudo_global;
 895 }
 896
 897 /* Nonzero if this is a namespace scope.  */
 898
 899 static int
 900 namespace_bindings_p ()
 901 {
 902   return current_binding_level->namespace_p;
 903 }
 904
 905 void
 906 keep_next_level ()
 907 {
 908   keep_next_level_flag = 1;
 909 }
 910
 911 /* Nonzero if the current level needs to have a BLOCK made.  */
 912
 913 int
 914 kept_level_p ()
 915 {
 916   return (current_binding_level->blocks != NULL_TREE
 917           || current_binding_level->keep
 918           || current_binding_level->names != NULL_TREE
 919           || (current_binding_level->tags != NULL_TREE
 920               && !current_binding_level->tag_transparent));
 921 }
 922
 923 /* Identify this binding level as a level of parameters.  */
 924
 925 void
 926 declare_parm_level ()
 927 {
 928   current_binding_level->parm_flag = 1;
 929 }
 930
 931 void
 932 declare_pseudo_global_level ()
 933 {
 934   current_binding_level->pseudo_global = 1;
 935 }
 936
 937 static void
 938 declare_namespace_level ()
 939 {
 940   current_binding_level->namespace_p = 1;
 941 }
 942
 943 int
 944 pseudo_global_level_p ()
 945 {
 946   return current_binding_level->pseudo_global;
 947 }
 948
 949 void
 950 set_class_shadows (shadows)
 951      tree shadows;
 952 {
 953   class_binding_level->class_shadowed = shadows;
 954 }
 955
 956 /* Enter a new binding level.
 957    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 958    not for that of tags.  */
 959
 960 void
 961 pushlevel (tag_transparent)
 962      int tag_transparent;
 963 {
 964   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
 965
 966   /* If this is the top level of a function,
 967      just make sure that NAMED_LABELS is 0.
 968      They should have been set to 0 at the end of the previous function.  */
 969
 970   if (current_binding_level == global_binding_level)
 971     my_friendly_assert (named_labels == NULL_TREE, 134);
 972
 973   /* Reuse or create a struct for this binding level.  */
 974
 975 #if defined(DEBUG_CP_BINDING_LEVELS)
 976   if (0)
 977 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 978   if (free_binding_level)
 979 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 980     {
 981       newlevel = free_binding_level;
 982       free_binding_level = free_binding_level->level_chain;
 983     }
 984   else
 985     {
 986       newlevel = make_binding_level ();
 987     }
 988
 989   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 990   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 991   keep_next_level_flag = 0;
 992 }
 993
 994 void
 995 note_level_for_for ()
 996 {
 997   current_binding_level->is_for_scope = 1;
 998 }
 999
1000 void
1001 pushlevel_temporary (tag_transparent)
1002      int tag_transparent;
1003 {
1004   pushlevel (tag_transparent);
1005   current_binding_level->keep = 2;
1006   clear_last_expr ();
1007
1008   /* Note we don't call push_momentary() here.  Otherwise, it would cause
1009      cleanups to be allocated on the momentary obstack, and they will be
1010      overwritten by the next statement.  */
1011
1012   expand_start_bindings (0);
1013 }
1014
1015 /* Exit a binding level.
1016    Pop the level off, and restore the state of the identifier-decl mappings
1017    that were in effect when this level was entered.
1018
1019    If KEEP == 1, this level had explicit declarations, so
1020    and create a "block" (a BLOCK node) for the level
1021    to record its declarations and subblocks for symbol table output.
1022
1023    If KEEP == 2, this level's subblocks go to the front,
1024    not the back of the current binding level.  This happens,
1025    for instance, when code for constructors and destructors
1026    need to generate code at the end of a function which must
1027    be moved up to the front of the function.
1028
1029    If FUNCTIONBODY is nonzero, this level is the body of a function,
1030    so create a block as if KEEP were set and also clear out all
1031    label names.
1032
1033    If REVERSE is nonzero, reverse the order of decls before putting
1034    them into the BLOCK.  */
1035
1036 tree
1037 poplevel (keep, reverse, functionbody)
1038      int keep;
1039      int reverse;
1040      int functionbody;
1041 {
1042   register tree link;
1043   /* The chain of decls was accumulated in reverse order.
1044      Put it into forward order, just for cleanliness.  */
1045   tree decls;
1046   int tmp = functionbody;
1047   int real_functionbody = current_binding_level->keep == 2
1048     ? ((functionbody = 0), tmp) : functionbody;
1049   tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
1050   tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1051   tree block = NULL_TREE;
1052   tree decl;
1053   int block_previously_created;
1054
1055   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1056                       (HOST_WIDE_INT) current_binding_level->level_chain,
1057                       current_binding_level->parm_flag,
1058                       current_binding_level->keep);
1059
1060   if (current_binding_level->keep == 1)
1061     keep = 1;
1062
1063   /* Get the decls in the order they were written.
1064      Usually current_binding_level->names is in reverse order.
1065      But parameter decls were previously put in forward order.  */
1066
1067   if (reverse)
1068     current_binding_level->names
1069       = decls = nreverse (current_binding_level->names);
1070   else
1071     decls = current_binding_level->names;
1072
1073   /* Output any nested inline functions within this block
1074      if they weren't already output.  */
1075
1076   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1077     if (TREE_CODE (decl) == FUNCTION_DECL
1078         && ! TREE_ASM_WRITTEN (decl)
1079         && DECL_INITIAL (decl) != NULL_TREE
1080         && TREE_ADDRESSABLE (decl)
1081         && decl_function_context (decl) == current_function_decl)
1082       {
1083         /* If this decl was copied from a file-scope decl
1084            on account of a block-scope extern decl,
1085            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1086         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1087           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1088         else
1089           {
1090             push_function_context ();
1091             output_inline_function (decl);
1092             pop_function_context ();
1093           }
1094       }
1095
1096   /* If there were any declarations or structure tags in that level,
1097      or if this level is a function body,
1098      create a BLOCK to record them for the life of this function.  */
1099
1100   block = NULL_TREE;
1101   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1102   if (block_previously_created)
1103     block = current_binding_level->this_block;
1104   else if (keep == 1 || functionbody)
1105     block = make_node (BLOCK);
1106   if (block != NULL_TREE)
1107     {
1108       if (block_previously_created)
1109         {
1110           if (decls || tags || subblocks)
1111             {
1112               if (BLOCK_VARS (block) || BLOCK_TYPE_TAGS (block))
1113                 {
1114                   warning ("internal compiler error: debugging info corrupted");
1115                 }
1116               BLOCK_VARS (block) = decls;
1117               BLOCK_TYPE_TAGS (block) = tags;
1118
1119               /* We can have previous subblocks and new subblocks when
1120                  doing fixup_gotos with complex cleanups.  We chain the new
1121                  subblocks onto the end of any pre-existing subblocks.  */
1122               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1123                                                  subblocks);
1124             }
1125           /* If we created the block earlier on, and we are just
1126              diddling it now, then it already should have a proper
1127              BLOCK_END_NOTE value associated with it.  */
1128         }
1129       else
1130         {
1131           BLOCK_VARS (block) = decls;
1132           BLOCK_TYPE_TAGS (block) = tags;
1133           BLOCK_SUBBLOCKS (block) = subblocks;
1134           /* Otherwise, for a new block, install a new BLOCK_END_NOTE value.  */
1135           remember_end_note (block);
1136         }
1137     }
1138
1139   /* In each subblock, record that this is its superior.  */
1140
1141   if (keep >= 0)
1142     for (link = subblocks; link; link = TREE_CHAIN (link))
1143       BLOCK_SUPERCONTEXT (link) = block;
1144
1145   /* Clear out the meanings of the local variables of this level.  */
1146
1147   if (current_binding_level->is_for_scope && flag_new_for_scope == 1)
1148     {
1149       struct binding_level *outer = current_binding_level->level_chain;
1150       for (link = decls; link; link = TREE_CHAIN (link))
1151         {
1152           if (TREE_CODE (link) == VAR_DECL)
1153             DECL_DEAD_FOR_LOCAL (link) = 1;
1154           else
1155             IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
1156         }
1157
1158       /* Save declarations made in a 'for' statement so we can support pre-ANSI
1159          'for' scoping semantics.  */
1160
1161       for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1162         {
1163           tree id = TREE_PURPOSE (link);
1164           tree decl = IDENTIFIER_LOCAL_VALUE (id);
1165
1166           if (decl && DECL_DEAD_FOR_LOCAL (decl))
1167             {
1168               /* In this case keep the dead for-decl visible,
1169                  but remember what (if anything) it shadowed.  */
1170               DECL_SHADOWED_FOR_VAR (decl) = TREE_VALUE (link);
1171               TREE_CHAIN (decl) = outer->dead_vars_from_for;
1172               outer->dead_vars_from_for = decl;
1173             }
1174           else
1175             IDENTIFIER_LOCAL_VALUE (id) = TREE_VALUE (link);
1176         }
1177     }
1178   else /* Not special for scope.  */
1179     {
1180       for (link = decls; link; link = TREE_CHAIN (link))
1181         {
1182           if (DECL_NAME (link) != NULL_TREE)
1183             {
1184               /* If the ident. was used or addressed via a local extern decl,
1185                  don't forget that fact.  */
1186               if (DECL_EXTERNAL (link))
1187                 {
1188                   if (TREE_USED (link))
1189                     TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
1190                   if (TREE_ADDRESSABLE (link))
1191                     TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1192                 }
1193               IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
1194             }
1195         }
1196
1197       /* Restore all name-meanings of the outer levels
1198          that were shadowed by this level.  */
1199
1200       for (link = current_binding_level->shadowed;
1201            link; link = TREE_CHAIN (link))
1202         IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1203
1204       /* We first restore the regular decls and *then* the dead_vars_from_for
1205          to handle this case:
1206
1207          int i; // i#1
1208          {
1209            for (int i; ; ) { ...} // i#2
1210            int i; // i#3
1211          } // we are here
1212
1213          In this case, we want remove the binding for i#3, restoring
1214          that of i#2.  Then we want to remove the binding for i#2,
1215          and restore that of i#1.  */
1216
1217       link = current_binding_level->dead_vars_from_for;
1218       for (; link != NULL_TREE; link = TREE_CHAIN (link))
1219         {
1220           tree id = DECL_NAME (link);
1221           if (IDENTIFIER_LOCAL_VALUE (id) == link)
1222             IDENTIFIER_LOCAL_VALUE (id) = DECL_SHADOWED_FOR_VAR (link);
1223         }
1224
1225       for (link = current_binding_level->class_shadowed;
1226            link; link = TREE_CHAIN (link))
1227         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1228       for (link = current_binding_level->type_shadowed;
1229            link; link = TREE_CHAIN (link))
1230         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1231     }
1232
1233   /* If the level being exited is the top level of a function,
1234      check over all the labels.  */
1235
1236   if (functionbody)
1237     {
1238       /* If this is the top level block of a function,
1239          the vars are the function's parameters.
1240          Don't leave them in the BLOCK because they are
1241          found in the FUNCTION_DECL instead.  */
1242
1243       BLOCK_VARS (block) = 0;
1244
1245       /* Clear out the definitions of all label names,
1246          since their scopes end here.  */
1247
1248       for (link = named_labels; link; link = TREE_CHAIN (link))
1249         {
1250           register tree label = TREE_VALUE (link);
1251
1252           if (DECL_INITIAL (label) == NULL_TREE)
1253             {
1254               cp_error_at ("label `%D' used but not defined", label);
1255               /* Avoid crashing later.  */
1256               define_label (input_filename, 1, DECL_NAME (label));
1257             }
1258           else if (warn_unused && !TREE_USED (label))
1259             cp_warning_at ("label `%D' defined but not used", label);
1260           SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1261
1262           /* Put the labels into the "variables" of the
1263              top-level block, so debugger can see them.  */
1264           TREE_CHAIN (label) = BLOCK_VARS (block);
1265           BLOCK_VARS (block) = label;
1266         }
1267
1268       named_labels = NULL_TREE;
1269     }
1270
1271   /* Any uses of undefined labels now operate under constraints
1272      of next binding contour.  */
1273   {
1274     struct binding_level *level_chain;
1275     level_chain = current_binding_level->level_chain;
1276     if (level_chain)
1277       {
1278         struct named_label_list *labels;
1279         for (labels = named_label_uses; labels; labels = labels->next)
1280           if (labels->binding_level == current_binding_level)
1281             {
1282               labels->binding_level = level_chain;
1283               labels->names_in_scope = level_chain->names;
1284             }
1285       }
1286   }
1287
1288   tmp = current_binding_level->keep;
1289
1290   pop_binding_level ();
1291   if (functionbody)
1292     DECL_INITIAL (current_function_decl) = block;
1293   else if (block)
1294     {
1295       if (!block_previously_created)
1296         current_binding_level->blocks
1297           = chainon (current_binding_level->blocks, block);
1298     }
1299   /* If we did not make a block for the level just exited,
1300      any blocks made for inner levels
1301      (since they cannot be recorded as subblocks in that level)
1302      must be carried forward so they will later become subblocks
1303      of something else.  */
1304   else if (subblocks)
1305     {
1306       if (keep == 2)
1307         current_binding_level->blocks
1308           = chainon (subblocks, current_binding_level->blocks);
1309       else
1310         current_binding_level->blocks
1311           = chainon (current_binding_level->blocks, subblocks);
1312     }
1313
1314   /* Take care of compiler's internal binding structures.  */
1315   if (tmp == 2)
1316     {
1317       expand_end_bindings (getdecls (), keep, 1);
1318       /* Each and every BLOCK node created here in `poplevel' is important
1319          (e.g. for proper debugging information) so if we created one
1320          earlier, mark it as "used".  */
1321       if (block)
1322         TREE_USED (block) = 1;
1323       block = poplevel (keep, reverse, real_functionbody);
1324     }
1325
1326   /* Each and every BLOCK node created here in `poplevel' is important
1327      (e.g. for proper debugging information) so if we created one
1328      earlier, mark it as "used".  */
1329   if (block)
1330     TREE_USED (block) = 1;
1331   return block;
1332 }
1333
1334 /* Delete the node BLOCK from the current binding level.
1335    This is used for the block inside a stmt expr ({...})
1336    so that the block can be reinserted where appropriate.  */
1337
1338 void
1339 delete_block (block)
1340      tree block;
1341 {
1342   tree t;
1343   if (current_binding_level->blocks == block)
1344     current_binding_level->blocks = TREE_CHAIN (block);
1345   for (t = current_binding_level->blocks; t;)
1346     {
1347       if (TREE_CHAIN (t) == block)
1348         TREE_CHAIN (t) = TREE_CHAIN (block);
1349       else
1350         t = TREE_CHAIN (t);
1351     }
1352   TREE_CHAIN (block) = NULL_TREE;
1353   /* Clear TREE_USED which is always set by poplevel.
1354      The flag is set again if insert_block is called.  */
1355   TREE_USED (block) = 0;
1356 }
1357
1358 /* Insert BLOCK at the end of the list of subblocks of the
1359    current binding level.  This is used when a BIND_EXPR is expanded,
1360    to handle the BLOCK node inside the BIND_EXPR.  */
1361
1362 void
1363 insert_block (block)
1364      tree block;
1365 {
1366   TREE_USED (block) = 1;
1367   current_binding_level->blocks
1368     = chainon (current_binding_level->blocks, block);
1369 }
1370
1371 /* Set the BLOCK node for the innermost scope
1372    (the one we are currently in).  */
1373
1374 void
1375 set_block (block)
1376     register tree block;
1377 {
1378   current_binding_level->this_block = block;
1379 }
1380
1381 /* Do a pushlevel for class declarations.  */
1382
1383 void
1384 pushlevel_class ()
1385 {
1386   register struct binding_level *newlevel;
1387
1388   /* Reuse or create a struct for this binding level.  */
1389 #if defined(DEBUG_CP_BINDING_LEVELS)
1390   if (0)
1391 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1392   if (free_binding_level)
1393 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1394     {
1395       newlevel = free_binding_level;
1396       free_binding_level = free_binding_level->level_chain;
1397     }
1398   else
1399     {
1400       newlevel = make_binding_level ();
1401     }
1402
1403 #if defined(DEBUG_CP_BINDING_LEVELS)
1404   is_class_level = 1;
1405 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1406
1407   push_binding_level (newlevel, 0, 0);
1408
1409   decl_stack = push_decl_level (decl_stack, &decl_obstack);
1410   class_binding_level = current_binding_level;
1411   class_binding_level->parm_flag = 2;
1412   /* We have just pushed into a new binding level.  Now, fake out the rest
1413      of the compiler.  Set the `current_binding_level' back to point to
1414      the most closely containing non-class binding level.  */
1415   do
1416     {
1417       current_binding_level = current_binding_level->level_chain;
1418     }
1419   while (current_binding_level->parm_flag == 2);
1420 }
1421
1422 /* ...and a poplevel for class declarations.  FORCE is used to force
1423    clearing out of CLASS_VALUEs after a class definition.  */
1424
1425 tree
1426 poplevel_class (force)
1427      int force;
1428 {
1429   register struct binding_level *level = class_binding_level;
1430   tree block = NULL_TREE;
1431   tree shadowed;
1432
1433   my_friendly_assert (level != 0, 354);
1434
1435   decl_stack = pop_stack_level (decl_stack);
1436   for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
1437     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1438   /* If we're leaving a toplevel class, don't bother to do the setting
1439      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1440      shouldn't even be used when current_class_type isn't set, and second,
1441      if we don't touch it here, we're able to use the cache effect if the
1442      next time we're entering a class scope, it is the same class.  */
1443   if (current_class_depth != 1 || force)
1444     for (shadowed = level->class_shadowed;
1445          shadowed;
1446          shadowed = TREE_CHAIN (shadowed))
1447       IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1448   else
1449     /* Remember to save what IDENTIFIER's were bound in this scope so we
1450        can recover from cache misses.  */
1451     {
1452       previous_class_type = current_class_type;
1453       previous_class_values = class_binding_level->class_shadowed;
1454     }
1455   for (shadowed = level->type_shadowed;
1456        shadowed;
1457        shadowed = TREE_CHAIN (shadowed))
1458     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1459
1460   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1461                       (HOST_WIDE_INT) class_binding_level->level_chain,
1462                       class_binding_level->parm_flag,
1463                       class_binding_level->keep);
1464
1465   if (class_binding_level->parm_flag != 2)
1466     class_binding_level = (struct binding_level *)0;
1467
1468   /* Now, pop out of the binding level which we created up in the
1469      `pushlevel_class' routine.  */
1470 #if defined(DEBUG_CP_BINDING_LEVELS)
1471   is_class_level = 1;
1472 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1473
1474   pop_binding_level ();
1475
1476   return block;
1477 }
1478 \f
1479 /* For debugging.  */
1480 static int no_print_functions = 0;
1481 static int no_print_builtins = 0;
1482
1483 void
1484 print_binding_level (lvl)
1485      struct binding_level *lvl;
1486 {
1487   tree t;
1488   int i = 0, len;
1489   fprintf (stderr, " blocks=");
1490   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1491   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1492            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1493   if (lvl->tag_transparent)
1494     fprintf (stderr, " tag-transparent");
1495   if (lvl->more_cleanups_ok)
1496     fprintf (stderr, " more-cleanups-ok");
1497   if (lvl->have_cleanups)
1498     fprintf (stderr, " have-cleanups");
1499   fprintf (stderr, "\n");
1500   if (lvl->names)
1501     {
1502       fprintf (stderr, " names:\t");
1503       /* We can probably fit 3 names to a line?  */
1504       for (t = lvl->names; t; t = TREE_CHAIN (t))
1505         {
1506           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1507             continue;
1508           if (no_print_builtins
1509               && (TREE_CODE (t) == TYPE_DECL)
1510               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1511             continue;
1512
1513           /* Function decls tend to have longer names.  */
1514           if (TREE_CODE (t) == FUNCTION_DECL)
1515             len = 3;
1516           else
1517             len = 2;
1518           i += len;
1519           if (i > 6)
1520             {
1521               fprintf (stderr, "\n\t");
1522               i = len;
1523             }
1524           print_node_brief (stderr, "", t, 0);
1525           if (t == error_mark_node)
1526             break;
1527         }
1528       if (i)
1529         fprintf (stderr, "\n");
1530     }
1531   if (lvl->tags)
1532     {
1533       fprintf (stderr, " tags:\t");
1534       i = 0;
1535       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1536         {
1537           if (TREE_PURPOSE (t) == NULL_TREE)
1538             len = 3;
1539           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1540             len = 2;
1541           else
1542             len = 4;
1543           i += len;
1544           if (i > 5)
1545             {
1546               fprintf (stderr, "\n\t");
1547               i = len;
1548             }
1549           if (TREE_PURPOSE (t) == NULL_TREE)
1550             {
1551               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1552               fprintf (stderr, ">");
1553             }
1554           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1555             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1556           else
1557             {
1558               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1559               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1560               fprintf (stderr, ">");
1561             }
1562         }
1563       if (i)
1564         fprintf (stderr, "\n");
1565     }
1566   if (lvl->shadowed)
1567     {
1568       fprintf (stderr, " shadowed:");
1569       for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
1570         {
1571           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1572         }
1573       fprintf (stderr, "\n");
1574     }
1575   if (lvl->class_shadowed)
1576     {
1577       fprintf (stderr, " class-shadowed:");
1578       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1579         {
1580           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1581         }
1582       fprintf (stderr, "\n");
1583     }
1584   if (lvl->type_shadowed)
1585     {
1586       fprintf (stderr, " type-shadowed:");
1587       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1588         {
1589           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1590         }
1591       fprintf (stderr, "\n");
1592     }
1593 }
1594
1595 void
1596 print_other_binding_stack (stack)
1597      struct binding_level *stack;
1598 {
1599   struct binding_level *level;
1600   for (level = stack; level != global_binding_level; level = level->level_chain)
1601     {
1602       fprintf (stderr, "binding level ");
1603       fprintf (stderr, HOST_PTR_PRINTF, level);
1604       fprintf (stderr, "\n");
1605       print_binding_level (level);
1606     }
1607 }
1608
1609 void
1610 print_binding_stack ()
1611 {
1612   struct binding_level *b;
1613   fprintf (stderr, "current_binding_level=");
1614   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1615   fprintf (stderr, "\nclass_binding_level=");
1616   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1617   fprintf (stderr, "\nglobal_binding_level=");
1618   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1619   fprintf (stderr, "\n");
1620   if (class_binding_level)
1621     {
1622       for (b = class_binding_level; b; b = b->level_chain)
1623         if (b == current_binding_level)
1624           break;
1625       if (b)
1626         b = class_binding_level;
1627       else
1628         b = current_binding_level;
1629     }
1630   else
1631     b = current_binding_level;
1632   print_other_binding_stack (b);
1633   fprintf (stderr, "global:\n");
1634   print_binding_level (global_binding_level);
1635 }
1636
1637 /* Namespace binding access routines: The namespace_bindings field of
1638    the identifier is polymorphic, with three possible values:
1639    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1640    indicating the BINDING_VALUE of global_namespace. */
1641
1642 /* Check whether the a binding for the name to scope is known.
1643    Assumes that the bindings of the name are already a list
1644    of bindings. Returns the binding found, or NULL_TREE. */
1645
1646 static tree
1647 find_binding (name, scope)
1648      tree name;
1649      tree scope;
1650 {
1651   tree iter, prev = NULL_TREE;
1652
1653   scope = ORIGINAL_NAMESPACE (scope);
1654
1655   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
1656        iter = TREE_CHAIN (iter))
1657     {
1658       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
1659       if (BINDING_SCOPE (iter) == scope)
1660         {
1661           /* Move binding found to the fron of the list, so
1662              subsequent lookups will find it faster. */
1663           if (prev)
1664             {
1665               TREE_CHAIN (prev) = TREE_CHAIN (iter);
1666               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
1667               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
1668             }
1669           return iter;
1670         }
1671       prev = iter;
1672     }
1673   return NULL_TREE;
1674 }
1675
1676 /* Always returns a binding for name in scope. If the
1677    namespace_bindings is not a list, convert it to one first.
1678    If no binding is found, make a new one. */
1679
1680 tree
1681 binding_for_name (name, scope)
1682      tree name;
1683      tree scope;
1684 {
1685   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1686   tree result;
1687
1688   scope = ORIGINAL_NAMESPACE (scope);
1689
1690   if (b && TREE_CODE (b) != CPLUS_BINDING)
1691     {
1692       /* Get rid of optimization for global scope. */
1693       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
1694       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
1695       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1696     }
1697   if (b && (result = find_binding (name, scope)))
1698     return result;
1699   /* Not found, make a new permanent one. */
1700   push_obstacks (&permanent_obstack, &permanent_obstack);
1701   result = make_node (CPLUS_BINDING);
1702   TREE_CHAIN (result) = b;
1703   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1704   BINDING_SCOPE (result) = scope;
1705   BINDING_TYPE (result) = NULL_TREE;
1706   BINDING_VALUE (result) = NULL_TREE;
1707   pop_obstacks ();
1708   return result;
1709 }
1710
1711 /* Return the binding value for name in scope, considering that
1712    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1713
1714 tree
1715 namespace_binding (name, scope)
1716      tree name;
1717      tree scope;
1718 {
1719   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1720   if (b == NULL_TREE)
1721     return NULL_TREE;
1722   if (TREE_CODE (b) != CPLUS_BINDING)
1723     return (scope == global_namespace) ? b : NULL_TREE;
1724   name = find_binding (name,scope);
1725   if (name == NULL_TREE)
1726     return name;
1727   return BINDING_VALUE (name);
1728 }
1729
1730 /* Set the binding value for name in scope. If modifying the binding
1731    of global_namespace is attempted, try to optimize it. */
1732
1733 void
1734 set_namespace_binding (name, scope, val)
1735      tree name;
1736      tree scope;
1737      tree val;
1738 {
1739   tree b;
1740   if (scope == global_namespace)
1741     {
1742       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1743       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
1744         {
1745           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
1746           return;
1747         }
1748     }
1749   b = binding_for_name (name, scope);
1750   BINDING_VALUE (b) = val;
1751 }
1752
1753 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
1754    select a name that is unique to this compilation unit.  */
1755
1756 void
1757 push_namespace (name)
1758      tree name;
1759 {
1760   tree d;
1761   int need_new = 1;
1762   int implicit_use = 0;
1763   int global = 0;
1764   if (!global_namespace)
1765     {
1766       /* This must be ::. */
1767       my_friendly_assert (name == get_identifier ("::"), 377);
1768       global = 1;
1769     }
1770   else if (!name)
1771     {
1772       /* The name of anonymous namespace is unique for the translation
1773          unit.  */
1774       static tree anon_name = NULL_TREE;
1775       if (!anon_name)
1776         anon_name = get_file_function_name ('N');
1777       name = anon_name;
1778       d = IDENTIFIER_NAMESPACE_VALUE (name);
1779       if (d)
1780         /* Reopening anonymous namespace.  */
1781         need_new = 0;
1782       implicit_use = 1;
1783     }
1784   else if (current_namespace == global_namespace
1785            && name == DECL_NAME (std_node))
1786     {
1787       in_std++;
1788       return;
1789     }
1790   else
1791     {
1792       /* Check whether this is an extended namespace definition. */
1793       d = IDENTIFIER_NAMESPACE_VALUE (name);
1794       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
1795         {
1796           need_new = 0;
1797           if (DECL_NAMESPACE_ALIAS (d))
1798             {
1799               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
1800                         d, DECL_NAMESPACE_ALIAS (d));
1801               d = DECL_NAMESPACE_ALIAS (d);
1802             }
1803         }
1804     }
1805
1806   if (need_new)
1807     {
1808       /* Make a new namespace, binding the name to it. */
1809       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
1810       /* The global namespace is not pushed, and the global binding
1811          level is set elsewhere.  */
1812       if (!global)
1813         {
1814           d = pushdecl (d);
1815           pushlevel (0);
1816           declare_namespace_level ();
1817           NAMESPACE_LEVEL (d) = current_binding_level;
1818         }
1819     }
1820   else
1821     resume_binding_level (NAMESPACE_LEVEL (d));
1822
1823   if (implicit_use)
1824     do_using_directive (d);
1825   /* Enter the name space. */
1826   current_namespace = d;
1827 }
1828
1829 /* Pop from the scope of the current namespace.  */
1830
1831 void
1832 pop_namespace ()
1833 {
1834   if (current_namespace == global_namespace)
1835     {
1836       my_friendly_assert (in_std>0, 980421);
1837       in_std--;
1838       return;
1839     }
1840   current_namespace = DECL_CONTEXT (current_namespace);
1841   /* The binding level is not popped, as it might be re-opened later.  */
1842   suspend_binding_level ();
1843 }
1844
1845 /* Concatenate the binding levels of all namespaces. */
1846
1847 void
1848 cat_namespace_levels()
1849 {
1850   tree current;
1851   tree last;
1852   struct binding_level *b;
1853
1854   last = NAMESPACE_LEVEL (global_namespace) -> names;
1855   /* The nested namespaces appear in the names list of their ancestors. */
1856   for (current = last; current; current = TREE_CHAIN (current))
1857     {
1858       if (TREE_CODE (current) != NAMESPACE_DECL)
1859         continue;
1860       if (!DECL_LANG_SPECIFIC (current))
1861         {
1862           /* Hmm. std. */
1863           my_friendly_assert (current == std_node, 393);
1864           continue;
1865         }
1866       b = NAMESPACE_LEVEL (current);
1867       while (TREE_CHAIN (last))
1868         last = TREE_CHAIN (last);
1869       TREE_CHAIN (last) = NAMESPACE_LEVEL (current) -> names;
1870     }
1871 }
1872 \f
1873 /* Subroutines for reverting temporarily to top-level for instantiation
1874    of templates and such.  We actually need to clear out the class- and
1875    local-value slots of all identifiers, so that only the global values
1876    are at all visible.  Simply setting current_binding_level to the global
1877    scope isn't enough, because more binding levels may be pushed.  */
1878 struct saved_scope {
1879   struct binding_level *old_binding_level;
1880   tree old_bindings;
1881   tree old_namespace;
1882   struct saved_scope *prev;
1883   tree class_name, class_type, function_decl;
1884   struct binding_level *class_bindings;
1885   tree *lang_base, *lang_stack, lang_name;
1886   int lang_stacksize;
1887   int minimal_parse_mode;
1888   tree last_function_parms;
1889   tree template_parms;
1890   HOST_WIDE_INT processing_template_decl;
1891   tree previous_class_type, previous_class_values;
1892   int processing_specialization;
1893   int processing_explicit_instantiation;
1894 };
1895 static struct saved_scope *current_saved_scope;
1896
1897 /* A chain of the binding vecs created by store_bindings.  We create a
1898    whole bunch of these during compilation, on permanent_obstack, so we
1899    can't just throw them away.  */
1900 static tree free_binding_vecs;
1901
1902 static tree
1903 store_bindings (names, old_bindings)
1904      tree names, old_bindings;
1905 {
1906   tree t;
1907   for (t = names; t; t = TREE_CHAIN (t))
1908     {
1909       tree binding, t1, id;
1910
1911       if (TREE_CODE (t) == TREE_LIST)
1912         id = TREE_PURPOSE (t);
1913       else
1914         id = DECL_NAME (t);
1915
1916       if (!id
1917           || (!IDENTIFIER_LOCAL_VALUE (id)
1918               && !IDENTIFIER_CLASS_VALUE (id)))
1919         continue;
1920
1921       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
1922         if (TREE_VEC_ELT (t1, 0) == id)
1923           goto skip_it;
1924
1925       if (free_binding_vecs)
1926         {
1927           binding = free_binding_vecs;
1928           free_binding_vecs = TREE_CHAIN (free_binding_vecs);
1929         }
1930       else
1931         binding = make_tree_vec (4);
1932
1933       if (id)
1934         {
1935           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
1936           TREE_VEC_ELT (binding, 0) = id;
1937           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
1938           TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
1939           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
1940           IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
1941           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
1942         }
1943       TREE_CHAIN (binding) = old_bindings;
1944       old_bindings = binding;
1945     skip_it:
1946       ;
1947     }
1948   return old_bindings;
1949 }
1950
1951 void
1952 maybe_push_to_top_level (pseudo)
1953      int pseudo;
1954 {
1955   extern int current_lang_stacksize;
1956   struct saved_scope *s
1957     = (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
1958   struct binding_level *b = inner_binding_level;
1959   tree old_bindings = NULL_TREE;
1960
1961   if (current_function_decl)
1962     push_cp_function_context (NULL_TREE);
1963
1964   if (previous_class_type)
1965     old_bindings = store_bindings (previous_class_values, old_bindings);
1966
1967   /* Have to include global_binding_level, because class-level decls
1968      aren't listed anywhere useful.  */
1969   for (; b; b = b->level_chain)
1970     {
1971       tree t;
1972
1973       /* Template IDs are inserted into the global level. If they were
1974          inserted into namespace level, finish_file wouldn't find them
1975          when doing pending instantiations. Therefore, don't stop at
1976          namespace level, but continue until :: .  */
1977       if (b == global_binding_level || (pseudo && b->pseudo_global))
1978         break;
1979
1980       old_bindings = store_bindings (b->names, old_bindings);
1981       /* We also need to check class_shadowed to save class-level type
1982          bindings, since pushclass doesn't fill in b->names.  */
1983       if (b->parm_flag == 2)
1984         old_bindings = store_bindings (b->class_shadowed, old_bindings);
1985
1986       /* Unwind type-value slots back to top level.  */
1987       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
1988         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
1989     }
1990
1991   s->old_binding_level = current_binding_level;
1992   current_binding_level = b;
1993
1994   s->old_namespace = current_namespace;
1995   s->class_name = current_class_name;
1996   s->class_type = current_class_type;
1997   s->function_decl = current_function_decl;
1998   s->class_bindings = class_binding_level;
1999   s->lang_stack = current_lang_stack;
2000   s->lang_base = current_lang_base;
2001   s->lang_stacksize = current_lang_stacksize;
2002   s->lang_name = current_lang_name;
2003   s->minimal_parse_mode = minimal_parse_mode;
2004   s->last_function_parms = last_function_parms;
2005   s->template_parms = current_template_parms;
2006   s->processing_template_decl = processing_template_decl;
2007   s->previous_class_type = previous_class_type;
2008   s->previous_class_values = previous_class_values;
2009   s->processing_specialization = processing_specialization;
2010   s->processing_explicit_instantiation = processing_explicit_instantiation;
2011
2012   current_class_name = current_class_type = NULL_TREE;
2013   current_function_decl = NULL_TREE;
2014   class_binding_level = (struct binding_level *)0;
2015   current_lang_stacksize = 10;
2016   current_lang_stack = current_lang_base
2017     = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
2018   current_lang_name = lang_name_cplusplus;
2019   strict_prototype = strict_prototypes_lang_cplusplus;
2020   named_labels = NULL_TREE;
2021   shadowed_labels = NULL_TREE;
2022   minimal_parse_mode = 0;
2023   previous_class_type = previous_class_values = NULL_TREE;
2024   processing_specialization = 0;
2025   processing_explicit_instantiation = 0;
2026   current_template_parms = NULL_TREE;
2027   processing_template_decl = 0;
2028   current_namespace = global_namespace;
2029
2030   s->prev = current_saved_scope;
2031   s->old_bindings = old_bindings;
2032   current_saved_scope = s;
2033
2034   push_obstacks (&permanent_obstack, &permanent_obstack);
2035 }
2036
2037 void
2038 push_to_top_level ()
2039 {
2040   maybe_push_to_top_level (0);
2041 }
2042
2043 void
2044 pop_from_top_level ()
2045 {
2046   extern int current_lang_stacksize;
2047   struct saved_scope *s = current_saved_scope;
2048   tree t;
2049
2050   /* Clear out class-level bindings cache.  */
2051   if (previous_class_type)
2052     {
2053       popclass (-1);
2054       previous_class_type = NULL_TREE;
2055     }
2056
2057   pop_obstacks ();
2058
2059   current_binding_level = s->old_binding_level;
2060   current_saved_scope = s->prev;
2061   for (t = s->old_bindings; t; )
2062     {
2063       tree save = t;
2064       tree id = TREE_VEC_ELT (t, 0);
2065       if (id)
2066         {
2067           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2068           IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
2069           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2070         }
2071       t = TREE_CHAIN (t);
2072       TREE_CHAIN (save) = free_binding_vecs;
2073       free_binding_vecs = save;
2074     }
2075   current_namespace = s->old_namespace;
2076   current_class_name = s->class_name;
2077   current_class_type = s->class_type;
2078   current_function_decl = s->function_decl;
2079   class_binding_level = s->class_bindings;
2080   free (current_lang_base);
2081   current_lang_base = s->lang_base;
2082   current_lang_stack = s->lang_stack;
2083   current_lang_name = s->lang_name;
2084   current_lang_stacksize = s->lang_stacksize;
2085   if (current_lang_name == lang_name_cplusplus)
2086     strict_prototype = strict_prototypes_lang_cplusplus;
2087   else if (current_lang_name == lang_name_c)
2088     strict_prototype = strict_prototypes_lang_c;
2089   minimal_parse_mode = s->minimal_parse_mode;
2090   last_function_parms = s->last_function_parms;
2091   current_template_parms = s->template_parms;
2092   processing_template_decl = s->processing_template_decl;
2093   previous_class_type = s->previous_class_type;
2094   previous_class_values = s->previous_class_values;
2095   processing_specialization = s->processing_specialization;
2096   processing_explicit_instantiation = s->processing_explicit_instantiation;
2097
2098   free (s);
2099
2100   if (current_function_decl)
2101     pop_cp_function_context (NULL_TREE);
2102 }
2103 \f
2104 /* Push a definition of struct, union or enum tag "name".
2105    into binding_level "b".   "type" should be the type node,
2106    We assume that the tag "name" is not already defined.
2107
2108    Note that the definition may really be just a forward reference.
2109    In that case, the TYPE_SIZE will be a NULL_TREE.
2110
2111    C++ gratuitously puts all these tags in the name space.  */
2112
2113 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2114    record the shadowed value for this binding contour.  TYPE is
2115    the type that ID maps to.  */
2116
2117 static void
2118 set_identifier_type_value_with_scope (id, type, b)
2119      tree id;
2120      tree type;
2121      struct binding_level *b;
2122 {
2123   if (!b->namespace_p)
2124     {
2125       /* Shadow the marker, not the real thing, so that the marker
2126          gets restored later. */
2127       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2128       b->type_shadowed
2129         = tree_cons (id, old_type_value, b->type_shadowed);
2130     }
2131   else
2132     {
2133       tree binding = binding_for_name (id, current_namespace);
2134       BINDING_TYPE (binding) = type;
2135       /* Store marker instead of real type. */
2136       type = global_type_node;
2137     }
2138   SET_IDENTIFIER_TYPE_VALUE (id, type);
2139 }
2140
2141 /* As set_identifier_type_value_with_scope, but using inner_binding_level.  */
2142
2143 void
2144 set_identifier_type_value (id, type)
2145      tree id;
2146      tree type;
2147 {
2148   set_identifier_type_value_with_scope (id, type, inner_binding_level);
2149 }
2150
2151 /* Return the type associated with id. */
2152
2153 tree
2154 identifier_type_value (id)
2155      tree id;
2156 {
2157   /* There is no type with that name, anywhere. */
2158   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2159     return NULL_TREE;
2160   /* This is not the type marker, but the real thing. */
2161   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2162     return REAL_IDENTIFIER_TYPE_VALUE (id);
2163   /* Have to search for it. It must be on the global level, now.
2164      Ask lookup_name not to return non-types. */
2165   id = lookup_name_real (id, 2, 1, 0);
2166   if (id)
2167     return TREE_TYPE (id);
2168   return NULL_TREE;
2169 }
2170
2171 /* Pop off extraneous binding levels left over due to syntax errors.
2172
2173    We don't pop past namespaces, as they might be valid.  */
2174
2175 void
2176 pop_everything ()
2177 {
2178 #ifdef DEBUG_CP_BINDING_LEVELS
2179   fprintf (stderr, "XXX entering pop_everything ()\n");
2180 #endif
2181   while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2182     {
2183       if (class_binding_level)
2184         pop_nested_class (1);
2185       else
2186         poplevel (0, 0, 0);
2187     }
2188 #ifdef DEBUG_CP_BINDING_LEVELS
2189   fprintf (stderr, "XXX leaving pop_everything ()\n");
2190 #endif
2191 }
2192
2193 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2194    Normally put it into the inner-most non-tag-transparent scope,
2195    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2196    The latter is needed for implicit declarations.  */
2197
2198 void
2199 pushtag (name, type, globalize)
2200      tree name, type;
2201      int globalize;
2202 {
2203   register struct binding_level *b;
2204   tree context = 0;
2205   tree c_decl = 0;
2206
2207   b = inner_binding_level;
2208   while (b->tag_transparent
2209          || (globalize && b->parm_flag == 2))
2210     b = b->level_chain;
2211
2212   if (toplevel_bindings_p ())
2213     b->tags = perm_tree_cons (name, type, b->tags);
2214   else
2215     b->tags = saveable_tree_cons (name, type, b->tags);
2216
2217   if (name)
2218     {
2219       context = type ? TYPE_CONTEXT (type) : NULL_TREE;
2220       if (! context)
2221         {
2222           tree cs = current_scope ();
2223
2224           if (! globalize)
2225             context = cs;
2226           else if (cs != NULL_TREE
2227                    && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2228             /* When declaring a friend class of a local class, we want
2229                to inject the newly named class into the scope
2230                containing the local class, not the namespace scope.  */
2231             context = hack_decl_function_context (get_type_decl (cs));
2232         }
2233       if (context)
2234         c_decl = TREE_CODE (context) == FUNCTION_DECL
2235           ? context : TYPE_MAIN_DECL (context);
2236
2237       if (!context)
2238         context = current_namespace;
2239
2240       /* Do C++ gratuitous typedefing.  */
2241       if (IDENTIFIER_TYPE_VALUE (name) != type)
2242         {
2243           register tree d = NULL_TREE;
2244           int newdecl = 0, in_class = 0;
2245
2246           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2247               || b->parm_flag == 2)
2248             in_class = 1;
2249           else
2250             d = lookup_nested_type (type, c_decl);
2251
2252           if (d == NULL_TREE)
2253             {
2254               newdecl = 1;
2255               d = build_decl (TYPE_DECL, name, type);
2256               if (current_lang_name == lang_name_java)
2257                 TYPE_FOR_JAVA (type) = 1;
2258               SET_DECL_ARTIFICIAL (d);
2259               if (! in_class)
2260                 set_identifier_type_value_with_scope (name, type, b);
2261             }
2262           else
2263             d = TYPE_MAIN_DECL (d);
2264
2265           TYPE_NAME (type) = d;
2266           DECL_CONTEXT (d) = context;
2267
2268           if (processing_template_parmlist)
2269             /* You can't declare a new template type in a template
2270                parameter list.  But, you can declare a non-template
2271                type:
2272
2273                  template <class A*> struct S;
2274
2275                is a forward-declaration of `A'.  */
2276             ;
2277           else if (IS_AGGR_TYPE (type)
2278               && (/* If !GLOBALIZE then we are looking at a
2279                      definition.  It may not be a primary template.
2280                      (For example, in:
2281
2282                        template <class T>
2283                        struct S1 { class S2 {}; }
2284
2285                      we have to push_template_decl for S2.)  */
2286                   (processing_template_decl && !globalize)
2287                   /* If we are declaring a friend template class, we
2288                      will have GLOBALIZE set, since something like:
2289
2290                        template <class T>
2291                        struct S1 {
2292                          template <class U>
2293                          friend class S2;
2294                        };
2295
2296                      declares S2 to be at global scope.  */
2297                   || (processing_template_decl >
2298                       template_class_depth (current_class_type))))
2299             {
2300               d = push_template_decl_real (d, globalize);
2301               /* If the current binding level is the binding level for
2302                  the template parameters (see the comment in
2303                  begin_template_parm_list) and the enclosing level is
2304                  a class scope, and we're not looking at a friend,
2305                  push the declaration of the member class into the
2306                  class scope.  In the friend case, push_template_decl
2307                  will already have put the friend into global scope,
2308                  if appropriate.  */
2309               if (!globalize && b->pseudo_global &&
2310                   b->level_chain->parm_flag == 2)
2311                 {
2312                   pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type),
2313                                        b->level_chain);
2314                   /* Put this tag on the list of tags for the class,
2315                      since that won't happen below because B is not
2316                      the class binding level, but is instead the
2317                      pseudo-global level.  */
2318                   b->level_chain->tags =
2319                     saveable_tree_cons (name, type, b->level_chain->tags);
2320                   TREE_NONLOCAL_FLAG (type) = 1;
2321                   if (TYPE_SIZE (current_class_type) == NULL_TREE)
2322                     CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2323                 }
2324             }
2325
2326           if (b->parm_flag == 2)
2327             d = pushdecl_class_level (d);
2328           else
2329             d = pushdecl_with_scope (d, b);
2330
2331           if (newdecl)
2332             {
2333               if (ANON_AGGRNAME_P (name))
2334                 DECL_IGNORED_P (d) = 1;
2335
2336               TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2337               DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2338               DECL_ASSEMBLER_NAME (d)
2339                 = get_identifier (build_overload_name (type, 1, 1));
2340             }
2341         }
2342       if (b->parm_flag == 2)
2343         {
2344           TREE_NONLOCAL_FLAG (type) = 1;
2345           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2346             CLASSTYPE_TAGS (current_class_type) = b->tags;
2347         }
2348     }
2349
2350   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2351     /* Use the canonical TYPE_DECL for this node.  */
2352     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2353   else
2354     {
2355       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2356          will be the tagged type we just added to the current
2357          binding level.  This fake NULL-named TYPE_DECL node helps
2358          dwarfout.c to know when it needs to output a
2359          representation of a tagged type, and it also gives us a
2360          convenient place to record the "scope start" address for
2361          the tagged type.  */
2362
2363       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2364       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2365     }
2366 }
2367
2368 /* Counter used to create anonymous type names.  */
2369
2370 static int anon_cnt = 0;
2371
2372 /* Return an IDENTIFIER which can be used as a name for
2373    anonymous structs and unions.  */
2374
2375 tree
2376 make_anon_name ()
2377 {
2378   char buf[32];
2379
2380   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2381   return get_identifier (buf);
2382 }
2383
2384 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2385    This keeps dbxout from getting confused.  */
2386
2387 void
2388 clear_anon_tags ()
2389 {
2390   register struct binding_level *b;
2391   register tree tags;
2392   static int last_cnt = 0;
2393
2394   /* Fast out if no new anon names were declared.  */
2395   if (last_cnt == anon_cnt)
2396     return;
2397
2398   b = current_binding_level;
2399   while (b->tag_transparent)
2400     b = b->level_chain;
2401   tags = b->tags;
2402   while (tags)
2403     {
2404       /* A NULL purpose means we have already processed all tags
2405          from here to the end of the list.  */
2406       if (TREE_PURPOSE (tags) == NULL_TREE)
2407         break;
2408       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2409         TREE_PURPOSE (tags) = NULL_TREE;
2410       tags = TREE_CHAIN (tags);
2411     }
2412   last_cnt = anon_cnt;
2413 }
2414 \f
2415 /* Subroutine of duplicate_decls: return truthvalue of whether
2416    or not types of these decls match.
2417
2418    For C++, we must compare the parameter list so that `int' can match
2419    `int&' in a parameter position, but `int&' is not confused with
2420    `const int&'.  */
2421
2422 int
2423 decls_match (newdecl, olddecl)
2424      tree newdecl, olddecl;
2425 {
2426   int types_match;
2427
2428   if (TREE_CODE (newdecl) == FUNCTION_DECL
2429       && TREE_CODE (olddecl) == FUNCTION_DECL)
2430     {
2431       tree f1 = TREE_TYPE (newdecl);
2432       tree f2 = TREE_TYPE (olddecl);
2433       tree p1 = TYPE_ARG_TYPES (f1);
2434       tree p2 = TYPE_ARG_TYPES (f2);
2435
2436       /* When we parse a static member function definition,
2437          we put together a FUNCTION_DECL which thinks its type
2438          is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
2439          proceed.  */
2440       if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2441         revert_static_member_fn (&newdecl, &f1, &p1);
2442       else if (TREE_CODE (f2) == METHOD_TYPE
2443                && DECL_STATIC_FUNCTION_P (newdecl))
2444         revert_static_member_fn (&olddecl, &f2, &p2);
2445
2446       /* Here we must take care of the case where new default
2447          parameters are specified.  Also, warn if an old
2448          declaration becomes ambiguous because default
2449          parameters may cause the two to be ambiguous.  */
2450       if (TREE_CODE (f1) != TREE_CODE (f2))
2451         {
2452           if (TREE_CODE (f1) == OFFSET_TYPE)
2453             cp_compiler_error ("`%D' redeclared as member function", newdecl);
2454           else
2455             cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2456           return 0;
2457         }
2458
2459       if (comptypes (TREE_TYPE (f1), TREE_TYPE (f2), 1))
2460         {
2461           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2462               && p2 == NULL_TREE)
2463             {
2464               types_match = self_promoting_args_p (p1);
2465               if (p1 == void_list_node)
2466                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2467             }
2468           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2469                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2470             {
2471               types_match = self_promoting_args_p (p2);
2472               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2473             }
2474           else
2475             types_match = compparms (p1, p2, 3);
2476         }
2477       else
2478         types_match = 0;
2479     }
2480   else if (TREE_CODE (newdecl) == TEMPLATE_DECL
2481            && TREE_CODE (olddecl) == TEMPLATE_DECL)
2482     {
2483       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2484                                 DECL_TEMPLATE_PARMS (olddecl)))
2485         return 0;
2486
2487       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2488         types_match = 1;
2489       else
2490         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2491                                    DECL_TEMPLATE_RESULT (newdecl));
2492     }
2493   else
2494     {
2495       if (TREE_TYPE (newdecl) == error_mark_node)
2496         types_match = TREE_TYPE (olddecl) == error_mark_node;
2497       else if (TREE_TYPE (olddecl) == NULL_TREE)
2498         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2499       else if (TREE_TYPE (newdecl) == NULL_TREE)
2500         types_match = 0;
2501       /* Qualifiers must match, and they may be present on either, the type
2502          or the decl.  */
2503       else if ((TREE_READONLY (newdecl)
2504                 || TYPE_READONLY (TREE_TYPE (newdecl)))
2505                == (TREE_READONLY (olddecl)
2506                    || TYPE_READONLY (TREE_TYPE (olddecl)))
2507                && (TREE_THIS_VOLATILE (newdecl)
2508                     || TYPE_VOLATILE (TREE_TYPE (newdecl)))
2509                    == (TREE_THIS_VOLATILE (olddecl)
2510                        || TYPE_VOLATILE (TREE_TYPE (olddecl))))
2511         types_match = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (newdecl)),
2512                                  TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)), 1);
2513       else
2514         types_match = 0;
2515     }
2516
2517   return types_match;
2518 }
2519
2520 /* If NEWDECL is `static' and an `extern' was seen previously,
2521    warn about it.  (OLDDECL may be NULL_TREE; NAME contains
2522    information about previous usage as an `extern'.)
2523
2524    Note that this does not apply to the C++ case of declaring
2525    a variable `extern const' and then later `const'.
2526
2527    Don't complain about built-in functions, since they are beyond
2528    the user's control.  */
2529
2530 static void
2531 warn_extern_redeclared_static (newdecl, olddecl)
2532      tree newdecl, olddecl;
2533 {
2534   tree name;
2535
2536   static char *explicit_extern_static_warning
2537     = "`%D' was declared `extern' and later `static'";
2538   static char *implicit_extern_static_warning
2539     = "`%D' was declared implicitly `extern' and later `static'";
2540
2541   if (TREE_CODE (newdecl) == TYPE_DECL)
2542     return;
2543
2544   name = DECL_ASSEMBLER_NAME (newdecl);
2545   if (TREE_PUBLIC (name) && DECL_THIS_STATIC (newdecl))
2546     {
2547       /* It's okay to redeclare an ANSI built-in function as static,
2548          or to declare a non-ANSI built-in function as anything.  */
2549       if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2550              && olddecl != NULL_TREE
2551              && TREE_CODE (olddecl) == FUNCTION_DECL
2552              && (DECL_BUILT_IN (olddecl)
2553                  || DECL_BUILT_IN_NONANSI (olddecl))))
2554         {
2555           cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2556                       ? implicit_extern_static_warning
2557                       : explicit_extern_static_warning, newdecl);
2558           if (olddecl != NULL_TREE)
2559             cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2560         }
2561     }
2562 }
2563
2564 /* Handle when a new declaration NEWDECL has the same name as an old
2565    one OLDDECL in the same binding contour.  Prints an error message
2566    if appropriate.
2567
2568    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2569    Otherwise, return 0.  */
2570
2571 int
2572 duplicate_decls (newdecl, olddecl)
2573      tree newdecl, olddecl;
2574 {
2575   extern struct obstack permanent_obstack;
2576   unsigned olddecl_uid = DECL_UID (olddecl);
2577   int olddecl_friend = 0, types_match = 0;
2578   int new_defines_function = 0;
2579
2580   if (newdecl == olddecl)
2581     return 1;
2582
2583   types_match = decls_match (newdecl, olddecl);
2584
2585   /* If either the type of the new decl or the type of the old decl is an
2586      error_mark_node, then that implies that we have already issued an
2587      error (earlier) for some bogus type specification, and in that case,
2588      it is rather pointless to harass the user with yet more error message
2589      about the same declaration, so just pretend the types match here.  */
2590   if (TREE_TYPE (newdecl) == error_mark_node
2591       || TREE_TYPE (olddecl) == error_mark_node)
2592     types_match = 1;
2593
2594   /* Check for redeclaration and other discrepancies. */
2595   if (TREE_CODE (olddecl) == FUNCTION_DECL
2596       && DECL_ARTIFICIAL (olddecl)
2597       && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
2598     {
2599       /* If you declare a built-in or predefined function name as static,
2600          the old definition is overridden, but optionally warn this was a
2601          bad choice of name.  Ditto for overloads.  */
2602       if (! TREE_PUBLIC (newdecl)
2603           || (TREE_CODE (newdecl) == FUNCTION_DECL
2604               && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2605         {
2606           if (warn_shadow)
2607             cp_warning ("shadowing %s function `%#D'",
2608                         DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2609                         olddecl);
2610           /* Discard the old built-in function.  */
2611           return 0;
2612         }
2613       else if (! types_match)
2614         {
2615           if (TREE_CODE (newdecl) != FUNCTION_DECL)
2616             {
2617               /* If the built-in is not ansi, then programs can override
2618                  it even globally without an error.  */
2619               if (! DECL_BUILT_IN (olddecl))
2620                 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2621                             olddecl, newdecl);
2622               else
2623                 {
2624                   cp_error ("declaration of `%#D'", newdecl);
2625                   cp_error ("conflicts with built-in declaration `%#D'",
2626                             olddecl);
2627                 }
2628               return 0;
2629             }
2630
2631           cp_warning ("declaration of `%#D'", newdecl);
2632           cp_warning ("conflicts with built-in declaration `%#D'",
2633                       olddecl);
2634         }
2635     }
2636   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
2637     {
2638       if ((TREE_CODE (newdecl) == FUNCTION_DECL
2639            && DECL_FUNCTION_TEMPLATE_P (olddecl))
2640           || (TREE_CODE (olddecl) == FUNCTION_DECL
2641               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
2642         return 0;
2643
2644       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
2645       if (TREE_CODE (olddecl) == TREE_LIST)
2646         olddecl = TREE_VALUE (olddecl);
2647       cp_error_at ("previous declaration of `%#D'", olddecl);
2648
2649       /* New decl is completely inconsistent with the old one =>
2650          tell caller to replace the old one.  */
2651
2652       return 0;
2653     }
2654   else if (!types_match)
2655     {
2656       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2657         {
2658           /* The name of a class template may not be declared to refer to
2659              any other template, class, function, object, namespace, value,
2660              or type in the same scope.  */
2661           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
2662               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2663             {
2664               cp_error ("declaration of template `%#D'", newdecl);
2665               cp_error_at ("conflicts with previous declaration `%#D'",
2666                            olddecl);
2667             }
2668           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
2669                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
2670                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
2671                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))), 3)
2672                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2673                                            DECL_TEMPLATE_PARMS (olddecl)))
2674             {
2675               cp_error ("new declaration `%#D'", newdecl);
2676               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2677             }
2678           return 0;
2679         }
2680       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2681         {
2682           if (DECL_LANGUAGE (newdecl) == lang_c
2683               && DECL_LANGUAGE (olddecl) == lang_c)
2684             {
2685               cp_error ("declaration of C function `%#D' conflicts with",
2686                         newdecl);
2687               cp_error_at ("previous declaration `%#D' here", olddecl);
2688             }
2689           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2690                               TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 3))
2691             {
2692               cp_error ("new declaration `%#D'", newdecl);
2693               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2694             }
2695           else
2696             return 0;
2697         }
2698
2699       /* Already complained about this, so don't do so again.  */
2700       else if (current_class_type == NULL_TREE
2701           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
2702         {
2703           cp_error ("conflicting types for `%#D'", newdecl);
2704           cp_error_at ("previous declaration as `%#D'", olddecl);
2705         }
2706     }
2707   else if (TREE_CODE (newdecl) == FUNCTION_DECL
2708             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
2709                  && (!DECL_TEMPLATE_INFO (newdecl)
2710                      || (DECL_TI_TEMPLATE (newdecl)
2711                          != DECL_TI_TEMPLATE (olddecl))))
2712                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
2713                     && (!DECL_TEMPLATE_INFO (olddecl)
2714                         || (DECL_TI_TEMPLATE (olddecl)
2715                             != DECL_TI_TEMPLATE (newdecl))))))
2716     /* It's OK to have a template specialization and a non-template
2717        with the same type, or to have specializations of two
2718        different templates with the same type.  Note that if one is a
2719        specialization, and the other is an instantiation of the same
2720        template, that we do not exit at this point.  That situation
2721        can occur if we instantiate a template class, and then
2722        specialize one of its methods.  This situation is legal, but
2723        the declarations must be merged in the usual way.  */
2724     return 0;
2725   else if (TREE_CODE (newdecl) == FUNCTION_DECL
2726            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
2727                 && !DECL_USE_TEMPLATE (newdecl))
2728                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
2729                    && !DECL_USE_TEMPLATE (olddecl))))
2730     /* One of the declarations is a template instantiation, and the
2731        other is not a template at all.  That's OK.  */
2732     return 0;
2733   else
2734     {
2735       char *errmsg = redeclaration_error_message (newdecl, olddecl);
2736       if (errmsg)
2737         {
2738           cp_error (errmsg, newdecl);
2739           if (DECL_NAME (olddecl) != NULL_TREE)
2740             cp_error_at ((DECL_INITIAL (olddecl)
2741                           && namespace_bindings_p ())
2742                          ? "`%#D' previously defined here"
2743                          : "`%#D' previously declared here", olddecl);
2744         }
2745       else if (TREE_CODE (olddecl) == FUNCTION_DECL
2746                && DECL_INITIAL (olddecl) != NULL_TREE
2747                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
2748                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
2749         {
2750           /* Prototype decl follows defn w/o prototype.  */
2751           cp_warning_at ("prototype for `%#D'", newdecl);
2752           cp_warning_at ("follows non-prototype definition here", olddecl);
2753         }
2754       else if (TREE_CODE (olddecl) == FUNCTION_DECL
2755                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
2756         {
2757           /* extern "C" int foo ();
2758              int foo () { bar (); }
2759              is OK.  */
2760           if (current_lang_stack == current_lang_base)
2761             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2762           else
2763             {
2764               cp_error_at ("previous declaration of `%#D' with %L linkage",
2765                            olddecl, DECL_LANGUAGE (olddecl));
2766               cp_error ("conflicts with new declaration with %L linkage",
2767                         DECL_LANGUAGE (newdecl));
2768             }
2769         }
2770
2771       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
2772         ;
2773       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
2774         {
2775           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
2776           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
2777           int i = 1;
2778
2779           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
2780             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
2781
2782           for (; t1 && t1 != void_list_node;
2783                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
2784             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
2785               {
2786                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
2787                                            TREE_PURPOSE (t2)))
2788                   {
2789                     if (pedantic)
2790                       {
2791                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
2792                                     i, newdecl);
2793                         cp_pedwarn_at ("after previous specification in `%#D'",
2794                                        olddecl);
2795                       }
2796                   }
2797                 else
2798                   {
2799                     cp_error ("default argument given for parameter %d of `%#D'",
2800                               i, newdecl);
2801                     cp_error_at ("after previous specification in `%#D'",
2802                                  olddecl);
2803                   }
2804               }
2805
2806           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
2807               && TREE_ADDRESSABLE (olddecl) && warn_inline)
2808             {
2809               cp_warning ("`%#D' was used before it was declared inline",
2810                           newdecl);
2811               cp_warning_at ("previous non-inline declaration here",
2812                              olddecl);
2813             }
2814         }
2815       /* These bits are logically part of the type for non-functions.  */
2816       else if (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
2817                || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))
2818         {
2819           cp_pedwarn ("type qualifiers for `%#D'", newdecl);
2820           cp_pedwarn_at ("conflict with previous decl `%#D'", olddecl);
2821         }
2822     }
2823
2824   /* If new decl is `static' and an `extern' was seen previously,
2825      warn about it.  */
2826   warn_extern_redeclared_static (newdecl, olddecl);
2827
2828   /* We have committed to returning 1 at this point.  */
2829   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2830     {
2831       /* Now that functions must hold information normally held
2832          by field decls, there is extra work to do so that
2833          declaration information does not get destroyed during
2834          definition.  */
2835       if (DECL_VINDEX (olddecl))
2836         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
2837       if (DECL_CONTEXT (olddecl))
2838         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2839       if (DECL_CLASS_CONTEXT (olddecl))
2840         DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
2841       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
2842         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2843       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
2844       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2845       DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
2846       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
2847       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
2848       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
2849
2850       /* Optionally warn about more than one declaration for the same
2851          name, but don't warn about a function declaration followed by a
2852          definition.  */
2853       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
2854           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
2855           /* Don't warn about extern decl followed by definition. */
2856           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
2857           /* Don't warn about friends, let add_friend take care of it. */
2858           && ! DECL_FRIEND_P (newdecl))
2859         {
2860           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
2861           cp_warning_at ("previous declaration of `%D'", olddecl);
2862         }
2863     }
2864
2865   /* Deal with C++: must preserve virtual function table size.  */
2866   if (TREE_CODE (olddecl) == TYPE_DECL)
2867     {
2868       register tree newtype = TREE_TYPE (newdecl);
2869       register tree oldtype = TREE_TYPE (olddecl);
2870
2871       if (newtype != error_mark_node && oldtype != error_mark_node
2872           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
2873         {
2874           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
2875           CLASSTYPE_FRIEND_CLASSES (newtype)
2876             = CLASSTYPE_FRIEND_CLASSES (oldtype);
2877         }
2878     }
2879
2880   /* Copy all the DECL_... slots specified in the new decl
2881      except for any that we copy here from the old type.  */
2882   DECL_MACHINE_ATTRIBUTES (newdecl)
2883     = merge_machine_decl_attributes (olddecl, newdecl);
2884
2885   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2886     {
2887       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE)
2888         {
2889           if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
2890                                  DECL_TEMPLATE_RESULT (olddecl)))
2891             cp_error ("invalid redeclaration of %D", newdecl);
2892           TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
2893           DECL_TEMPLATE_PARMS (olddecl) = DECL_TEMPLATE_PARMS (newdecl);
2894           DECL_TEMPLATE_INFO (olddecl) = DECL_TEMPLATE_INFO (newdecl);
2895         }
2896       DECL_TEMPLATE_SPECIALIZATIONS (newdecl)
2897         = DECL_TEMPLATE_SPECIALIZATIONS (olddecl);
2898
2899       return 1;
2900     }
2901
2902   if (types_match)
2903     {
2904       /* Automatically handles default parameters.  */
2905       tree oldtype = TREE_TYPE (olddecl);
2906       tree newtype;
2907
2908       /* Make sure we put the new type in the same obstack as the old one.  */
2909       if (oldtype)
2910         push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
2911       else
2912         {
2913           push_obstacks_nochange ();
2914           end_temporary_allocation ();
2915         }
2916
2917       /* Merge the data types specified in the two decls.  */
2918       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
2919
2920       if (TREE_CODE (newdecl) == VAR_DECL)
2921         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
2922       /* Do this after calling `common_type' so that default
2923          parameters don't confuse us.  */
2924       else if (TREE_CODE (newdecl) == FUNCTION_DECL
2925           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
2926               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
2927         {
2928           TREE_TYPE (newdecl) = build_exception_variant (newtype,
2929                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
2930           TREE_TYPE (olddecl) = build_exception_variant (newtype,
2931                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
2932
2933           if ((pedantic || (! DECL_IN_SYSTEM_HEADER (olddecl)
2934                             && DECL_SOURCE_LINE (olddecl) != 0))
2935               && flag_exceptions
2936               && ! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2937             {
2938               cp_pedwarn ("declaration of `%D' throws different exceptions",
2939                         newdecl);
2940               cp_pedwarn_at ("previous declaration here", olddecl);
2941             }
2942         }
2943       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2944
2945       /* Lay the type out, unless already done.  */
2946       if (newtype != CANONICAL_TYPE_VARIANT (oldtype)
2947           && TREE_TYPE (newdecl) != error_mark_node
2948           && !(processing_template_decl && uses_template_parms (newdecl)))
2949         layout_type (TREE_TYPE (newdecl));
2950
2951       if ((TREE_CODE (newdecl) == VAR_DECL
2952            || TREE_CODE (newdecl) == PARM_DECL
2953            || TREE_CODE (newdecl) == RESULT_DECL
2954            || TREE_CODE (newdecl) == FIELD_DECL
2955            || TREE_CODE (newdecl) == TYPE_DECL)
2956           && !(processing_template_decl && uses_template_parms (newdecl)))
2957         layout_decl (newdecl, 0);
2958
2959       /* Merge the type qualifiers.  */
2960       if (TREE_READONLY (newdecl))
2961         TREE_READONLY (olddecl) = 1;
2962       if (TREE_THIS_VOLATILE (newdecl))
2963         TREE_THIS_VOLATILE (olddecl) = 1;
2964
2965       /* Merge the initialization information.  */
2966       if (DECL_INITIAL (newdecl) == NULL_TREE
2967           && DECL_INITIAL (olddecl) != NULL_TREE)
2968         {
2969           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2970           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
2971           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
2972         }
2973
2974       /* Merge the section attribute.
2975          We want to issue an error if the sections conflict but that must be
2976          done later in decl_attributes since we are called before attributes
2977          are assigned.  */
2978       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2979         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2980
2981       /* Keep the old rtl since we can safely use it, unless it's the
2982          call to abort() used for abstract virtuals.  */
2983       if ((DECL_LANG_SPECIFIC (olddecl)
2984            && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
2985           || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
2986         DECL_RTL (newdecl) = DECL_RTL (olddecl);
2987
2988       pop_obstacks ();
2989     }
2990   /* If cannot merge, then use the new type and qualifiers,
2991      and don't preserve the old rtl.  */
2992   else
2993     {
2994       /* Clean out any memory we had of the old declaration.  */
2995       tree oldstatic = value_member (olddecl, static_aggregates);
2996       if (oldstatic)
2997         TREE_VALUE (oldstatic) = error_mark_node;
2998
2999       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3000       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3001       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3002       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3003     }
3004
3005   /* Merge the storage class information.  */
3006   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3007   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3008   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3009   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3010   if (! DECL_EXTERNAL (olddecl))
3011     DECL_EXTERNAL (newdecl) = 0;
3012
3013   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3014     {
3015       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3016       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3017       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3018       /* Don't really know how much of the language-specific
3019          values we should copy from old to new.  */
3020       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3021       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3022       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3023       if (DECL_TEMPLATE_INFO (newdecl) == NULL_TREE)
3024         {
3025           DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3026           DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
3027         }
3028       olddecl_friend = DECL_FRIEND_P (olddecl);
3029     }
3030
3031   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3032     {
3033       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3034           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3035         {
3036           /* If newdecl is not a specialization, then it is not a
3037              template-related function at all.  And that means that we
3038              shoud have exited above, returning 0.  */
3039           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3040                               0);
3041
3042           if (TREE_USED (olddecl))
3043             /* From [temp.expl.spec]:
3044
3045                If a template, a member template or the member of a class
3046                template is explicitly specialized then that
3047                specialization shall be declared before the first use of
3048                that specialization that would cause an implicit
3049                instantiation to take place, in every translation unit in
3050                which such a use occurs.  */
3051             cp_error ("explicit specialization of %D after first use",
3052                       olddecl);
3053
3054           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3055         }
3056       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3057
3058       /* If either decl says `inline', this fn is inline, unless its
3059          definition was passed already.  */
3060       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3061         DECL_INLINE (olddecl) = 1;
3062       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3063
3064       if (! types_match)
3065         {
3066           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3067           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3068           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3069         }
3070       if (! types_match || new_defines_function)
3071         {
3072           /* These need to be copied so that the names are available.  */
3073           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3074           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3075         }
3076       if (new_defines_function)
3077         /* If defining a function declared with other language
3078            linkage, use the previously declared language linkage.  */
3079         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3080       else
3081         {
3082           /* If redeclaring a builtin function, and not a definition,
3083              it stays built in.  */
3084           if (DECL_BUILT_IN (olddecl))
3085             {
3086               DECL_BUILT_IN (newdecl) = 1;
3087               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3088               /* If we're keeping the built-in definition, keep the rtl,
3089                  regardless of declaration matches.  */
3090               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3091             }
3092           else
3093             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3094
3095           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3096           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3097             /* Previously saved insns go together with
3098                the function's previous definition.  */
3099             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3100           /* Don't clear out the arguments if we're redefining a function.  */
3101           if (DECL_ARGUMENTS (olddecl))
3102             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3103         }
3104       if (DECL_LANG_SPECIFIC (olddecl))
3105         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3106     }
3107
3108   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3109     {
3110       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3111     }
3112
3113   /* Now preserve various other info from the definition.  */
3114   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3115   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3116   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3117   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3118
3119   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3120     {
3121       int function_size;
3122       struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
3123       struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
3124
3125       function_size = sizeof (struct tree_decl);
3126
3127       bcopy ((char *) newdecl + sizeof (struct tree_common),
3128              (char *) olddecl + sizeof (struct tree_common),
3129              function_size - sizeof (struct tree_common));
3130
3131       /* Can we safely free the storage used by newdecl?  */
3132
3133 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3134                   & ~ obstack_alignment_mask (&permanent_obstack))
3135
3136       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3137         {
3138           /* If newdecl is a template instantiation, it is possible that
3139              the following sequence of events has occurred:
3140
3141              o A friend function was declared in a class template.  The
3142              class template was instantiated.
3143
3144              o The instantiation of the friend declaration was
3145              recorded on the instantiation list, and is newdecl.
3146
3147              o Later, however, instantiate_class_template called pushdecl
3148              on the newdecl to perform name injection.  But, pushdecl in
3149              turn called duplicate_decls when it discovered that another
3150              declaration of a global function with the same name already
3151              existed.
3152
3153              o Here, in duplicate_decls, we decided to clobber newdecl.
3154
3155              If we're going to do that, we'd better make sure that
3156              olddecl, and not newdecl, is on the list of
3157              instantiations so that if we try to do the instantiation
3158              again we won't get the clobbered declaration.  */
3159
3160           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3161           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3162
3163           for (; decls; decls = TREE_CHAIN (decls))
3164             if (TREE_VALUE (decls) == newdecl)
3165               TREE_VALUE (decls) = olddecl;
3166         }
3167
3168       if (((char *)newdecl + ROUND (function_size) == (char *)nl
3169            && ((char *)newdecl + ROUND (function_size)
3170                + ROUND (sizeof (struct lang_decl))
3171                == obstack_next_free (&permanent_obstack)))
3172           || ((char *)newdecl + ROUND (function_size)
3173               == obstack_next_free (&permanent_obstack)))
3174         {
3175           DECL_MAIN_VARIANT (newdecl) = olddecl;
3176           DECL_LANG_SPECIFIC (olddecl) = ol;
3177           bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
3178
3179           obstack_free (&permanent_obstack, newdecl);
3180         }
3181       else if (LANG_DECL_PERMANENT (ol) && ol != nl)
3182         {
3183           if (DECL_MAIN_VARIANT (olddecl) == olddecl)
3184             {
3185               /* Save these lang_decls that would otherwise be lost.  */
3186               extern tree free_lang_decl_chain;
3187               tree free_lang_decl = (tree) ol;
3188
3189               if (DECL_LANG_SPECIFIC (olddecl) == ol)
3190                 abort ();
3191
3192               TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
3193               free_lang_decl_chain = free_lang_decl;
3194             }
3195           else
3196             {
3197               /* Storage leak.  */;
3198             }
3199         }
3200     }
3201   else
3202     {
3203       bcopy ((char *) newdecl + sizeof (struct tree_common),
3204              (char *) olddecl + sizeof (struct tree_common),
3205              sizeof (struct tree_decl) - sizeof (struct tree_common)
3206              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3207     }
3208
3209   DECL_UID (olddecl) = olddecl_uid;
3210   if (olddecl_friend)
3211     DECL_FRIEND_P (olddecl) = 1;
3212
3213   /* NEWDECL contains the merged attribute lists.
3214      Update OLDDECL to be the same.  */
3215   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3216
3217   return 1;
3218 }
3219
3220 /* Record a decl-node X as belonging to the current lexical scope.
3221    Check for errors (such as an incompatible declaration for the same
3222    name already seen in the same scope).
3223
3224    Returns either X or an old decl for the same name.
3225    If an old decl is returned, it may have been smashed
3226    to agree with what X says.  */
3227
3228 tree
3229 pushdecl (x)
3230      tree x;
3231 {
3232   register tree t;
3233   register tree name = DECL_ASSEMBLER_NAME (x);
3234   register struct binding_level *b = current_binding_level;
3235
3236   if (current_function_decl && x != current_function_decl
3237       /* A local declaration for a function doesn't constitute nesting.  */
3238       && (TREE_CODE (x) != FUNCTION_DECL || DECL_INITIAL (x))
3239       /* Don't change DECL_CONTEXT of virtual methods.  */
3240       && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3241       && ! DECL_CONTEXT (x))
3242     DECL_CONTEXT (x) = current_function_decl;
3243   if (!DECL_CONTEXT (x))
3244     DECL_CONTEXT (x) = current_namespace;
3245
3246   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3247      compiler wants to use.  */
3248   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3249       || TREE_CODE (x) == NAMESPACE_DECL || TREE_CODE (x) == TEMPLATE_TYPE_PARM
3250       || TREE_CODE (x) == TEMPLATE_TEMPLATE_PARM)
3251     name = DECL_NAME (x);
3252
3253   if (name)
3254     {
3255 #if 0
3256       /* Not needed...see below.  */
3257       char *file;
3258       int line;
3259 #endif
3260       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3261         name = TREE_OPERAND (name, 0);
3262
3263       /* Namespace-scoped variables are not found in the current level. */
3264       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3265         t = namespace_binding (name, DECL_CONTEXT (x));
3266       else
3267         t = lookup_name_current_level (name);
3268       if (t == error_mark_node)
3269         {
3270           /* error_mark_node is 0 for a while during initialization!  */
3271           t = NULL_TREE;
3272           cp_error_at ("`%#D' used prior to declaration", x);
3273         }
3274
3275       else if (t != NULL_TREE)
3276         {
3277 #if 0
3278           /* This is turned off until I have time to do it right (bpk).  */
3279           /* With the code below that uses it...  */
3280           file = DECL_SOURCE_FILE (t);
3281           line = DECL_SOURCE_LINE (t);
3282 #endif
3283           if (TREE_CODE (t) == PARM_DECL)
3284             {
3285               if (DECL_CONTEXT (t) == NULL_TREE)
3286                 fatal ("parse errors have confused me too much");
3287
3288               /* Check for duplicate params.  */
3289               if (duplicate_decls (x, t))
3290                 return t;
3291             }
3292           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3293                     || DECL_FUNCTION_TEMPLATE_P (x))
3294                    && is_overloaded_fn (t))
3295             /* Don't do anything just yet. */;
3296           else if (t == wchar_decl_node)
3297             {
3298               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3299                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3300
3301               /* Throw away the redeclaration.  */
3302               return t;
3303             }
3304           else if (TREE_CODE (t) != TREE_CODE (x))
3305             {
3306               if ((TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
3307                    && TREE_CODE (x) != TYPE_DECL
3308                    && ! (TREE_CODE (x) == TEMPLATE_DECL
3309                          && TREE_CODE (DECL_TEMPLATE_RESULT (x)) == TYPE_DECL))
3310                   || (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3311                       && TREE_CODE (t) != TYPE_DECL
3312                       && ! (TREE_CODE (t) == TEMPLATE_DECL
3313                             && (TREE_CODE (DECL_TEMPLATE_RESULT (t))
3314                                 == TYPE_DECL))))
3315                 {
3316                   /* We do nothing special here, because C++ does such nasty
3317                      things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3318                      get shadowed, and know that if we need to find a TYPE_DECL
3319                      for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3320                      slot of the identifier.  */
3321                   ;
3322                 }
3323               else if (duplicate_decls (x, t))
3324                 return t;
3325             }
3326           else if (duplicate_decls (x, t))
3327             {
3328 #if 0
3329               /* This is turned off until I have time to do it right (bpk).  */
3330
3331               /* Also warn if they did a prototype with `static' on it, but
3332                  then later left the `static' off.  */
3333               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3334                 {
3335                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3336                     return t;
3337
3338                   if (extra_warnings)
3339                     {
3340                       cp_warning ("`static' missing from declaration of `%D'",
3341                                   t);
3342                       warning_with_file_and_line (file, line,
3343                                                   "previous declaration of `%s'",
3344                                                   decl_as_string (t, 0));
3345                     }
3346
3347                   /* Now fix things so it'll do what they expect.  */
3348                   if (current_function_decl)
3349                     TREE_PUBLIC (current_function_decl) = 0;
3350                 }
3351               /* Due to interference in memory reclamation (X may be
3352                  obstack-deallocated at this point), we must guard against
3353                  one really special case.  [jason: This should be handled
3354                  by start_function]  */
3355               if (current_function_decl == x)
3356                 current_function_decl = t;
3357 #endif
3358               if (TREE_CODE (t) == TYPE_DECL)
3359                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3360               else if (TREE_CODE (t) == FUNCTION_DECL)
3361                 check_default_args (t);
3362
3363               return t;
3364             }
3365           else if (DECL_MAIN_P (x))
3366             {
3367               /* A redeclaration of main, but not a duplicate of the
3368                  previous one.
3369
3370                  [basic.start.main]
3371
3372                  This function shall not be overloaded.  */
3373               cp_error_at ("invalid redeclaration of `%D'", t);
3374               cp_error ("as `%D'", x);
3375               /* We don't try to push this declaration since that
3376                  causes a crash.  */
3377               return x;
3378             }
3379         }
3380
3381       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3382         {
3383           t = push_overloaded_decl (x, 1);
3384           if (t != x || DECL_LANGUAGE (x) == lang_c)
3385             return t;
3386         }
3387       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3388         return push_overloaded_decl (x, 0);
3389
3390       /* If declaring a type as a typedef, copy the type (unless we're
3391          at line 0), and install this TYPE_DECL as the new type's typedef
3392          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3393       if (TREE_CODE (x) == TYPE_DECL)
3394         {
3395           tree type = TREE_TYPE (x);
3396           if (DECL_SOURCE_LINE (x) == 0)
3397             {
3398               if (TYPE_NAME (type) == 0)
3399                 TYPE_NAME (type) = x;
3400             }
3401           else if (type != error_mark_node && TYPE_NAME (type) != x)
3402             {
3403               push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
3404
3405               DECL_ORIGINAL_TYPE (x) = type;
3406               type = build_type_copy (type);
3407               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3408               TYPE_NAME (type) = x;
3409               TREE_TYPE (x) = type;
3410
3411               pop_obstacks ();
3412             }
3413
3414           if (type != error_mark_node
3415               && TYPE_NAME (type)
3416               && TYPE_IDENTIFIER (type))
3417             set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
3418         }
3419
3420       /* Multiple external decls of the same identifier ought to match.
3421
3422          We get warnings about inline functions where they are defined.
3423          We get warnings about other functions from push_overloaded_decl.
3424
3425          Avoid duplicate warnings where they are used.  */
3426       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3427         {
3428           tree decl;
3429           tree bindings = binding_for_name (name, current_namespace);
3430
3431           if (BINDING_VALUE (bindings) != NULL_TREE
3432               && (DECL_EXTERNAL (BINDING_VALUE (bindings))
3433                   || TREE_PUBLIC (BINDING_VALUE (bindings))))
3434             decl = BINDING_VALUE (bindings);
3435           else
3436             decl = NULL_TREE;
3437
3438           if (decl
3439               /* If different sort of thing, we already gave an error.  */
3440               && TREE_CODE (decl) == TREE_CODE (x)
3441               && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1))
3442             {
3443               cp_pedwarn ("type mismatch with previous external decl", x);
3444               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3445             }
3446         }
3447
3448       /* This name is new in its binding level.
3449          Install the new declaration and return it.  */
3450       if (namespace_bindings_p ())
3451         {
3452           /* Install a global value.  */
3453           tree bindings = binding_for_name (name, current_namespace);
3454
3455           /* If the first global decl has external linkage,
3456              warn if we later see static one.  */
3457           if (BINDING_VALUE (bindings) == NULL_TREE && TREE_PUBLIC (x))
3458             TREE_PUBLIC (name) = 1;
3459
3460           /* Don't install an artificial TYPE_DECL if we already have
3461              another _DECL with that name.  */
3462           if (TREE_CODE (x) != TYPE_DECL
3463               || t == NULL_TREE
3464               || ! DECL_ARTIFICIAL (x))
3465             {
3466               if (TREE_CODE (x) == FUNCTION_DECL)
3467                 my_friendly_assert ((BINDING_VALUE (bindings) == NULL_TREE)
3468                                     || BINDING_VALUE (bindings) == x, 378);
3469               BINDING_VALUE (bindings) = x;
3470             }
3471
3472           /* Don't forget if the function was used via an implicit decl.  */
3473           if (IDENTIFIER_IMPLICIT_DECL (name)
3474               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3475             TREE_USED (x) = 1;
3476
3477           /* Don't forget if its address was taken in that way.  */
3478           if (IDENTIFIER_IMPLICIT_DECL (name)
3479               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3480             TREE_ADDRESSABLE (x) = 1;
3481
3482           /* Warn about mismatches against previous implicit decl.  */
3483           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3484               /* If this real decl matches the implicit, don't complain.  */
3485               && ! (TREE_CODE (x) == FUNCTION_DECL
3486                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3487             cp_warning
3488               ("`%D' was previously implicitly declared to return `int'", x);
3489
3490           /* If new decl is `static' and an `extern' was seen previously,
3491              warn about it.  */
3492           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3493             warn_extern_redeclared_static (x, t);
3494         }
3495       else
3496         {
3497           /* Here to install a non-global value.  */
3498           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
3499           tree oldglobal = binding_for_name (name, current_namespace);
3500
3501           /* Don't install an artificial TYPE_DECL if we already have
3502              another _DECL with that name.  */
3503           if (TREE_CODE (x) != TYPE_DECL
3504               || t == NULL_TREE
3505               || ! DECL_ARTIFICIAL (x))
3506             {
3507               b->shadowed = tree_cons (name, oldlocal, b->shadowed);
3508               IDENTIFIER_LOCAL_VALUE (name) = x;
3509             }
3510
3511           /* If this is a TYPE_DECL, push it into the type value slot.  */
3512           if (TREE_CODE (x) == TYPE_DECL)
3513             set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
3514
3515           /* Clear out any TYPE_DECL shadowed by a namespace so that
3516              we won't think this is a type.  The C struct hack doesn't
3517              go through namespaces.  */
3518           if (TREE_CODE (x) == NAMESPACE_DECL)
3519             set_identifier_type_value_with_scope (name, NULL_TREE, b);
3520
3521           /* If this is an extern function declaration, see if we
3522              have a global definition or declaration for the function.  */
3523           if (oldlocal == NULL_TREE
3524               && DECL_EXTERNAL (x)
3525               && BINDING_VALUE (oldglobal) != NULL_TREE
3526               && TREE_CODE (x) == FUNCTION_DECL
3527               && TREE_CODE (BINDING_VALUE (oldglobal)) == FUNCTION_DECL)
3528             {
3529               /* We have one.  Their types must agree.  */
3530               if (decls_match (x, BINDING_VALUE (oldglobal)))
3531                 /* OK */;
3532               else
3533                 {
3534                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3535                   cp_warning_at ("global declaration `%#D'", BINDING_VALUE (oldglobal));
3536                 }
3537             }
3538           /* If we have a local external declaration,
3539              and no file-scope declaration has yet been seen,
3540              then if we later have a file-scope decl it must not be static.  */
3541           if (oldlocal == NULL_TREE
3542               && BINDING_VALUE (oldglobal) == NULL_TREE
3543               && DECL_EXTERNAL (x)
3544               && TREE_PUBLIC (x))
3545             {
3546               TREE_PUBLIC (name) = 1;
3547             }
3548
3549           if (DECL_FROM_INLINE (x))
3550             /* Inline decls shadow nothing.  */;
3551
3552           /* Warn if shadowing an argument at the top level of the body.  */
3553           else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3554               && TREE_CODE (oldlocal) == PARM_DECL
3555               && TREE_CODE (x) != PARM_DECL)
3556             {
3557               /* Go to where the parms should be and see if we
3558                  find them there.  */
3559               struct binding_level *b = current_binding_level->level_chain;
3560
3561               if (cleanup_label)
3562                 b = b->level_chain;
3563
3564               /* ARM $8.3 */
3565               if (b->parm_flag == 1)
3566                 cp_error ("declaration of `%#D' shadows a parameter", name);
3567             }
3568           else if (warn_shadow && oldlocal != NULL_TREE && b->is_for_scope
3569                    && !DECL_DEAD_FOR_LOCAL (oldlocal))
3570             {
3571               warning ("variable `%s' shadows local",
3572                        IDENTIFIER_POINTER (name));
3573               cp_warning_at ("  this is the shadowed declaration", oldlocal);
3574             }
3575           /* Maybe warn if shadowing something else.  */
3576           else if (warn_shadow && !DECL_EXTERNAL (x)
3577                    /* No shadow warnings for internally generated vars.  */
3578                    && ! DECL_ARTIFICIAL (x)
3579                    /* No shadow warnings for vars made for inlining.  */
3580                    && ! DECL_FROM_INLINE (x))
3581             {
3582               char *warnstring = NULL;
3583
3584               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3585                 warnstring = "declaration of `%s' shadows a parameter";
3586               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3587                        && current_class_ptr
3588                        && !TREE_STATIC (name))
3589                 warnstring = "declaration of `%s' shadows a member of `this'";
3590               else if (oldlocal != NULL_TREE)
3591                 warnstring = "declaration of `%s' shadows previous local";
3592               else if (BINDING_VALUE (oldglobal) != NULL_TREE)
3593                 /* XXX shadow warnings in outer-more namespaces */
3594                 warnstring = "declaration of `%s' shadows global declaration";
3595
3596               if (warnstring)
3597                 warning (warnstring, IDENTIFIER_POINTER (name));
3598             }
3599         }
3600
3601       if (TREE_CODE (x) == FUNCTION_DECL)
3602         check_default_args (x);
3603
3604       /* Keep count of variables in this level with incomplete type.  */
3605       if (TREE_CODE (x) == VAR_DECL
3606           && TREE_TYPE (x) != error_mark_node
3607           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3608                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
3609               /* RTTI TD entries are created while defining the type_info.  */
3610               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
3611                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
3612         b->incomplete = tree_cons (NULL_TREE, x, b->incomplete);
3613     }
3614
3615   /* Put decls on list in reverse order.
3616      We will reverse them later if necessary.  */
3617   TREE_CHAIN (x) = b->names;
3618   b->names = x;
3619   if (! (b != global_binding_level || TREE_PERMANENT (x)))
3620     my_friendly_abort (124);
3621
3622   return x;
3623 }
3624
3625 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
3626    caller to set DECL_CONTEXT properly.  */
3627
3628 static tree
3629 pushdecl_with_scope (x, level)
3630      tree x;
3631      struct binding_level *level;
3632 {
3633   register struct binding_level *b;
3634   tree function_decl = current_function_decl;
3635
3636   current_function_decl = NULL_TREE;
3637   if (level->parm_flag == 2)
3638     {
3639       b = class_binding_level;
3640       class_binding_level = level;
3641       pushdecl_class_level (x);
3642       class_binding_level = b;
3643     }
3644   else
3645     {
3646       b = current_binding_level;
3647       current_binding_level = level;
3648       x = pushdecl (x);
3649       current_binding_level = b;
3650     }
3651   current_function_decl = function_decl;
3652   return x;
3653 }
3654
3655 /* Like pushdecl, only it places X in the current namespace,
3656    if appropriate.  */
3657
3658 tree
3659 pushdecl_namespace_level (x)
3660      tree x;
3661 {
3662   register struct binding_level *b = inner_binding_level;
3663   register tree t;
3664
3665   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3666
3667   /* Now, the type_shadowed stack may screw us.  Munge it so it does
3668      what we want.  */
3669   if (TREE_CODE (x) == TYPE_DECL)
3670     {
3671       tree name = DECL_NAME (x);
3672       tree newval;
3673       tree *ptr = (tree *)0;
3674       for (; b != global_binding_level; b = b->level_chain)
3675         {
3676           tree shadowed = b->type_shadowed;
3677           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3678             if (TREE_PURPOSE (shadowed) == name)
3679               {
3680                 ptr = &TREE_VALUE (shadowed);
3681                 /* Can't break out of the loop here because sometimes
3682                    a binding level will have duplicate bindings for
3683                    PT names.  It's gross, but I haven't time to fix it.  */
3684               }
3685         }
3686       newval = TREE_TYPE (x);
3687       if (ptr == (tree *)0)
3688         {
3689           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
3690              up here if this is changed to an assertion.  --KR  */
3691           SET_IDENTIFIER_TYPE_VALUE (name, newval);
3692         }
3693       else
3694         {
3695           *ptr = newval;
3696         }
3697     }
3698   return t;
3699 }
3700
3701 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3702    if appropriate.  */
3703
3704 tree
3705 pushdecl_top_level (x)
3706      tree x;
3707 {
3708   tree cur_namespace = current_namespace;
3709   current_namespace = global_namespace;
3710   x = pushdecl_namespace_level (x);
3711   current_namespace = cur_namespace;
3712   return x;
3713 }
3714
3715 /* Make the declaration of X appear in CLASS scope.  */
3716
3717 tree
3718 pushdecl_class_level (x)
3719      tree x;
3720 {
3721   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
3722      scope looks for the pre-mangled name.  */
3723   register tree name = DECL_NAME (x);
3724
3725   if (name)
3726     {
3727       if (TYPE_BEING_DEFINED (current_class_type))
3728         {
3729           /* Check for inconsistent use of this name in the class body.
3730              Types, enums, and static vars are checked here; other
3731              members are checked in finish_struct.  */
3732           tree icv = IDENTIFIER_CLASS_VALUE (name);
3733
3734           if (icv && icv != x
3735               /* Don't complain about inherited names.  */
3736               && id_in_current_class (name)
3737               /* Or shadowed tags.  */
3738               && !(DECL_DECLARES_TYPE_P (icv)
3739                    && DECL_CONTEXT (icv) == current_class_type))
3740             {
3741               cp_error ("declaration of identifier `%D' as `%#D'", name, x);
3742               cp_error_at ("conflicts with previous use in class as `%#D'",
3743                            icv);
3744             }
3745         }
3746
3747       push_class_level_binding (name, x);
3748       if (TREE_CODE (x) == TYPE_DECL)
3749         {
3750           set_identifier_type_value (name, TREE_TYPE (x));
3751         }
3752     }
3753   return x;
3754 }
3755
3756 #if 0
3757 /* This function is used to push the mangled decls for nested types into
3758    the appropriate scope.  Previously pushdecl_top_level was used, but that
3759    is incorrect for members of local classes.  */
3760
3761 void
3762 pushdecl_nonclass_level (x)
3763      tree x;
3764 {
3765   struct binding_level *b = current_binding_level;
3766
3767   my_friendly_assert (b->parm_flag != 2, 180);
3768
3769 #if 0
3770   /* Get out of template binding levels */
3771   while (b->pseudo_global)
3772     b = b->level_chain;
3773 #endif
3774
3775   pushdecl_with_scope (x, b);
3776 }
3777 #endif
3778
3779 /* Make the declaration(s) of X appear in CLASS scope
3780    under the name NAME.  */
3781
3782 void
3783 push_class_level_binding (name, x)
3784      tree name;
3785      tree x;
3786 {
3787   /* The class_binding_level will be NULL if x is a template
3788      parameter name in a member template.  */
3789   if (!class_binding_level)
3790     return;
3791
3792   if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3793       && purpose_member (name, class_binding_level->class_shadowed))
3794     return;
3795
3796   maybe_push_cache_obstack ();
3797   class_binding_level->class_shadowed
3798       = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
3799                    class_binding_level->class_shadowed);
3800   pop_obstacks ();
3801   IDENTIFIER_CLASS_VALUE (name) = x;
3802   obstack_ptr_grow (&decl_obstack, x);
3803 }
3804
3805 /* Insert another USING_DECL into the current binding level,
3806    returning this declaration. If this is a redeclaration,
3807    do nothing and return NULL_TREE.  */
3808
3809 tree
3810 push_using_decl (scope, name)
3811      tree scope;
3812      tree name;
3813 {
3814   tree decl;
3815
3816   if (!toplevel_bindings_p ())
3817     {
3818       sorry ("using declaration inside function");
3819       return NULL_TREE;
3820     }
3821
3822   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
3823   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
3824   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
3825     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
3826       break;
3827   if (decl)
3828     return NULL_TREE;
3829   decl = build_lang_decl (USING_DECL, name, void_type_node);
3830   DECL_INITIAL (decl) = scope;
3831   TREE_CHAIN (decl) = current_binding_level->usings;
3832   current_binding_level->usings = decl;
3833   return decl;
3834 }
3835
3836 /* DECL is a FUNCTION_DECL which may have other definitions already in
3837    place.  We get around this by making the value of the identifier point
3838    to a list of all the things that want to be referenced by that name.  It
3839    is then up to the users of that name to decide what to do with that
3840    list.
3841
3842    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3843    slot.  It is dealt with the same way.
3844
3845    The value returned may be a previous declaration if we guessed wrong
3846    about what language DECL should belong to (C or C++).  Otherwise,
3847    it's always DECL (and never something that's not a _DECL).  */
3848
3849 static tree
3850 push_overloaded_decl (decl, forgettable)
3851      tree decl;
3852      int forgettable;
3853 {
3854   tree orig_name = DECL_NAME (decl);
3855   tree old;
3856   int doing_global = (namespace_bindings_p () || ! forgettable);
3857
3858   if (doing_global)
3859     {
3860       old = namespace_binding (orig_name, DECL_CONTEXT (decl));
3861       if (old && TREE_CODE (old) == FUNCTION_DECL
3862           && DECL_ARTIFICIAL (old)
3863           && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
3864         {
3865           if (duplicate_decls (decl, old))
3866             return old;
3867           old = NULL_TREE;
3868         }
3869     }
3870   else
3871     {
3872       old = IDENTIFIER_LOCAL_VALUE (orig_name);
3873
3874       if (! purpose_member (orig_name, current_binding_level->shadowed))
3875         {
3876           current_binding_level->shadowed
3877             = tree_cons (orig_name, old, current_binding_level->shadowed);
3878           old = NULL_TREE;
3879         }
3880     }
3881
3882   if (old)
3883     {
3884       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
3885         {
3886           tree t = TREE_TYPE (old);
3887           if (IS_AGGR_TYPE (t) && warn_shadow
3888               && (! DECL_IN_SYSTEM_HEADER (decl)
3889                   || ! DECL_IN_SYSTEM_HEADER (old)))
3890             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
3891           old = NULL_TREE;
3892         }
3893       else if (is_overloaded_fn (old))
3894         {
3895           tree tmp;
3896
3897           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
3898             if (decl == OVL_CURRENT (tmp)
3899                 || duplicate_decls (decl, OVL_CURRENT (tmp)))
3900               return OVL_CURRENT (tmp);
3901         }
3902       else
3903         {
3904           cp_error_at ("previous non-function declaration `%#D'", old);
3905           cp_error ("conflicts with function declaration `%#D'", decl);
3906           return decl;
3907         }
3908     }
3909
3910   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
3911     {
3912       if (old && TREE_CODE (old) != OVERLOAD)
3913         old = ovl_cons (old, NULL_TREE);
3914       old = ovl_cons (decl, old);
3915     }
3916   else
3917     /* orig_name is not ambiguous.  */
3918     old = decl;
3919
3920   if (doing_global)
3921     set_namespace_binding (orig_name, DECL_CONTEXT (decl), old);
3922   else
3923     IDENTIFIER_LOCAL_VALUE (orig_name) = old;
3924
3925   return decl;
3926 }
3927 \f
3928 /* Generate an implicit declaration for identifier FUNCTIONID
3929    as a function of type int ().  Print a warning if appropriate.  */
3930
3931 tree
3932 implicitly_declare (functionid)
3933      tree functionid;
3934 {
3935   register tree decl;
3936   int temp = allocation_temporary_p ();
3937
3938   push_obstacks_nochange ();
3939
3940   /* Save the decl permanently so we can warn if definition follows.
3941      In ANSI C, warn_implicit is usually false, so the saves little space.
3942      But in C++, it's usually true, hence the extra code.  */
3943   if (temp && (! warn_implicit || toplevel_bindings_p ()))
3944     end_temporary_allocation ();
3945
3946   /* We used to reuse an old implicit decl here,
3947      but this loses with inline functions because it can clobber
3948      the saved decl chains.  */
3949   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
3950
3951   DECL_EXTERNAL (decl) = 1;
3952   TREE_PUBLIC (decl) = 1;
3953
3954   /* ANSI standard says implicit declarations are in the innermost block.
3955      So we record the decl in the standard fashion.  */
3956   pushdecl (decl);
3957   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
3958
3959   if (warn_implicit
3960       /* Only one warning per identifier.  */
3961       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
3962     {
3963       cp_pedwarn ("implicit declaration of function `%#D'", decl);
3964     }
3965
3966   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
3967
3968   pop_obstacks ();
3969
3970   return decl;
3971 }
3972
3973 /* Return zero if the declaration NEWDECL is valid
3974    when the declaration OLDDECL (assumed to be for the same name)
3975    has already been seen.
3976    Otherwise return an error message format string with a %s
3977    where the identifier should go.  */
3978
3979 static char *
3980 redeclaration_error_message (newdecl, olddecl)
3981      tree newdecl, olddecl;
3982 {
3983   if (TREE_CODE (newdecl) == TYPE_DECL)
3984     {
3985       /* Because C++ can put things into name space for free,
3986          constructs like "typedef struct foo { ... } foo"
3987          would look like an erroneous redeclaration.  */
3988       if (comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
3989         return 0;
3990       else
3991         return "redefinition of `%#D'";
3992     }
3993   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
3994     {
3995       /* If this is a pure function, its olddecl will actually be
3996          the original initialization to `0' (which we force to call
3997          abort()).  Don't complain about redefinition in this case.  */
3998       if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
3999         return 0;
4000
4001       /* If both functions come from different namespaces, this is not
4002          a redeclaration - this is a conflict with a used function. */
4003       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4004           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4005         return "`%D' conflicts with used function";
4006
4007       /* We'll complain about linkage mismatches in
4008          warn_extern_redeclared_static.  */
4009
4010       /* Defining the same name twice is no good.  */
4011       if (DECL_INITIAL (olddecl) != NULL_TREE
4012           && DECL_INITIAL (newdecl) != NULL_TREE)
4013         {
4014           if (DECL_NAME (olddecl) == NULL_TREE)
4015             return "`%#D' not declared in class";
4016           else
4017             return "redefinition of `%#D'";
4018         }
4019       return 0;
4020     }
4021   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4022     {
4023       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4024            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4025            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4026           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4027               && TYPE_SIZE (TREE_TYPE (newdecl))
4028               && TYPE_SIZE (TREE_TYPE (olddecl))))
4029         return "redefinition of `%#D'";
4030       return 0;
4031     }
4032   else if (toplevel_bindings_p ())
4033     {
4034       /* Objects declared at top level:  */
4035       /* If at least one is a reference, it's ok.  */
4036       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4037         return 0;
4038       /* Reject two definitions.  */
4039       return "redefinition of `%#D'";
4040     }
4041   else
4042     {
4043       /* Objects declared with block scope:  */
4044       /* Reject two definitions, and reject a definition
4045          together with an external reference.  */
4046       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4047         return "redeclaration of `%#D'";
4048       return 0;
4049     }
4050 }
4051 \f
4052 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4053    Create one if none exists so far for the current function.
4054    This function is called for both label definitions and label references.  */
4055
4056 tree
4057 lookup_label (id)
4058      tree id;
4059 {
4060   register tree decl = IDENTIFIER_LABEL_VALUE (id);
4061
4062   if (current_function_decl == NULL_TREE)
4063     {
4064       error ("label `%s' referenced outside of any function",
4065              IDENTIFIER_POINTER (id));
4066       return NULL_TREE;
4067     }
4068
4069   if ((decl == NULL_TREE
4070       || DECL_SOURCE_LINE (decl) == 0)
4071       && (named_label_uses == NULL
4072           || named_label_uses->names_in_scope != current_binding_level->names
4073           || named_label_uses->label_decl != decl))
4074     {
4075       struct named_label_list *new_ent;
4076       new_ent
4077         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4078       new_ent->label_decl = decl;
4079       new_ent->names_in_scope = current_binding_level->names;
4080       new_ent->binding_level = current_binding_level;
4081       new_ent->lineno_o_goto = lineno;
4082       new_ent->filename_o_goto = input_filename;
4083       new_ent->next = named_label_uses;
4084       named_label_uses = new_ent;
4085     }
4086
4087   /* Use a label already defined or ref'd with this name.  */
4088   if (decl != NULL_TREE)
4089     {
4090       /* But not if it is inherited and wasn't declared to be inheritable.  */
4091       if (DECL_CONTEXT (decl) != current_function_decl
4092           && ! C_DECLARED_LABEL_FLAG (decl))
4093         return shadow_label (id);
4094       return decl;
4095     }
4096
4097   decl = build_decl (LABEL_DECL, id, void_type_node);
4098
4099   /* Make sure every label has an rtx.  */
4100   label_rtx (decl);
4101
4102   /* A label not explicitly declared must be local to where it's ref'd.  */
4103   DECL_CONTEXT (decl) = current_function_decl;
4104
4105   DECL_MODE (decl) = VOIDmode;
4106
4107   /* Say where one reference is to the label,
4108      for the sake of the error if it is not defined.  */
4109   DECL_SOURCE_LINE (decl) = lineno;
4110   DECL_SOURCE_FILE (decl) = input_filename;
4111
4112   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4113
4114   named_labels = tree_cons (NULL_TREE, decl, named_labels);
4115   named_label_uses->label_decl = decl;
4116
4117   return decl;
4118 }
4119
4120 /* Make a label named NAME in the current function,
4121    shadowing silently any that may be inherited from containing functions
4122    or containing scopes.
4123
4124    Note that valid use, if the label being shadowed
4125    comes from another scope in the same function,
4126    requires calling declare_nonlocal_label right away.  */
4127
4128 tree
4129 shadow_label (name)
4130      tree name;
4131 {
4132   register tree decl = IDENTIFIER_LABEL_VALUE (name);
4133
4134   if (decl != NULL_TREE)
4135     {
4136       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4137       SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4138     }
4139
4140   return lookup_label (name);
4141 }
4142
4143 /* Define a label, specifying the location in the source file.
4144    Return the LABEL_DECL node for the label, if the definition is valid.
4145    Otherwise return 0.  */
4146
4147 tree
4148 define_label (filename, line, name)
4149      char *filename;
4150      int line;
4151      tree name;
4152 {
4153   tree decl;
4154
4155   if (minimal_parse_mode)
4156     {
4157       push_obstacks (&permanent_obstack, &permanent_obstack);
4158       decl = build_decl (LABEL_DECL, name, void_type_node);
4159       pop_obstacks ();
4160       DECL_SOURCE_LINE (decl) = line;
4161       DECL_SOURCE_FILE (decl) = filename;
4162       add_tree (decl);
4163       return decl;
4164     }
4165
4166   decl = lookup_label (name);
4167
4168   /* After labels, make any new cleanups go into their
4169      own new (temporary) binding contour.  */
4170   current_binding_level->more_cleanups_ok = 0;
4171
4172   /* If label with this name is known from an outer context, shadow it.  */
4173   if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
4174     {
4175       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4176       SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4177       decl = lookup_label (name);
4178     }
4179
4180   if (name == get_identifier ("wchar_t"))
4181     cp_pedwarn ("label named wchar_t");
4182
4183   if (DECL_INITIAL (decl) != NULL_TREE)
4184     {
4185       cp_error ("duplicate label `%D'", decl);
4186       return 0;
4187     }
4188   else
4189     {
4190       struct named_label_list *uses, *prev;
4191       int identified = 0;
4192
4193       /* Mark label as having been defined.  */
4194       DECL_INITIAL (decl) = error_mark_node;
4195       /* Say where in the source.  */
4196       DECL_SOURCE_FILE (decl) = filename;
4197       DECL_SOURCE_LINE (decl) = line;
4198
4199       prev = NULL;
4200       uses = named_label_uses;
4201       while (uses != NULL)
4202         if (uses->label_decl == decl)
4203           {
4204             struct binding_level *b = current_binding_level;
4205             while (b)
4206               {
4207                 tree new_decls = b->names;
4208                 tree old_decls = (b == uses->binding_level)
4209                                   ? uses->names_in_scope : NULL_TREE;
4210                 while (new_decls != old_decls)
4211                   {
4212                     if (TREE_CODE (new_decls) == VAR_DECL
4213                         /* Don't complain about crossing initialization
4214                            of internal entities.  They can't be accessed,
4215                            and they should be cleaned up
4216                            by the time we get to the label.  */
4217                         && ! DECL_ARTIFICIAL (new_decls)
4218                         && ((DECL_INITIAL (new_decls) != NULL_TREE
4219                              && DECL_INITIAL (new_decls) != error_mark_node)
4220                             || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4221                       {
4222                         if (! identified)
4223                           {
4224                             cp_error ("jump to label `%D'", decl);
4225                             error_with_file_and_line (uses->filename_o_goto,
4226                                                       uses->lineno_o_goto,
4227                                                       "  from here");
4228                             identified = 1;
4229                         }
4230                         cp_error_at ("  crosses initialization of `%#D'",
4231                                      new_decls);
4232                       }
4233                     new_decls = TREE_CHAIN (new_decls);
4234                   }
4235                 if (b == uses->binding_level)
4236                   break;
4237                 b = b->level_chain;
4238               }
4239
4240             if (prev != NULL)
4241               prev->next = uses->next;
4242             else
4243               named_label_uses = uses->next;
4244
4245             uses = uses->next;
4246           }
4247         else
4248           {
4249             prev = uses;
4250             uses = uses->next;
4251           }
4252       current_function_return_value = NULL_TREE;
4253       return decl;
4254     }
4255 }
4256
4257 struct cp_switch
4258 {
4259   struct binding_level *level;
4260   struct cp_switch *next;
4261 };
4262
4263 static struct cp_switch *switch_stack;
4264
4265 void
4266 push_switch ()
4267 {
4268   struct cp_switch *p
4269     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4270   p->level = current_binding_level;
4271   p->next = switch_stack;
4272   switch_stack = p;
4273 }
4274
4275 void
4276 pop_switch ()
4277 {
4278   switch_stack = switch_stack->next;
4279 }
4280
4281 /* Same, but for CASE labels.  If DECL is NULL_TREE, it's the default.  */
4282 /* XXX Note decl is never actually used. (bpk) */
4283
4284 void
4285 define_case_label (decl)
4286      tree decl;
4287 {
4288   tree cleanup = last_cleanup_this_contour ();
4289   struct binding_level *b = current_binding_level;
4290   int identified = 0;
4291
4292   if (cleanup)
4293     {
4294       static int explained = 0;
4295       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4296       warning ("where case label appears here");
4297       if (!explained)
4298         {
4299           warning ("(enclose actions of previous case statements requiring");
4300           warning ("destructors in their own binding contours.)");
4301           explained = 1;
4302         }
4303     }
4304
4305   for (; b && b != switch_stack->level; b = b->level_chain)
4306     {
4307       tree new_decls = b->names;
4308       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4309         {
4310           if (TREE_CODE (new_decls) == VAR_DECL
4311               /* Don't complain about crossing initialization
4312                  of internal entities.  They can't be accessed,
4313                  and they should be cleaned up
4314                  by the time we get to the label.  */
4315               && ! DECL_ARTIFICIAL (new_decls)
4316               && ((DECL_INITIAL (new_decls) != NULL_TREE
4317                    && DECL_INITIAL (new_decls) != error_mark_node)
4318                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4319             {
4320               if (! identified)
4321                 error ("jump to case label");
4322               identified = 1;
4323               cp_error_at ("  crosses initialization of `%#D'",
4324                            new_decls);
4325             }
4326         }
4327     }
4328
4329   /* After labels, make any new cleanups go into their
4330      own new (temporary) binding contour.  */
4331
4332   current_binding_level->more_cleanups_ok = 0;
4333   current_function_return_value = NULL_TREE;
4334 }
4335 \f
4336 /* Return the list of declarations of the current level.
4337    Note that this list is in reverse order unless/until
4338    you nreverse it; and when you do nreverse it, you must
4339    store the result back using `storedecls' or you will lose.  */
4340
4341 tree
4342 getdecls ()
4343 {
4344   return current_binding_level->names;
4345 }
4346
4347 /* Return the list of type-tags (for structs, etc) of the current level.  */
4348
4349 tree
4350 gettags ()
4351 {
4352   return current_binding_level->tags;
4353 }
4354
4355 /* Store the list of declarations of the current level.
4356    This is done for the parameter declarations of a function being defined,
4357    after they are modified in the light of any missing parameters.  */
4358
4359 static void
4360 storedecls (decls)
4361      tree decls;
4362 {
4363   current_binding_level->names = decls;
4364 }
4365
4366 /* Similarly, store the list of tags of the current level.  */
4367
4368 static void
4369 storetags (tags)
4370      tree tags;
4371 {
4372   current_binding_level->tags = tags;
4373 }
4374 \f
4375 /* Given NAME, an IDENTIFIER_NODE,
4376    return the structure (or union or enum) definition for that name.
4377    Searches binding levels from BINDING_LEVEL up to the global level.
4378    If THISLEVEL_ONLY is nonzero, searches only the specified context
4379    (but skips any tag-transparent contexts to find one that is
4380    meaningful for tags).
4381    FORM says which kind of type the caller wants;
4382    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4383    If the wrong kind of type is found, and it's not a template, an error is
4384    reported.  */
4385
4386 static tree
4387 lookup_tag (form, name, binding_level, thislevel_only)
4388      enum tree_code form;
4389      tree name;
4390      struct binding_level *binding_level;
4391      int thislevel_only;
4392 {
4393   register struct binding_level *level;
4394
4395   for (level = binding_level; level; level = level->level_chain)
4396     {
4397       register tree tail;
4398       if (ANON_AGGRNAME_P (name))
4399         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4400           {
4401             /* There's no need for error checking here, because
4402                anon names are unique throughout the compilation.  */
4403             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4404               return TREE_VALUE (tail);
4405           }
4406       else if (level->namespace_p)
4407         /* Do namespace lookup. */
4408         /* XXX: is this a real lookup, considering using-directives etc. ??? */
4409         for (tail = current_namespace; 1; tail = DECL_CONTEXT (tail))
4410           {
4411             tree old = BINDING_TYPE (binding_for_name (name, tail));
4412             /* If it has an original type, it is a typedef, and we
4413                should not return it.  */
4414             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4415               old = NULL_TREE;
4416             if (old && TREE_CODE (old) != form
4417                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
4418               {
4419                 cp_error ("`%#D' redeclared as %C", old, form);
4420                 return NULL_TREE;
4421               }
4422             if (old)
4423               return old;
4424             if (thislevel_only || tail == global_namespace)
4425               return NULL_TREE;
4426           }
4427       else
4428         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4429           {
4430             if (TREE_PURPOSE (tail) == name)
4431               {
4432                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
4433                 /* Should tighten this up; it'll probably permit
4434                    UNION_TYPE and a struct template, for example.  */
4435                 if (code != form
4436                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
4437                   {
4438                     /* Definition isn't the kind we were looking for.  */
4439                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
4440                               form);
4441                     return NULL_TREE;
4442                   }
4443                 return TREE_VALUE (tail);
4444               }
4445           }
4446       if (thislevel_only && ! level->tag_transparent)
4447         {
4448           if (level->pseudo_global)
4449             {
4450               tree t = IDENTIFIER_CLASS_VALUE (name);
4451               if (t && DECL_CLASS_TEMPLATE_P (t))
4452                 return TREE_TYPE (t);
4453               t = IDENTIFIER_NAMESPACE_VALUE (name);
4454               if (t && DECL_CLASS_TEMPLATE_P (t))
4455                 return TREE_TYPE (t);
4456             }
4457           return NULL_TREE;
4458         }
4459       if (current_class_type && level->level_chain->namespace_p)
4460         {
4461           /* Try looking in this class's tags before heading into
4462              global binding level.  */
4463           tree context = current_class_type;
4464           while (context)
4465             {
4466               switch (TREE_CODE_CLASS (TREE_CODE (context)))
4467                 {
4468                 tree these_tags;
4469                 case 't':
4470                     these_tags = CLASSTYPE_TAGS (context);
4471                     if (ANON_AGGRNAME_P (name))
4472                       while (these_tags)
4473                         {
4474                           if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
4475                               == name)
4476                             return TREE_VALUE (tail);
4477                           these_tags = TREE_CHAIN (these_tags);
4478                         }
4479                     else
4480                       while (these_tags)
4481                         {
4482                           if (TREE_PURPOSE (these_tags) == name)
4483                             {
4484                               if (TREE_CODE (TREE_VALUE (these_tags)) != form)
4485                                 {
4486                                   cp_error ("`%#D' redeclared as %C in class scope",
4487                                             TREE_VALUE (tail), form);
4488                                   return NULL_TREE;
4489                                 }
4490                               return TREE_VALUE (tail);
4491                             }
4492                           these_tags = TREE_CHAIN (these_tags);
4493                         }
4494                     /* If this type is not yet complete, then don't
4495                        look at its context.  */
4496                     if (TYPE_SIZE (context) == NULL_TREE)
4497                       goto no_context;
4498                     /* Go to next enclosing type, if any.  */
4499                     context = DECL_CONTEXT (TYPE_MAIN_DECL (context));
4500                     break;
4501                 case 'd':
4502                     context = DECL_CONTEXT (context);
4503                     break;
4504                 default:
4505                     my_friendly_abort (10);
4506                 }
4507               continue;
4508               no_context:
4509               break;
4510             }
4511         }
4512     }
4513   return NULL_TREE;
4514 }
4515
4516 #if 0
4517 void
4518 set_current_level_tags_transparency (tags_transparent)
4519      int tags_transparent;
4520 {
4521   current_binding_level->tag_transparent = tags_transparent;
4522 }
4523 #endif
4524
4525 /* Given a type, find the tag that was defined for it and return the tag name.
4526    Otherwise return 0.  However, the value can never be 0
4527    in the cases in which this is used.
4528
4529    C++: If NAME is non-zero, this is the new name to install.  This is
4530    done when replacing anonymous tags with real tag names.  */
4531
4532 static tree
4533 lookup_tag_reverse (type, name)
4534      tree type;
4535      tree name;
4536 {
4537   register struct binding_level *level;
4538
4539   for (level = current_binding_level; level; level = level->level_chain)
4540     {
4541       register tree tail;
4542       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4543         {
4544           if (TREE_VALUE (tail) == type)
4545             {
4546               if (name)
4547                 TREE_PURPOSE (tail) = name;
4548               return TREE_PURPOSE (tail);
4549             }
4550         }
4551     }
4552   return NULL_TREE;
4553 }
4554 \f
4555 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4556    Return the type value, or NULL_TREE if not found.  */
4557
4558 static tree
4559 lookup_nested_type (type, context)
4560      tree type;
4561      tree context;
4562 {
4563   if (context == NULL_TREE)
4564     return NULL_TREE;
4565   while (context)
4566     {
4567       switch (TREE_CODE (context))
4568         {
4569         case TYPE_DECL:
4570           {
4571             tree ctype = TREE_TYPE (context);
4572             tree match = value_member (type, CLASSTYPE_TAGS (ctype));
4573             if (match)
4574               return TREE_VALUE (match);
4575             context = DECL_CONTEXT (context);
4576
4577             /* When we have a nested class whose member functions have
4578                local types (e.g., a set of enums), we'll arrive here
4579                with the DECL_CONTEXT as the actual RECORD_TYPE node for
4580                the enclosing class.  Instead, we want to make sure we
4581                come back in here with the TYPE_DECL, not the RECORD_TYPE.  */
4582             if (context && TREE_CODE (context) == RECORD_TYPE)
4583               context = TREE_CHAIN (context);
4584           }
4585           break;
4586         case FUNCTION_DECL:
4587           if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
4588             return lookup_name (TYPE_IDENTIFIER (type), 1);
4589           return NULL_TREE;
4590         default:
4591           my_friendly_abort (12);
4592         }
4593     }
4594   return NULL_TREE;
4595 }
4596
4597 /* Look up NAME in the NAMESPACE.  */
4598
4599 tree
4600 lookup_namespace_name (namespace, name)
4601      tree namespace, name;
4602 {
4603   struct tree_binding _b;
4604   tree val;
4605
4606   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
4607   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
4608
4609   val = binding_init (&_b);
4610   if (!qualified_lookup_using_namespace (name, namespace, val))
4611     return error_mark_node;
4612
4613   if (BINDING_VALUE (val))
4614     return BINDING_VALUE (val);
4615   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
4616   return error_mark_node;
4617 }
4618
4619 tree
4620 make_typename_type (context, name)
4621      tree context, name;
4622 {
4623   tree t, d;
4624   tree fullname;
4625
4626   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
4627     name = TYPE_IDENTIFIER (name);
4628   else if (TREE_CODE (name) == TYPE_DECL)
4629     name = DECL_NAME (name);
4630
4631   fullname = name;
4632
4633   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4634     {
4635       name = TREE_OPERAND (name, 0);
4636       if (TREE_CODE (name) == TEMPLATE_DECL)
4637         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
4638     }
4639   if (TREE_CODE (name) != IDENTIFIER_NODE)
4640     my_friendly_abort (2000);
4641
4642   if (! uses_template_parms (context)
4643       || currently_open_class (context))
4644     {
4645       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
4646         {
4647           if (IS_AGGR_TYPE (context))
4648             t = lookup_field (context, name, 0, 0);
4649           else
4650             t = NULL_TREE;
4651
4652           if (t == NULL_TREE || TREE_CODE (t) != TEMPLATE_DECL
4653               || TREE_CODE (DECL_RESULT (t)) != TYPE_DECL)
4654             {
4655               cp_error ("no class template named `%#T' in `%#T'",
4656                         name, context);
4657               return error_mark_node;
4658             }
4659
4660           return lookup_template_class (t, TREE_OPERAND (fullname, 1),
4661                                         NULL_TREE, context);
4662         }
4663       else
4664         {
4665           if (IS_AGGR_TYPE (context))
4666             t = lookup_field (context, name, 0, 1);
4667           else
4668             t = NULL_TREE;
4669
4670           if (t == NULL_TREE)
4671             {
4672               cp_error ("no type named `%#T' in `%#T'", name, context);
4673               return error_mark_node;
4674             }
4675
4676           return TREE_TYPE (t);
4677         }
4678     }
4679
4680   if (processing_template_decl)
4681     push_obstacks (&permanent_obstack, &permanent_obstack);
4682   t = make_lang_type (TYPENAME_TYPE);
4683   TYPENAME_TYPE_FULLNAME (t) = fullname;
4684   d = build_decl (TYPE_DECL, name, t);
4685   if (processing_template_decl)
4686     pop_obstacks ();
4687
4688   TYPE_CONTEXT (t) = context;
4689   TYPE_NAME (TREE_TYPE (d)) = d;
4690   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
4691   DECL_CONTEXT (d) = context;
4692   CLASSTYPE_GOT_SEMICOLON (t) = 1;
4693
4694   return t;
4695 }
4696
4697 /* Select the right _DECL from multiple choices. */
4698
4699 static tree
4700 select_decl (binding, prefer_type, namespaces_only)
4701      tree binding;
4702      int prefer_type, namespaces_only;
4703 {
4704   tree val;
4705   val = BINDING_VALUE (binding);
4706   if (namespaces_only)
4707     {
4708       /* We are not interested in types. */
4709       if (val && TREE_CODE (val) == NAMESPACE_DECL)
4710         return val;
4711       return NULL_TREE;
4712     }
4713
4714   /* If we could have a type and
4715      we have nothing or we need a type and have none.  */
4716   if (BINDING_TYPE (binding)
4717       && (!val || (prefer_type && TREE_CODE (val) != TYPE_DECL)))
4718     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
4719   /* Don't return non-types if we really prefer types. */
4720   else if (val && prefer_type > 1  && TREE_CODE (val) != TYPE_DECL
4721            && (!looking_for_template || TREE_CODE (val) != TEMPLATE_DECL))
4722     val = NULL_TREE;
4723   return val;
4724 }
4725
4726 /* Look up NAME in the current binding level and its superiors in the
4727    namespace of variables, functions and typedefs.  Return a ..._DECL
4728    node of some kind representing its definition if there is only one
4729    such declaration, or return a TREE_LIST with all the overloaded
4730    definitions if there are many, or return 0 if it is undefined.
4731
4732    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4733    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4734    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
4735    Otherwise we prefer non-TYPE_DECLs.
4736
4737    If NONCLASS is non-zero, we don't look for the NAME in class scope,
4738    using IDENTIFIER_CLASS_VALUE.  */
4739
4740 static tree
4741 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
4742      tree name;
4743      int prefer_type, nonclass, namespaces_only;
4744 {
4745   register tree val;
4746   int yylex = 0;
4747   tree from_obj = NULL_TREE;
4748   tree locval, classval;
4749
4750   /* Hack: copy flag set by parser, if set. */
4751   if (only_namespace_names)
4752     namespaces_only = 1;
4753
4754   if (prefer_type == -2)
4755     {
4756       extern int looking_for_typename;
4757       tree type = NULL_TREE;
4758
4759       yylex = 1;
4760       prefer_type = looking_for_typename;
4761
4762       /* std:: becomes :: for now.  */
4763       if (got_scope == std_node)
4764         got_scope = void_type_node;
4765
4766       if (got_scope)
4767         type = got_scope;
4768       else if (got_object != error_mark_node)
4769         type = got_object;
4770
4771       if (type)
4772         {
4773           if (type == error_mark_node)
4774             return error_mark_node;
4775           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4776             type = TREE_TYPE (type);
4777
4778           type = complete_type (type);
4779
4780           if (TREE_CODE (type) == VOID_TYPE)
4781             type = global_namespace;
4782           if (TREE_CODE (type) == NAMESPACE_DECL)
4783             {
4784               struct tree_binding b;
4785               val = binding_init (&b);
4786               if (!qualified_lookup_using_namespace (name, type, val))
4787                 return NULL_TREE;
4788               val = select_decl (val, prefer_type, namespaces_only);
4789             }
4790           else if (! IS_AGGR_TYPE (type)
4791                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
4792                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
4793                    || TREE_CODE (type) == TYPENAME_TYPE)
4794             /* Someone else will give an error about this if needed.  */
4795             val = NULL_TREE;
4796           else if (TYPE_BEING_DEFINED (type))
4797             {
4798               val = IDENTIFIER_CLASS_VALUE (name);
4799               if (val && DECL_CONTEXT (val) != type)
4800                 {
4801                   struct binding_level *b = class_binding_level;
4802                   for (val = NULL_TREE; b; b = b->level_chain)
4803                     {
4804                       tree t = purpose_member (name, b->class_shadowed);
4805                       if (t && TREE_VALUE (t)
4806                           && DECL_CONTEXT (TREE_VALUE (t)) == type)
4807                         {
4808                           val = TREE_VALUE (t);
4809                           break;
4810                         }
4811                     }
4812                 }
4813               if (val == NULL_TREE)
4814                 val = lookup_field (type, name, 0, 1);
4815             }
4816           else if (type == current_class_type)
4817             val = IDENTIFIER_CLASS_VALUE (name);
4818           else
4819             val = lookup_member (type, name, 0, prefer_type);
4820         }
4821       else
4822         val = NULL_TREE;
4823
4824       if (got_scope)
4825         goto done;
4826       else if (got_object && val)
4827         from_obj = val;
4828     }
4829
4830   locval = classval = NULL_TREE;
4831
4832   if (!namespaces_only && !current_binding_level->namespace_p
4833       && IDENTIFIER_LOCAL_VALUE (name)
4834       /* Kludge to avoid infinite recursion with identifier_type_value.  */
4835       && (prefer_type <= 0
4836           || TREE_CODE (IDENTIFIER_LOCAL_VALUE (name)) == TYPE_DECL))
4837     locval = IDENTIFIER_LOCAL_VALUE (name);
4838
4839   /* In C++ class fields are between local and global scope,
4840      just before the global scope.  */
4841   if (current_class_type && ! nonclass)
4842     {
4843       classval = IDENTIFIER_CLASS_VALUE (name);
4844       if (classval == NULL_TREE && TYPE_BEING_DEFINED (current_class_type))
4845         /* Try to find values from base classes if we are presently
4846            defining a type.  We are presently only interested in
4847            TYPE_DECLs.  */
4848         classval = lookup_field (current_class_type, name, 0, 1);
4849
4850       /* Add implicit 'typename' to types from template bases.  lookup_field
4851          will do this for us.  If classval is actually from an enclosing
4852          scope, lookup_nested_field will get it for us.  */
4853       if (processing_template_decl
4854           && classval && TREE_CODE (classval) == TYPE_DECL
4855           && ! currently_open_class (DECL_CONTEXT (classval))
4856           && uses_template_parms (current_class_type)
4857           && ! DECL_ARTIFICIAL (classval))
4858         classval = lookup_field (current_class_type, name, 0, 1);
4859
4860       /* yylex() calls this with -2, since we should never start digging for
4861          the nested name at the point where we haven't even, for example,
4862          created the COMPONENT_REF or anything like that.  */
4863       if (classval == NULL_TREE)
4864         classval = lookup_nested_field (name, ! yylex);
4865     }
4866
4867   if (locval && classval)
4868     {
4869       if (current_scope () == current_function_decl
4870           && ! hack_decl_function_context (current_function_decl))
4871         /* Not in a nested function.  */
4872         val = locval;
4873       else
4874         {
4875           /* This is incredibly horrible.  The whole concept of
4876              IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
4877              IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
4878              classes.  */
4879           tree lctx = hack_decl_function_context (locval);
4880           tree cctx = hack_decl_function_context (classval);
4881
4882           if (lctx == current_scope ())
4883             val = locval;
4884           else if (lctx == cctx)
4885             val = classval;
4886           else
4887             /* I don't know which is right; let's just guess for now.  */
4888             val = locval;
4889         }
4890     }
4891   else if (locval)
4892     val = locval;
4893   else if (classval)
4894     val = classval;
4895   else
4896     {
4897       /* Unscoped lookup of a global, iterate over namespaces,
4898          considering using namespace statements. */
4899       struct tree_binding _binding;
4900       tree b = binding_init (&_binding);
4901       tree initial = current_decl_namespace();
4902       tree scope = initial;
4903       val = NULL_TREE;
4904       while (!val)
4905         {
4906           val = binding_for_name (name, scope);
4907           /* Initialize binding for this context. */
4908           BINDING_VALUE (b) = BINDING_VALUE (val);
4909           BINDING_TYPE (b) = BINDING_TYPE (val);
4910           /* Add all _DECLs seen through using-directives. */
4911           if (!lookup_using_namespace (name, b, initial, scope))
4912             {
4913               /* Give up because of error. */
4914               val = NULL_TREE;
4915               break;
4916             }
4917           val = select_decl (b, prefer_type, namespaces_only);
4918           if (scope == global_namespace)
4919             break;
4920           scope = DECL_CONTEXT (scope);
4921         }
4922     }
4923
4924  done:
4925   if (val)
4926     {
4927       /* This should only warn about types used in qualified-ids.  */
4928       if (from_obj && from_obj != val)
4929         {
4930           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
4931               && TREE_CODE (val) == TYPE_DECL
4932               && TREE_TYPE (from_obj) != TREE_TYPE (val))
4933             {
4934               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
4935                           name, got_object, TREE_TYPE (from_obj));
4936               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
4937                           TREE_TYPE (val));
4938             }
4939
4940           val = from_obj;
4941         }
4942
4943       if ((TREE_CODE (val) == TEMPLATE_DECL && looking_for_template)
4944           || TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
4945         ;
4946       /* Caller wants a class-or-namespace-name. */
4947       else if (prefer_type == 1 && TREE_CODE (val) == NAMESPACE_DECL)
4948         ;
4949       else if (IDENTIFIER_HAS_TYPE_VALUE (name))
4950         val = TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name));
4951       else if (TREE_TYPE (val) == error_mark_node)
4952         val = error_mark_node;
4953     }
4954   else if (from_obj)
4955     val = from_obj;
4956
4957   return val;
4958 }
4959
4960 tree
4961 lookup_name_nonclass (name)
4962      tree name;
4963 {
4964   return lookup_name_real (name, 0, 1, 0);
4965 }
4966
4967 tree
4968 lookup_function_nonclass (name, args)
4969      tree name;
4970      tree args;
4971 {
4972   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
4973 }
4974
4975 tree
4976 lookup_name_namespace_only (name)
4977      tree name;
4978 {
4979   /* type-or-namespace, nonclass, namespace_only */
4980   return lookup_name_real (name, 1, 1, 1);
4981 }
4982
4983 tree
4984 lookup_name (name, prefer_type)
4985      tree name;
4986      int prefer_type;
4987 {
4988   return lookup_name_real (name, prefer_type, 0, 0);
4989 }
4990
4991 /* Similar to `lookup_name' but look only at current binding level.  */
4992
4993 tree
4994 lookup_name_current_level (name)
4995      tree name;
4996 {
4997   register tree t = NULL_TREE;
4998
4999   if (current_binding_level->namespace_p)
5000     {
5001       t =  IDENTIFIER_NAMESPACE_VALUE (name);
5002
5003       /* extern "C" function() */
5004       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5005         t = TREE_VALUE (t);
5006     }
5007   else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
5008     {
5009       struct binding_level *b = current_binding_level;
5010       while (1)
5011         {
5012           for (t = b->names; t; t = TREE_CHAIN (t))
5013             if (DECL_NAME (t) == name || DECL_ASSEMBLER_NAME (t) == name)
5014               goto out;
5015           if (b->keep == 2)
5016             b = b->level_chain;
5017           else
5018             break;
5019         }
5020     out:
5021       ;
5022     }
5023
5024   return t;
5025 }
5026
5027 void
5028 begin_only_namespace_names ()
5029 {
5030   only_namespace_names = 1;
5031 }
5032
5033 void
5034 end_only_namespace_names ()
5035 {
5036   only_namespace_names = 0;
5037 }
5038 \f
5039 /* Arrange for the user to get a source line number, even when the
5040    compiler is going down in flames, so that she at least has a
5041    chance of working around problems in the compiler.  We used to
5042    call error(), but that let the segmentation fault continue
5043    through; now, it's much more passive by asking them to send the
5044    maintainers mail about the problem.  */
5045
5046 static void
5047 signal_catch (sig)
5048      int sig ATTRIBUTE_UNUSED;
5049 {
5050   signal (SIGSEGV, SIG_DFL);
5051 #ifdef SIGIOT
5052   signal (SIGIOT, SIG_DFL);
5053 #endif
5054 #ifdef SIGILL
5055   signal (SIGILL, SIG_DFL);
5056 #endif
5057 #ifdef SIGABRT
5058   signal (SIGABRT, SIG_DFL);
5059 #endif
5060 #ifdef SIGBUS
5061   signal (SIGBUS, SIG_DFL);
5062 #endif
5063   my_friendly_abort (0);
5064 }
5065
5066 #if 0
5067 /* Unused -- brendan 970107 */
5068 /* Array for holding types considered "built-in".  These types
5069    are output in the module in which `main' is defined.  */
5070 static tree *builtin_type_tdescs_arr;
5071 static int builtin_type_tdescs_len, builtin_type_tdescs_max;
5072 #endif
5073
5074 /* Push the declarations of builtin types into the namespace.
5075    RID_INDEX, if < RID_MAX is the index of the builtin type
5076    in the array RID_POINTERS.  NAME is the name used when looking
5077    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5078
5079 static void
5080 record_builtin_type (rid_index, name, type)
5081      enum rid rid_index;
5082      char *name;
5083      tree type;
5084 {
5085   tree rname = NULL_TREE, tname = NULL_TREE;
5086   tree tdecl = NULL_TREE;
5087
5088   if ((int) rid_index < (int) RID_MAX)
5089     rname = ridpointers[(int) rid_index];
5090   if (name)
5091     tname = get_identifier (name);
5092
5093   TYPE_BUILT_IN (type) = 1;
5094
5095   if (tname)
5096     {
5097       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5098       set_identifier_type_value (tname, NULL_TREE);
5099       if ((int) rid_index < (int) RID_MAX)
5100         /* Built-in types live in the global namespace. */
5101         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5102     }
5103   if (rname != NULL_TREE)
5104     {
5105       if (tname != NULL_TREE)
5106         {
5107           set_identifier_type_value (rname, NULL_TREE);
5108           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5109         }
5110       else
5111         {
5112           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5113           set_identifier_type_value (rname, NULL_TREE);
5114         }
5115     }
5116 }
5117
5118 /* Record one of the standard Java types.
5119  * Declare it as having the given NAME.
5120  * If SIZE > 0, it is the size of one of the integral types;
5121  * otherwise it is the negative of the size of one of the other types.  */
5122
5123 static tree
5124 record_builtin_java_type (name, size)
5125      char *name;
5126      int size;
5127 {
5128   tree type, decl;
5129   if (size > 0)
5130     type = make_signed_type (size);
5131   else if (size > -32)
5132     { /* "__java_char" or ""__java_boolean". */
5133       type = make_unsigned_type (-size);
5134       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5135     }
5136   else
5137     { /* "__java_float" or ""__java_double". */
5138       type = make_node (REAL_TYPE);
5139       TYPE_PRECISION (type) = - size;
5140       layout_type (type);
5141     }
5142   record_builtin_type (RID_MAX, name, type);
5143   decl = TYPE_NAME (type);
5144   DECL_IGNORED_P (decl) = 1;
5145   TYPE_FOR_JAVA (type) = 1;
5146   return type;
5147 }
5148
5149 /* Push a type into the namespace so that the back-ends ignore it. */
5150
5151 static void
5152 record_unknown_type (type, name)
5153      tree type;
5154      char *name;
5155 {
5156   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5157   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5158   DECL_IGNORED_P (decl) = 1;
5159   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5160   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5161   TYPE_ALIGN (type) = 1;
5162   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5163 }
5164
5165 /* Push overloaded decl, in global scope, with one argument so it
5166    can be used as a callback from define_function.  */
5167
5168 static void
5169 push_overloaded_decl_1 (x)
5170      tree x;
5171 {
5172   push_overloaded_decl (x, 0);
5173 }
5174
5175 #ifdef __GNUC__
5176 __inline
5177 #endif
5178 tree
5179 auto_function (name, type, code)
5180      tree name, type;
5181      enum built_in_function code;
5182 {
5183   return define_function
5184     (IDENTIFIER_POINTER (name), type, code, push_overloaded_decl_1,
5185      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5186                                               0)));
5187 }
5188
5189 /* Create the predefined scalar types of C,
5190    and some nodes representing standard constants (0, 1, (void *)0).
5191    Initialize the global binding level.
5192    Make definitions for built-in primitive functions.  */
5193
5194 void
5195 init_decl_processing ()
5196 {
5197   register tree endlink, int_endlink, double_endlink, unsigned_endlink;
5198   tree fields[20];
5199   /* Data type of memcpy.  */
5200   tree memcpy_ftype, strlen_ftype;
5201   int wchar_type_size;
5202   tree temp;
5203   tree array_domain_type;
5204   extern int flag_strict_prototype;
5205   tree vb_off_identifier = NULL_TREE;
5206   /* Function type `char *(char *, char *)' and similar ones */
5207   tree string_ftype_ptr_ptr, int_ftype_string_string;
5208   tree sizetype_endlink;
5209   tree ptr_ftype, ptr_ftype_unsigned, ptr_ftype_sizetype;
5210   tree void_ftype, void_ftype_int, void_ftype_ptr, ptr_ftype_void;
5211
5212   /* Have to make these distinct before we try using them.  */
5213   lang_name_cplusplus = get_identifier ("C++");
5214   lang_name_c = get_identifier ("C");
5215   lang_name_java = get_identifier ("Java");
5216
5217   /* Enter the global namespace. */
5218   my_friendly_assert (global_namespace == NULL_TREE, 375);
5219   my_friendly_assert (current_lang_name == NULL_TREE, 375);
5220   current_lang_name = lang_name_cplusplus;
5221   push_namespace (get_identifier ("::"));
5222   global_namespace = current_namespace;
5223   current_lang_name = NULL_TREE;
5224
5225   if (flag_strict_prototype == 2)
5226     {
5227       if (pedantic)
5228         strict_prototypes_lang_c = strict_prototypes_lang_cplusplus;
5229     }
5230   else
5231     strict_prototypes_lang_c = flag_strict_prototype;
5232
5233   /* Initially, C.  */
5234   current_lang_name = lang_name_c;
5235
5236   current_function_decl = NULL_TREE;
5237   named_labels = NULL_TREE;
5238   named_label_uses = NULL;
5239   current_binding_level = NULL_BINDING_LEVEL;
5240   free_binding_level = NULL_BINDING_LEVEL;
5241
5242 #ifndef __CYGWIN32__
5243   /* Because most segmentation signals can be traced back into user
5244      code, catch them and at least give the user a chance of working
5245      around compiler bugs.  */
5246   signal (SIGSEGV, signal_catch);
5247
5248   /* We will also catch aborts in the back-end through signal_catch and
5249      give the user a chance to see where the error might be, and to defeat
5250      aborts in the back-end when there have been errors previously in their
5251      code.  */
5252 #ifdef SIGIOT
5253   signal (SIGIOT, signal_catch);
5254 #endif
5255 #ifdef SIGILL
5256   signal (SIGILL, signal_catch);
5257 #endif
5258 #ifdef SIGABRT
5259   signal (SIGABRT, signal_catch);
5260 #endif
5261 #ifdef SIGBUS
5262   signal (SIGBUS, signal_catch);
5263 #endif
5264 #else /* ndef __CYGWIN32__ */
5265   /* Cygwin32 cannot handle catching signals other than
5266      SIGABRT yet.  We hope this will cease to be the case soon. */
5267 #ifdef SIGABRT
5268   signal (SIGABRT, signal_catch);
5269 #endif
5270 #endif /* ndef __CYGWIN32__ */
5271
5272   gcc_obstack_init (&decl_obstack);
5273
5274   /* Must lay these out before anything else gets laid out.  */
5275   error_mark_node = make_node (ERROR_MARK);
5276   TREE_PERMANENT (error_mark_node) = 1;
5277   TREE_TYPE (error_mark_node) = error_mark_node;
5278   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
5279   TREE_TYPE (error_mark_list) = error_mark_node;
5280
5281   /* Make the binding_level structure for global names.  */
5282   pushlevel (0);
5283   global_binding_level = current_binding_level;
5284   /* The global level is the namespace level of ::.  */
5285   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
5286   declare_namespace_level ();
5287
5288   this_identifier = get_identifier (THIS_NAME);
5289   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
5290   ctor_identifier = get_identifier (CTOR_NAME);
5291   dtor_identifier = get_identifier (DTOR_NAME);
5292   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
5293   index_identifier = get_identifier (VTABLE_INDEX_NAME);
5294   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
5295   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
5296   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
5297   if (flag_handle_signatures)
5298     {
5299       tag_identifier = get_identifier (SIGTABLE_TAG_NAME);
5300       vb_off_identifier = get_identifier (SIGTABLE_VB_OFF_NAME);
5301       vt_off_identifier = get_identifier (SIGTABLE_VT_OFF_NAME);
5302     }
5303
5304   /* Define `int' and `char' first so that dbx will output them first.  */
5305
5306   integer_type_node = make_signed_type (INT_TYPE_SIZE);
5307   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
5308
5309   /* Define `char', which is like either `signed char' or `unsigned char'
5310      but not the same as either.  */
5311
5312   char_type_node
5313     = (flag_signed_char
5314        ? make_signed_type (CHAR_TYPE_SIZE)
5315        : make_unsigned_type (CHAR_TYPE_SIZE));
5316   record_builtin_type (RID_CHAR, "char", char_type_node);
5317
5318   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
5319   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
5320
5321   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
5322   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
5323
5324   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
5325   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
5326   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
5327
5328   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
5329   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
5330
5331   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
5332   record_builtin_type (RID_MAX, "long long unsigned int",
5333                        long_long_unsigned_type_node);
5334   record_builtin_type (RID_MAX, "long long unsigned",
5335                        long_long_unsigned_type_node);
5336
5337   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
5338   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
5339   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
5340   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
5341   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
5342
5343   /* `unsigned long' is the standard type for sizeof.
5344      Note that stddef.h uses `unsigned long',
5345      and this must agree, even if long and int are the same size.  */
5346   set_sizetype
5347     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
5348
5349   ptrdiff_type_node
5350     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
5351
5352   /* Define both `signed char' and `unsigned char'.  */
5353   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
5354   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
5355   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
5356   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
5357
5358   /* These are types that type_for_size and type_for_mode use.  */
5359   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
5360   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
5361   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
5362   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
5363   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
5364   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
5365   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
5366   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
5367   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
5368   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
5369   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
5370   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
5371   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
5372   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
5373   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
5374   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
5375   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
5376   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
5377   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
5378   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
5379
5380   float_type_node = make_node (REAL_TYPE);
5381   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
5382   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
5383   layout_type (float_type_node);
5384
5385   double_type_node = make_node (REAL_TYPE);
5386   if (flag_short_double)
5387     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
5388   else
5389     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
5390   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
5391   layout_type (double_type_node);
5392
5393   long_double_type_node = make_node (REAL_TYPE);
5394   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
5395   record_builtin_type (RID_MAX, "long double", long_double_type_node);
5396   layout_type (long_double_type_node);
5397
5398   complex_integer_type_node = make_node (COMPLEX_TYPE);
5399   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
5400                         complex_integer_type_node));
5401   TREE_TYPE (complex_integer_type_node) = integer_type_node;
5402   layout_type (complex_integer_type_node);
5403
5404   complex_float_type_node = make_node (COMPLEX_TYPE);
5405   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
5406                         complex_float_type_node));
5407   TREE_TYPE (complex_float_type_node) = float_type_node;
5408   layout_type (complex_float_type_node);
5409
5410   complex_double_type_node = make_node (COMPLEX_TYPE);
5411   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
5412                         complex_double_type_node));
5413   TREE_TYPE (complex_double_type_node) = double_type_node;
5414   layout_type (complex_double_type_node);
5415
5416   complex_long_double_type_node = make_node (COMPLEX_TYPE);
5417   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
5418                         complex_long_double_type_node));
5419   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
5420   layout_type (complex_long_double_type_node);
5421
5422   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
5423   java_short_type_node = record_builtin_java_type ("__java_short", 16);
5424   java_int_type_node = record_builtin_java_type ("__java_int", 32);
5425   java_long_type_node = record_builtin_java_type ("__java_long", 64);
5426   java_float_type_node = record_builtin_java_type ("__java_float", -32);
5427   java_double_type_node = record_builtin_java_type ("__java_double", -64);
5428   java_char_type_node = record_builtin_java_type ("__java_char", -16);
5429   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
5430
5431   integer_zero_node = build_int_2 (0, 0);
5432   TREE_TYPE (integer_zero_node) = integer_type_node;
5433   integer_one_node = build_int_2 (1, 0);
5434   TREE_TYPE (integer_one_node) = integer_type_node;
5435   integer_two_node = build_int_2 (2, 0);
5436   TREE_TYPE (integer_two_node) = integer_type_node;
5437   integer_three_node = build_int_2 (3, 0);
5438   TREE_TYPE (integer_three_node) = integer_type_node;
5439
5440   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5441   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5442   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
5443   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
5444   TYPE_PRECISION (boolean_type_node) = 1;
5445   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
5446   boolean_false_node = build_int_2 (0, 0);
5447   TREE_TYPE (boolean_false_node) = boolean_type_node;
5448   boolean_true_node = build_int_2 (1, 0);
5449   TREE_TYPE (boolean_true_node) = boolean_type_node;
5450
5451   /* These are needed by stor-layout.c.  */
5452   size_zero_node = size_int (0);
5453   size_one_node = size_int (1);
5454
5455   signed_size_zero_node = build_int_2 (0, 0);
5456   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
5457
5458   void_type_node = make_node (VOID_TYPE);
5459   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
5460   layout_type (void_type_node); /* Uses integer_zero_node.  */
5461   void_list_node = build_tree_list (NULL_TREE, void_type_node);
5462   TREE_PARMLIST (void_list_node) = 1;
5463
5464   null_pointer_node = build_int_2 (0, 0);
5465   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
5466   layout_type (TREE_TYPE (null_pointer_node));
5467
5468   /* Used for expressions that do nothing, but are not errors.  */
5469   void_zero_node = build_int_2 (0, 0);
5470   TREE_TYPE (void_zero_node) = void_type_node;
5471
5472   string_type_node = build_pointer_type (char_type_node);
5473   const_string_type_node
5474     = build_pointer_type (build_type_variant (char_type_node, 1, 0));
5475 #if 0
5476   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
5477 #endif
5478
5479   /* Make a type to be the domain of a few array types
5480      whose domains don't really matter.
5481      200 is small enough that it always fits in size_t
5482      and large enough that it can hold most function names for the
5483      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
5484   array_domain_type = build_index_type (build_int_2 (200, 0));
5485
5486   /* Make a type for arrays of characters.
5487      With luck nothing will ever really depend on the length of this
5488      array type.  */
5489   char_array_type_node
5490     = build_array_type (char_type_node, array_domain_type);
5491   /* Likewise for arrays of ints.  */
5492   int_array_type_node
5493     = build_array_type (integer_type_node, array_domain_type);
5494
5495   /* This is just some anonymous class type.  Nobody should ever
5496      need to look inside this envelope.  */
5497   class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
5498
5499   default_function_type
5500     = build_function_type (integer_type_node, NULL_TREE);
5501
5502   ptr_type_node = build_pointer_type (void_type_node);
5503   const_ptr_type_node
5504     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
5505 #if 0
5506   record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
5507 #endif
5508   endlink = void_list_node;
5509   int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
5510   double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
5511   unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
5512
5513   ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
5514   ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
5515   sizetype_endlink = tree_cons (NULL_TREE, sizetype, endlink);
5516   /* We realloc here because sizetype could be int or unsigned.  S'ok.  */
5517   ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
5518
5519   void_ftype = build_function_type (void_type_node, endlink);
5520   void_ftype_int = build_function_type (void_type_node, int_endlink);
5521   void_ftype_ptr
5522     = build_function_type (void_type_node,
5523                            tree_cons (NULL_TREE, ptr_type_node, endlink));
5524   void_ftype_ptr
5525     = build_exception_variant (void_ftype_ptr,
5526                                tree_cons (NULL_TREE, NULL_TREE, NULL_TREE));
5527
5528   float_ftype_float
5529     = build_function_type (float_type_node,
5530                            tree_cons (NULL_TREE, float_type_node, endlink));
5531
5532   double_ftype_double
5533     = build_function_type (double_type_node, double_endlink);
5534
5535   ldouble_ftype_ldouble
5536     = build_function_type (long_double_type_node,
5537                            tree_cons (NULL_TREE, long_double_type_node,
5538                                       endlink));
5539
5540   double_ftype_double_double
5541     = build_function_type (double_type_node,
5542                            tree_cons (NULL_TREE, double_type_node,
5543                                       double_endlink));
5544
5545   int_ftype_int
5546     = build_function_type (integer_type_node, int_endlink);
5547
5548   long_ftype_long
5549     = build_function_type (long_integer_type_node,
5550                            tree_cons (NULL_TREE, long_integer_type_node,
5551                                       endlink));
5552
5553   int_ftype_cptr_cptr_sizet
5554     = build_function_type (integer_type_node,
5555                            tree_cons (NULL_TREE, const_ptr_type_node,
5556                                       tree_cons (NULL_TREE, const_ptr_type_node,
5557                                                  tree_cons (NULL_TREE,
5558                                                             sizetype,
5559                                                             endlink))));
5560
5561   string_ftype_ptr_ptr          /* strcpy prototype */
5562     = build_function_type (string_type_node,
5563                            tree_cons (NULL_TREE, string_type_node,
5564                                       tree_cons (NULL_TREE,
5565                                                  const_string_type_node,
5566                                                  endlink)));
5567
5568   int_ftype_string_string       /* strcmp prototype */
5569     = build_function_type (integer_type_node,
5570                            tree_cons (NULL_TREE, const_string_type_node,
5571                                       tree_cons (NULL_TREE,
5572                                                  const_string_type_node,
5573                                                  endlink)));
5574
5575   strlen_ftype          /* strlen prototype */
5576     = build_function_type (sizetype,
5577                            tree_cons (NULL_TREE, const_string_type_node,
5578                                       endlink));
5579
5580   memcpy_ftype  /* memcpy prototype */
5581     = build_function_type (ptr_type_node,
5582                            tree_cons (NULL_TREE, ptr_type_node,
5583                                       tree_cons (NULL_TREE, const_ptr_type_node,
5584                                                  sizetype_endlink)));
5585
5586   if (flag_huge_objects)
5587     delta_type_node = long_integer_type_node;
5588   else
5589     delta_type_node = short_integer_type_node;
5590
5591   builtin_function ("__builtin_constant_p", default_function_type,
5592                     BUILT_IN_CONSTANT_P, NULL_PTR);
5593
5594   builtin_return_address_fndecl
5595     = builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
5596                         BUILT_IN_RETURN_ADDRESS, NULL_PTR);
5597
5598   builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
5599                     BUILT_IN_FRAME_ADDRESS, NULL_PTR);
5600
5601   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
5602   builtin_function ("__builtin_fp", ptr_ftype_void, BUILT_IN_FP, NULL_PTR);
5603   builtin_function ("__builtin_sp", ptr_ftype_void, BUILT_IN_SP, NULL_PTR);
5604
5605   builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
5606                     BUILT_IN_ALLOCA, "alloca");
5607   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
5608   /* Define alloca, ffs as builtins.
5609      Declare _exit just to mark it as volatile.  */
5610   if (! flag_no_builtin && !flag_no_nonansi_builtin)
5611     {
5612       temp = builtin_function ("alloca", ptr_ftype_sizetype,
5613                                BUILT_IN_ALLOCA, NULL_PTR);
5614       /* Suppress error if redefined as a non-function.  */
5615       DECL_BUILT_IN_NONANSI (temp) = 1;
5616       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
5617       /* Suppress error if redefined as a non-function.  */
5618       DECL_BUILT_IN_NONANSI (temp) = 1;
5619       temp = builtin_function ("_exit", void_ftype_int,
5620                                NOT_BUILT_IN, NULL_PTR);
5621       TREE_THIS_VOLATILE (temp) = 1;
5622       TREE_SIDE_EFFECTS (temp) = 1;
5623       /* Suppress error if redefined as a non-function.  */
5624       DECL_BUILT_IN_NONANSI (temp) = 1;
5625     }
5626
5627   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5628   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
5629                     NULL_PTR);
5630   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
5631                     NULL_PTR);
5632   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5633                     NULL_PTR);
5634   builtin_function ("__builtin_labs", long_ftype_long,
5635                     BUILT_IN_LABS, NULL_PTR);
5636   builtin_function ("__builtin_saveregs", ptr_ftype,
5637                     BUILT_IN_SAVEREGS, NULL_PTR);
5638   builtin_function ("__builtin_classify_type", default_function_type,
5639                     BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
5640   builtin_function ("__builtin_next_arg", ptr_ftype,
5641                     BUILT_IN_NEXT_ARG, NULL_PTR);
5642   builtin_function ("__builtin_args_info", int_ftype_int,
5643                     BUILT_IN_ARGS_INFO, NULL_PTR);
5644   builtin_function ("__builtin_setjmp",
5645                     build_function_type (integer_type_node,
5646                                          tree_cons (NULL_TREE, ptr_type_node,
5647                                                     endlink)),
5648                     BUILT_IN_SETJMP, NULL_PTR);
5649   builtin_function ("__builtin_longjmp",
5650                     build_function_type (integer_type_node,
5651                                          tree_cons (NULL_TREE, ptr_type_node,
5652                                                     tree_cons (NULL_TREE,
5653                                                                integer_type_node,
5654                                                                endlink))),
5655                     BUILT_IN_LONGJMP, NULL_PTR);
5656
5657   /* Untyped call and return.  */
5658   builtin_function ("__builtin_apply_args", ptr_ftype,
5659                     BUILT_IN_APPLY_ARGS, NULL_PTR);
5660
5661   temp = tree_cons (NULL_TREE,
5662                     build_pointer_type (build_function_type (void_type_node,
5663                                                              NULL_TREE)),
5664                     tree_cons (NULL_TREE, ptr_ftype_sizetype, NULL_TREE));
5665   builtin_function ("__builtin_apply",
5666                     build_function_type (ptr_type_node, temp),
5667                     BUILT_IN_APPLY, NULL_PTR);
5668   builtin_function ("__builtin_return", void_ftype_ptr,
5669                     BUILT_IN_RETURN, NULL_PTR);
5670
5671   /* Currently under experimentation.  */
5672   builtin_function ("__builtin_memcpy", memcpy_ftype,
5673                     BUILT_IN_MEMCPY, "memcpy");
5674   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
5675                     BUILT_IN_MEMCMP, "memcmp");
5676   builtin_function ("__builtin_strcmp", int_ftype_string_string,
5677                     BUILT_IN_STRCMP, "strcmp");
5678   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
5679                     BUILT_IN_STRCPY, "strcpy");
5680   builtin_function ("__builtin_strlen", strlen_ftype,
5681                     BUILT_IN_STRLEN, "strlen");
5682   builtin_function ("__builtin_sqrtf", float_ftype_float,
5683                     BUILT_IN_FSQRT, "sqrtf");
5684   builtin_function ("__builtin_fsqrt", double_ftype_double,
5685                     BUILT_IN_FSQRT, NULL_PTR);
5686   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
5687                     BUILT_IN_FSQRT, "sqrtl");
5688   builtin_function ("__builtin_sinf", float_ftype_float,
5689                     BUILT_IN_SIN, "sinf");
5690   builtin_function ("__builtin_sin", double_ftype_double,
5691                     BUILT_IN_SIN, "sin");
5692   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
5693                     BUILT_IN_SIN, "sinl");
5694   builtin_function ("__builtin_cosf", float_ftype_float,
5695                     BUILT_IN_COS, "cosf");
5696   builtin_function ("__builtin_cos", double_ftype_double,
5697                     BUILT_IN_COS, "cos");
5698   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
5699                     BUILT_IN_COS, "cosl");
5700
5701   if (!flag_no_builtin)
5702     {
5703       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5704       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
5705       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
5706       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
5707       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5708                         NULL_PTR);
5709       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
5710       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
5711                         NULL_PTR);
5712       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
5713                         NULL_PTR);
5714       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
5715                         NULL_PTR);
5716       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
5717       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
5718       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
5719       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
5720                         NULL_PTR);
5721       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
5722       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
5723       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
5724       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
5725       builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
5726       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
5727
5728       /* Declare these functions volatile
5729          to avoid spurious "control drops through" warnings.  */
5730       temp = builtin_function ("abort", void_ftype,
5731                                NOT_BUILT_IN, NULL_PTR);
5732       TREE_THIS_VOLATILE (temp) = 1;
5733       TREE_SIDE_EFFECTS (temp) = 1;
5734       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
5735          them...  */
5736       DECL_BUILT_IN_NONANSI (temp) = 1;
5737       temp = builtin_function ("exit", void_ftype_int,
5738                                NOT_BUILT_IN, NULL_PTR);
5739       TREE_THIS_VOLATILE (temp) = 1;
5740       TREE_SIDE_EFFECTS (temp) = 1;
5741       DECL_BUILT_IN_NONANSI (temp) = 1;
5742     }
5743
5744 #if 0
5745   /* Support for these has not been written in either expand_builtin
5746      or build_function_call.  */
5747   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
5748   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
5749   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
5750                     NULL_PTR);
5751   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
5752                     NULL_PTR);
5753   builtin_function ("__builtin_fmod", double_ftype_double_double,
5754                     BUILT_IN_FMOD, NULL_PTR);
5755   builtin_function ("__builtin_frem", double_ftype_double_double,
5756                     BUILT_IN_FREM, NULL_PTR);
5757   builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
5758                     BUILT_IN_MEMSET, NULL_PTR);
5759   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
5760                     NULL_PTR);
5761   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
5762                     NULL_PTR);
5763 #endif
5764
5765   /* C++ extensions */
5766
5767   unknown_type_node = make_node (UNKNOWN_TYPE);
5768   record_unknown_type (unknown_type_node, "unknown type");
5769
5770   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
5771   TREE_TYPE (unknown_type_node) = unknown_type_node;
5772
5773   if (flag_ansi)
5774     TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
5775   else
5776     TREE_TYPE (null_node) = build_pointer_type (unknown_type_node);
5777
5778   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
5779      result.  */
5780   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
5781   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
5782
5783   /* This is for handling opaque types in signatures.  */
5784   opaque_type_node = copy_node (ptr_type_node);
5785   TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
5786   record_builtin_type (RID_MAX, 0, opaque_type_node);
5787
5788   /* This is special for C++ so functions can be overloaded.  */
5789   wchar_type_node
5790     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
5791   wchar_type_size = TYPE_PRECISION (wchar_type_node);
5792   signed_wchar_type_node = make_signed_type (wchar_type_size);
5793   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
5794   wchar_type_node
5795     = TREE_UNSIGNED (wchar_type_node)
5796       ? unsigned_wchar_type_node
5797       : signed_wchar_type_node;
5798   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
5799
5800   /* Artificial declaration of wchar_t -- can be bashed */
5801   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
5802                                 wchar_type_node);
5803   pushdecl (wchar_decl_node);
5804
5805   /* This is for wide string constants.  */
5806   wchar_array_type_node
5807     = build_array_type (wchar_type_node, array_domain_type);
5808
5809   if (flag_vtable_thunks)
5810     {
5811       /* Make sure we get a unique function type, so we can give
5812          its pointer type a name.  (This wins for gdb.) */
5813       tree vfunc_type = make_node (FUNCTION_TYPE);
5814       TREE_TYPE (vfunc_type) = integer_type_node;
5815       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
5816       layout_type (vfunc_type);
5817
5818       vtable_entry_type = build_pointer_type (vfunc_type);
5819     }
5820   else
5821     {
5822       vtable_entry_type = make_lang_type (RECORD_TYPE);
5823       fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
5824                                          delta_type_node);
5825       fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
5826                                          delta_type_node);
5827       fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
5828                                          ptr_type_node);
5829       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
5830                            double_type_node);
5831
5832       /* Make this part of an invisible union.  */
5833       fields[3] = copy_node (fields[2]);
5834       TREE_TYPE (fields[3]) = delta_type_node;
5835       DECL_NAME (fields[3]) = delta2_identifier;
5836       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
5837       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
5838       TREE_UNSIGNED (fields[3]) = 0;
5839       TREE_CHAIN (fields[2]) = fields[3];
5840       vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
5841     }
5842   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
5843
5844   vtbl_type_node
5845     = build_array_type (vtable_entry_type, NULL_TREE);
5846   layout_type (vtbl_type_node);
5847   vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0);
5848   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
5849
5850   /* Simplify life by making a "sigtable_entry_type".  Give its
5851      fields names so that the debugger can use them.  */
5852
5853   if (flag_handle_signatures)
5854     {
5855       sigtable_entry_type = make_lang_type (RECORD_TYPE);
5856       fields[0] = build_lang_field_decl (FIELD_DECL, tag_identifier,
5857                                          delta_type_node);
5858       fields[1] = build_lang_field_decl (FIELD_DECL, vb_off_identifier,
5859                                          delta_type_node);
5860       fields[2] = build_lang_field_decl (FIELD_DECL, delta_identifier,
5861                                          delta_type_node);
5862       fields[3] = build_lang_field_decl (FIELD_DECL, index_identifier,
5863                                          delta_type_node);
5864       fields[4] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
5865                                          ptr_type_node);
5866
5867       /* Set the alignment to the max of the alignment of ptr_type_node and
5868          delta_type_node.  Double alignment wastes a word on the Sparc.  */
5869       finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 4,
5870                            (TYPE_ALIGN (ptr_type_node) > TYPE_ALIGN (delta_type_node))
5871                            ? ptr_type_node
5872                            : delta_type_node);
5873
5874       /* Make this part of an invisible union.  */
5875       fields[5] = copy_node (fields[4]);
5876       TREE_TYPE (fields[5]) = delta_type_node;
5877       DECL_NAME (fields[5]) = vt_off_identifier;
5878       DECL_MODE (fields[5]) = TYPE_MODE (delta_type_node);
5879       DECL_SIZE (fields[5]) = TYPE_SIZE (delta_type_node);
5880       TREE_UNSIGNED (fields[5]) = 0;
5881       TREE_CHAIN (fields[4]) = fields[5];
5882
5883       sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
5884       record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
5885     }
5886
5887   std_node = build_decl (NAMESPACE_DECL,
5888                          get_identifier (flag_honor_std ? "fake std":"std"),
5889                          void_type_node);
5890   pushdecl (std_node);
5891
5892   global_type_node = make_node (LANG_TYPE);
5893   record_unknown_type (global_type_node, "global type");
5894
5895   /* Now, C++.  */
5896   current_lang_name = lang_name_cplusplus;
5897
5898   {
5899     tree bad_alloc_type_node, newtype, deltype;
5900     if (flag_honor_std)
5901       push_namespace (get_identifier ("std"));
5902     bad_alloc_type_node = xref_tag
5903       (class_type_node, get_identifier ("bad_alloc"), NULL_TREE, 1);
5904     if (flag_honor_std)
5905       pop_namespace ();
5906     newtype = build_exception_variant
5907       (ptr_ftype_sizetype, build_tree_list (NULL_TREE, bad_alloc_type_node));
5908     deltype = build_exception_variant
5909       (void_ftype_ptr, build_tree_list (NULL_TREE, NULL_TREE));
5910     auto_function (ansi_opname[(int) NEW_EXPR], newtype, NOT_BUILT_IN);
5911     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype, NOT_BUILT_IN);
5912     auto_function (ansi_opname[(int) DELETE_EXPR], deltype, NOT_BUILT_IN);
5913     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype, NOT_BUILT_IN);
5914   }
5915
5916   abort_fndecl
5917     = define_function ("__pure_virtual", void_ftype,
5918                        NOT_BUILT_IN, 0, 0);
5919
5920   /* Perform other language dependent initializations.  */
5921   init_class_processing ();
5922   init_init_processing ();
5923   init_search_processing ();
5924   if (flag_rtti)
5925     init_rtti_processing ();
5926
5927   if (flag_exceptions)
5928     init_exception_processing ();
5929   if (flag_no_inline)
5930     {
5931       flag_inline_functions = 0;
5932     }
5933
5934   if (! supports_one_only ())
5935     flag_weak = 0;
5936
5937   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
5938   declare_function_name ();
5939
5940   /* Prepare to check format strings against argument lists.  */
5941   init_function_format_info ();
5942
5943   /* Show we use EH for cleanups.  */
5944   using_eh_for_cleanups ();
5945
5946   print_error_function = lang_print_error_function;
5947 }
5948
5949 /* Function to print any language-specific context for an error message.  */
5950
5951 static void
5952 lang_print_error_function (file)
5953      char *file;
5954 {
5955   default_print_error_function (file);
5956   maybe_print_template_context ();
5957 }
5958
5959 /* Make a definition for a builtin function named NAME and whose data type
5960    is TYPE.  TYPE should be a function type with argument types.
5961    FUNCTION_CODE tells later passes how to compile calls to this function.
5962    See tree.h for its possible values.
5963
5964    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
5965    the name to be called if we can't opencode the function.  */
5966
5967 tree
5968 define_function (name, type, function_code, pfn, library_name)
5969      char *name;
5970      tree type;
5971      enum built_in_function function_code;
5972      void (*pfn) PROTO((tree));
5973      char *library_name;
5974 {
5975   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
5976   DECL_EXTERNAL (decl) = 1;
5977   TREE_PUBLIC (decl) = 1;
5978   DECL_ARTIFICIAL (decl) = 1;
5979
5980   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
5981   DECL_CONTEXT (decl) = current_namespace;
5982
5983   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
5984      we cannot change DECL_ASSEMBLER_NAME until we have installed this
5985      function in the namespace.  */
5986   if (pfn) (*pfn) (decl);
5987   if (library_name)
5988     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
5989   make_function_rtl (decl);
5990   if (function_code != NOT_BUILT_IN)
5991     {
5992       DECL_BUILT_IN (decl) = 1;
5993       DECL_FUNCTION_CODE (decl) = function_code;
5994     }
5995   return decl;
5996 }
5997 \f
5998 /* Called when a declaration is seen that contains no names to declare.
5999    If its type is a reference to a structure, union or enum inherited
6000    from a containing scope, shadow that tag name for the current scope
6001    with a forward reference.
6002    If its type defines a new named structure or union
6003    or defines an enum, it is valid but we need not do anything here.
6004    Otherwise, it is an error.
6005
6006    C++: may have to grok the declspecs to learn about static,
6007    complain for anonymous unions.  */
6008
6009 void
6010 shadow_tag (declspecs)
6011      tree declspecs;
6012 {
6013   int found_tag = 0;
6014   tree ob_modifier = NULL_TREE;
6015   register tree link;
6016   register enum tree_code code, ok_code = ERROR_MARK;
6017   register tree t = NULL_TREE;
6018
6019   for (link = declspecs; link; link = TREE_CHAIN (link))
6020     {
6021       register tree value = TREE_VALUE (link);
6022
6023       code = TREE_CODE (value);
6024       if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
6025         {
6026           my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6027
6028           if (IS_AGGR_TYPE (value) && CLASSTYPE_USE_TEMPLATE (value))
6029             {
6030               if (CLASSTYPE_IMPLICIT_INSTANTIATION (value)
6031                   && TYPE_SIZE (value) == NULL_TREE)
6032                 {
6033                   SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (value);
6034                   if (processing_template_decl)
6035                     push_template_decl (TYPE_MAIN_DECL (value));
6036                 }
6037               else if (CLASSTYPE_TEMPLATE_INSTANTIATION (value))
6038                 cp_error ("specialization after instantiation of `%T'", value);
6039             }
6040
6041           t = value;
6042           ok_code = code;
6043           found_tag++;
6044         }
6045       else if (value == ridpointers[(int) RID_STATIC]
6046                || value == ridpointers[(int) RID_EXTERN]
6047                || value == ridpointers[(int) RID_AUTO]
6048                || value == ridpointers[(int) RID_REGISTER]
6049                || value == ridpointers[(int) RID_INLINE]
6050                || value == ridpointers[(int) RID_VIRTUAL]
6051                || value == ridpointers[(int) RID_EXPLICIT])
6052         ob_modifier = value;
6053     }
6054
6055   /* This is where the variables in an anonymous union are
6056      declared.  An anonymous union declaration looks like:
6057      union { ... } ;
6058      because there is no declarator after the union, the parser
6059      sends that declaration here.  */
6060   if (ok_code == UNION_TYPE
6061       && t != NULL_TREE
6062       && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
6063            && ANON_AGGRNAME_P (TYPE_NAME (t)))
6064           || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
6065               && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
6066     {
6067       /* See also grok_x_components.  */
6068       tree *q;
6069
6070       /* Wipe out memory of synthesized methods */
6071       TYPE_HAS_CONSTRUCTOR (t) = 0;
6072       TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6073       TYPE_HAS_INIT_REF (t) = 0;
6074       TYPE_HAS_CONST_INIT_REF (t) = 0;
6075       TYPE_HAS_ASSIGN_REF (t) = 0;
6076       TYPE_HAS_ASSIGNMENT (t) = 0;
6077       TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6078
6079       q = &TYPE_METHODS (t);
6080       while (*q)
6081         {
6082           if (DECL_ARTIFICIAL (*q))
6083             *q = TREE_CHAIN (*q);
6084           else
6085             q = &TREE_CHAIN (*q);
6086         }
6087
6088       /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
6089          function members.  */
6090       if (TYPE_METHODS (t))
6091         error ("an anonymous union cannot have function members");
6092
6093       if (TYPE_FIELDS (t))
6094         {
6095           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6096                                       NULL_TREE);
6097           finish_anon_union (decl);
6098         }
6099     }
6100   else
6101     {
6102       /* Anonymous unions are objects, that's why we only check for
6103          inappropriate specifiers in this branch.  */
6104
6105       if (ob_modifier)
6106         {
6107           if (ob_modifier == ridpointers[(int) RID_INLINE]
6108               || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6109             cp_error ("`%D' can only be specified for functions", ob_modifier);
6110           else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6111             cp_error ("`%D' can only be specified for constructors",
6112                       ob_modifier);
6113           else
6114             cp_error ("`%D' can only be specified for objects and functions",
6115                       ob_modifier);
6116         }
6117
6118       if (found_tag == 0)
6119         cp_error ("abstract declarator used as declaration");
6120       else if (found_tag > 1)
6121         pedwarn ("multiple types in one declaration");
6122     }
6123 }
6124 \f
6125 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6126
6127 tree
6128 groktypename (typename)
6129      tree typename;
6130 {
6131   if (TREE_CODE (typename) != TREE_LIST)
6132     return typename;
6133   return grokdeclarator (TREE_VALUE (typename),
6134                          TREE_PURPOSE (typename),
6135                          TYPENAME, 0, NULL_TREE);
6136 }
6137
6138 /* Decode a declarator in an ordinary declaration or data definition.
6139    This is called as soon as the type information and variable name
6140    have been parsed, before parsing the initializer if any.
6141    Here we create the ..._DECL node, fill in its type,
6142    and put it on the list of decls for the current context.
6143    The ..._DECL node is returned as the value.
6144
6145    Exception: for arrays where the length is not specified,
6146    the type is left null, to be filled in by `cp_finish_decl'.
6147
6148    Function definitions do not come here; they go to start_function
6149    instead.  However, external and forward declarations of functions
6150    do go through here.  Structure field declarations are done by
6151    grokfield and not through here.  */
6152
6153 /* Set this to zero to debug not using the temporary obstack
6154    to parse initializers.  */
6155 int debug_temp_inits = 1;
6156
6157 tree
6158 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6159      tree declarator, declspecs;
6160      int initialized;
6161      tree attributes, prefix_attributes;
6162 {
6163   register tree decl;
6164   register tree type, tem;
6165   tree context;
6166   extern int have_extern_spec;
6167   extern int used_extern_spec;
6168
6169 #if 0
6170   /* See code below that used this.  */
6171   int init_written = initialized;
6172 #endif
6173
6174   /* This should only be done once on the top most decl.  */
6175   if (have_extern_spec && !used_extern_spec)
6176     {
6177       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6178                                   declspecs);
6179       used_extern_spec = 1;
6180     }
6181
6182   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6183                          NULL_TREE);
6184   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6185     return NULL_TREE;
6186
6187   type = TREE_TYPE (decl);
6188
6189   /* Don't lose if destructors must be executed at file-level.  */
6190   if (! processing_template_decl && TREE_STATIC (decl)
6191       && TYPE_NEEDS_DESTRUCTOR (complete_type (type))
6192       && !TREE_PERMANENT (decl))
6193     {
6194       push_obstacks (&permanent_obstack, &permanent_obstack);
6195       decl = copy_node (decl);
6196       if (TREE_CODE (type) == ARRAY_TYPE)
6197         {
6198           tree itype = TYPE_DOMAIN (type);
6199           if (itype && ! TREE_PERMANENT (itype))
6200             {
6201               itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
6202               type = build_cplus_array_type (TREE_TYPE (type), itype);
6203               TREE_TYPE (decl) = type;
6204             }
6205         }
6206       pop_obstacks ();
6207     }
6208
6209   context
6210     = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6211       ? DECL_CLASS_CONTEXT (decl)
6212       : DECL_CONTEXT (decl);
6213
6214   /* We are only interested in class contexts, later. */
6215   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6216     context = NULL_TREE;
6217
6218   if (initialized)
6219     /* Is it valid for this decl to have an initializer at all?
6220        If not, set INITIALIZED to zero, which will indirectly
6221        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6222     switch (TREE_CODE (decl))
6223       {
6224       case TYPE_DECL:
6225         /* typedef foo = bar  means give foo the same type as bar.
6226            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6227            Any other case of an initialization in a TYPE_DECL is an error.  */
6228         if (pedantic || list_length (declspecs) > 1)
6229           {
6230             cp_error ("typedef `%D' is initialized", decl);
6231             initialized = 0;
6232           }
6233         break;
6234
6235       case FUNCTION_DECL:
6236         cp_error ("function `%#D' is initialized like a variable", decl);
6237         initialized = 0;
6238         break;
6239
6240       default:
6241         if (! processing_template_decl)
6242           {
6243             if (type != error_mark_node)
6244               {
6245                 if (TYPE_SIZE (type) != NULL_TREE
6246                     && ! TREE_CONSTANT (TYPE_SIZE (type)))
6247                   {
6248                     cp_error
6249                       ("variable-sized object `%D' may not be initialized",
6250                        decl);
6251                     initialized = 0;
6252                   }
6253
6254                 if (TREE_CODE (type) == ARRAY_TYPE
6255                     && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6256                   {
6257                     cp_error
6258                       ("elements of array `%#D' have incomplete type", decl);
6259                     initialized = 0;
6260                   }
6261               }
6262           }
6263       }
6264
6265   if (initialized)
6266     {
6267       if (! toplevel_bindings_p ()
6268           && DECL_EXTERNAL (decl))
6269         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6270                     decl);
6271       DECL_EXTERNAL (decl) = 0;
6272       if (toplevel_bindings_p ())
6273         TREE_STATIC (decl) = 1;
6274
6275       /* Tell `pushdecl' this is an initialized decl
6276          even though we don't yet have the initializer expression.
6277          Also tell `cp_finish_decl' it may store the real initializer.  */
6278       DECL_INITIAL (decl) = error_mark_node;
6279     }
6280
6281   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6282     {
6283       if (TREE_CODE (decl) == VAR_DECL)
6284         {
6285           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6286           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6287             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6288           else
6289             {
6290               if (DECL_CONTEXT (field) != context)
6291                 {
6292                   cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6293                               DECL_CONTEXT (field), DECL_NAME (decl),
6294                               context, DECL_NAME (decl));
6295                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6296                 }
6297               /* Static data member are tricky; an in-class initialization
6298                  still doesn't provide a definition, so the in-class
6299                  declaration will have DECL_EXTERNAL set, but will have an
6300                  initialization.  Thus, duplicate_decls won't warn
6301                  about this situation, and so we check here.  */
6302               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6303                 cp_error ("duplicate initialization of %D", decl);
6304               if (duplicate_decls (decl, field))
6305                 decl = field;
6306             }
6307         }
6308       else
6309         {
6310           tree field = check_classfn (context, decl);
6311           if (field && duplicate_decls (decl, field))
6312             decl = field;
6313         }
6314
6315       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6316       DECL_IN_AGGR_P (decl) = 0;
6317       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6318           || CLASSTYPE_USE_TEMPLATE (context))
6319         SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6320
6321       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6322         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6323                     decl);
6324
6325       pushclass (context, 2);
6326     }
6327
6328   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6329   cplus_decl_attributes (decl, attributes, prefix_attributes);
6330
6331   /* Add this decl to the current binding level, but not if it
6332      comes from another scope, e.g. a static member variable.
6333      TEM may equal DECL or it may be a previous decl of the same name.  */
6334
6335   if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE
6336        /* Definitions of namespace members outside their namespace are
6337           possible. */
6338        && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
6339       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
6340       || TREE_CODE (type) == LANG_TYPE
6341       /* The declaration of template specializations does not affect
6342          the functions available for overload resolution, so we do not
6343          call pushdecl.  */
6344       || (TREE_CODE (decl) == FUNCTION_DECL
6345           && DECL_TEMPLATE_SPECIALIZATION (decl)))
6346     tem = decl;
6347   else
6348     tem = pushdecl (decl);
6349
6350   if (processing_template_decl)
6351     {
6352       if (! current_function_decl)
6353         tem = push_template_decl (tem);
6354       else if (minimal_parse_mode)
6355         DECL_VINDEX (tem)
6356             = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
6357                             copy_to_permanent (declspecs),
6358                             NULL_TREE);
6359     }
6360
6361
6362 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6363   /* Tell the back-end to use or not use .common as appropriate.  If we say
6364      -fconserve-space, we want this to save .data space, at the expense of
6365      wrong semantics.  If we say -fno-conserve-space, we want this to
6366      produce errors about redefs; to do this we force variables into the
6367      data segment.  */
6368   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6369 #endif
6370
6371   if (! processing_template_decl)
6372     start_decl_1 (tem);
6373
6374   /* Corresponding pop_obstacks is done in `cp_finish_decl'.  */
6375   push_obstacks_nochange ();
6376
6377 #if 0
6378   /* We have no way of knowing whether the initializer will need to be
6379      evaluated at run-time or not until we've parsed it, so let's just put
6380      it in the permanent obstack.  (jason) */
6381   if (init_written
6382       && ! (TREE_CODE (tem) == PARM_DECL
6383             || (TREE_READONLY (tem)
6384                 && (TREE_CODE (tem) == VAR_DECL
6385                     || TREE_CODE (tem) == FIELD_DECL))))
6386     {
6387       /* When parsing and digesting the initializer,
6388          use temporary storage.  Do this even if we will ignore the value.  */
6389       if (toplevel_bindings_p () && debug_temp_inits)
6390         {
6391           if (processing_template_decl
6392               || TYPE_NEEDS_CONSTRUCTING (type)
6393               || TREE_CODE (type) == REFERENCE_TYPE)
6394             /* In this case, the initializer must lay down in permanent
6395                storage, since it will be saved until `finish_file' is run.   */
6396             ;
6397           else
6398             temporary_allocation ();
6399         }
6400     }
6401 #endif
6402
6403   return tem;
6404 }
6405
6406 void
6407 start_decl_1 (decl)
6408      tree decl;
6409 {
6410   tree type = TREE_TYPE (decl);
6411   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6412
6413   /* If this type of object needs a cleanup, and control may
6414      jump past it, make a new binding level so that it is cleaned
6415      up only when it is initialized first.  */
6416   if (TYPE_NEEDS_DESTRUCTOR (type)
6417       && current_binding_level->more_cleanups_ok == 0)
6418     pushlevel_temporary (1);
6419
6420   if (initialized)
6421     /* Is it valid for this decl to have an initializer at all?
6422        If not, set INITIALIZED to zero, which will indirectly
6423        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6424     {
6425       /* Don't allow initializations for incomplete types except for
6426          arrays which might be completed by the initialization.  */
6427       if (type == error_mark_node)
6428         ;                       /* Don't complain again.  */
6429       else if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6430         ;                       /* A complete type is ok.  */
6431       else if (TREE_CODE (type) != ARRAY_TYPE)
6432         {
6433           cp_error ("variable `%#D' has initializer but incomplete type",
6434                     decl);
6435           initialized = 0;
6436         }
6437       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6438         {
6439           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6440             cp_error ("elements of array `%#D' have incomplete type", decl);
6441           /* else we already gave an error in start_decl.  */
6442           initialized = 0;
6443         }
6444     }
6445
6446   if (!initialized
6447       && TREE_CODE (decl) != TYPE_DECL
6448       && TREE_CODE (decl) != TEMPLATE_DECL
6449       && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
6450     {
6451       if ((! processing_template_decl || ! uses_template_parms (type))
6452           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6453         {
6454           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6455                  decl);
6456           /* Change the type so that assemble_variable will give
6457              DECL an rtl we can live with: (mem (const_int 0)).  */
6458           TREE_TYPE (decl) = error_mark_node;
6459           type = error_mark_node;
6460         }
6461       else
6462         {
6463           /* If any base type in the hierarchy of TYPE needs a constructor,
6464              then we set initialized to 1.  This way any nodes which are
6465              created for the purposes of initializing this aggregate
6466              will live as long as it does.  This is necessary for global
6467              aggregates which do not have their initializers processed until
6468              the end of the file.  */
6469           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6470         }
6471     }
6472
6473 #if 0
6474   /* We don't do this yet for GNU C++.  */
6475   /* For a local variable, define the RTL now.  */
6476   if (! toplevel_bindings_p ()
6477       /* But not if this is a duplicate decl
6478          and we preserved the rtl from the previous one
6479          (which may or may not happen).  */
6480       && DECL_RTL (tem) == NULL_RTX)
6481     {
6482       if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
6483         expand_decl (tem);
6484       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
6485                && DECL_INITIAL (tem) != NULL_TREE)
6486         expand_decl (tem);
6487     }
6488 #endif
6489
6490   if (! initialized)
6491     DECL_INITIAL (decl) = NULL_TREE;
6492 }
6493
6494 /* Handle initialization of references.
6495    These three arguments are from `cp_finish_decl', and have the
6496    same meaning here that they do there.
6497
6498    Quotes on semantics can be found in ARM 8.4.3.  */
6499
6500 static void
6501 grok_reference_init (decl, type, init)
6502      tree decl, type, init;
6503 {
6504   tree tmp;
6505
6506   if (init == NULL_TREE)
6507     {
6508       if ((DECL_LANG_SPECIFIC (decl) == 0
6509            || DECL_IN_AGGR_P (decl) == 0)
6510           && ! DECL_THIS_EXTERN (decl))
6511         {
6512           cp_error ("`%D' declared as reference but not initialized", decl);
6513           if (TREE_CODE (decl) == VAR_DECL)
6514             SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6515         }
6516       return;
6517     }
6518
6519   if (init == error_mark_node)
6520     return;
6521
6522   if (TREE_CODE (type) == REFERENCE_TYPE
6523       && TREE_CODE (init) == CONSTRUCTOR)
6524     {
6525       cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6526       return;
6527     }
6528
6529   if (TREE_TYPE (init) && TREE_CODE (TREE_TYPE (init)) == UNKNOWN_TYPE)
6530     /* decay_conversion is probably wrong for references to functions.  */
6531     init = decay_conversion (instantiate_type (TREE_TYPE (type), init, 1));
6532
6533   if (TREE_CODE (init) == TREE_LIST)
6534     init = build_compound_expr (init);
6535
6536   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6537     init = convert_from_reference (init);
6538
6539   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6540       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6541     {
6542       /* Note: default conversion is only called in very special cases.  */
6543       init = default_conversion (init);
6544     }
6545
6546   tmp = convert_to_reference
6547     (type, init, CONV_IMPLICIT,
6548      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6549
6550   if (tmp == error_mark_node)
6551     goto fail;
6552   else if (tmp != NULL_TREE)
6553     {
6554       init = tmp;
6555       DECL_INITIAL (decl) = save_expr (init);
6556     }
6557   else
6558     {
6559       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6560       goto fail;
6561     }
6562
6563   /* ?? Can this be optimized in some cases to
6564      hand back the DECL_INITIAL slot??  */
6565   if (TYPE_SIZE (TREE_TYPE (type)))
6566     {
6567       init = convert_from_reference (decl);
6568       if (TREE_PERMANENT (decl))
6569         init = copy_to_permanent (init);
6570       SET_DECL_REFERENCE_SLOT (decl, init);
6571     }
6572
6573   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6574     {
6575       expand_static_init (decl, DECL_INITIAL (decl));
6576       DECL_INITIAL (decl) = NULL_TREE;
6577     }
6578   return;
6579
6580  fail:
6581   if (TREE_CODE (decl) == VAR_DECL)
6582     SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6583   return;
6584 }
6585
6586 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6587    mucking with forces it does not comprehend (i.e. initialization with a
6588    constructor).  If we are at global scope and won't go into COMMON, fill
6589    it in with a dummy CONSTRUCTOR to force the variable into .data;
6590    otherwise we can use error_mark_node.  */
6591
6592 static tree
6593 obscure_complex_init (decl, init)
6594      tree decl, init;
6595 {
6596   if (! flag_no_inline && TREE_STATIC (decl))
6597     {
6598       if (extract_init (decl, init))
6599         return NULL_TREE;
6600     }
6601
6602 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6603   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
6604     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
6605                                  NULL_TREE);
6606   else
6607 #endif
6608     DECL_INITIAL (decl) = error_mark_node;
6609
6610   return init;
6611 }
6612
6613 /* Finish processing of a declaration;
6614    install its line number and initial value.
6615    If the length of an array type is not known before,
6616    it must be determined now, from the initial value, or it is an error.
6617
6618    Call `pop_obstacks' iff NEED_POP is nonzero.
6619
6620    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
6621    for aggregates that have constructors alive on the permanent obstack,
6622    so that the global initializing functions can be written at the end.
6623
6624    INIT0 holds the value of an initializer that should be allowed to escape
6625    the normal rules.
6626
6627    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
6628    if the (init) syntax was used.
6629
6630    For functions that take default parameters, DECL points to its
6631    "maximal" instantiation.  `cp_finish_decl' must then also declared its
6632    subsequently lower and lower forms of instantiation, checking for
6633    ambiguity as it goes.  This can be sped up later.  */
6634
6635 void
6636 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
6637      tree decl, init;
6638      tree asmspec_tree;
6639      int need_pop;
6640      int flags;
6641 {
6642   register tree type;
6643   tree cleanup = NULL_TREE, ttype = NULL_TREE;
6644   int was_incomplete;
6645   int temporary = allocation_temporary_p ();
6646   char *asmspec = NULL;
6647   int was_readonly = 0;
6648   int already_used = 0;
6649
6650   /* If this is 0, then we did not change obstacks.  */
6651   if (! decl)
6652     {
6653       if (init)
6654         error ("assignment (not initialization) in declaration");
6655       return;
6656     }
6657
6658   /* If a name was specified, get the string.  */
6659   if (asmspec_tree)
6660       asmspec = TREE_STRING_POINTER (asmspec_tree);
6661
6662   if (init && TREE_CODE (init) == NAMESPACE_DECL)
6663     {
6664       cp_error ("Cannot initialize `%D' to namespace `%D'",
6665                 decl, init);
6666       init = NULL_TREE;
6667     }
6668
6669   /* If the type of the thing we are declaring either has
6670      a constructor, or has a virtual function table pointer,
6671      AND its initialization was accepted by `start_decl',
6672      then we stayed on the permanent obstack through the
6673      declaration, otherwise, changed obstacks as GCC would.  */
6674
6675   type = TREE_TYPE (decl);
6676
6677   if (type == error_mark_node)
6678     {
6679       if (toplevel_bindings_p () && temporary)
6680         end_temporary_allocation ();
6681
6682       return;
6683     }
6684
6685   if (processing_template_decl)
6686     {
6687       if (init && DECL_INITIAL (decl))
6688         DECL_INITIAL (decl) = init;
6689       if (minimal_parse_mode && ! DECL_ARTIFICIAL (decl))
6690         {
6691           tree stmt = DECL_VINDEX (decl);
6692           /* If the decl is declaring a member of a local class (in a
6693              template function), the DECL_VINDEX will either be NULL,
6694              or it will be an actual virtual function index, not a
6695              DECL_STMT.  */
6696           if (stmt != NULL_TREE && TREE_CODE (stmt) == DECL_STMT)
6697             {
6698               DECL_VINDEX (decl) = NULL_TREE;
6699               TREE_OPERAND (stmt, 2) = copy_to_permanent (init);
6700               add_tree (stmt);
6701             }
6702         }
6703
6704       goto finish_end0;
6705     }
6706   /* Take care of TYPE_DECLs up front.  */
6707   if (TREE_CODE (decl) == TYPE_DECL)
6708     {
6709       if (init && DECL_INITIAL (decl))
6710         {
6711           /* typedef foo = bar; store the type of bar as the type of foo.  */
6712           TREE_TYPE (decl) = type = TREE_TYPE (init);
6713           DECL_INITIAL (decl) = init = NULL_TREE;
6714         }
6715       if (type != error_mark_node
6716           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
6717         {
6718           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6719             cp_warning ("shadowing previous type declaration of `%#D'", decl);
6720           set_identifier_type_value (DECL_NAME (decl), type);
6721           CLASSTYPE_GOT_SEMICOLON (type) = 1;
6722         }
6723       GNU_xref_decl (current_function_decl, decl);
6724
6725       /* If we have installed this as the canonical typedef for this
6726          type, and that type has not been defined yet, delay emitting
6727          the debug information for it, as we will emit it later.  */
6728       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6729           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
6730         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6731
6732       rest_of_decl_compilation (decl, NULL_PTR,
6733                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
6734       goto finish_end;
6735     }
6736   if (TREE_CODE (decl) != FUNCTION_DECL)
6737     {
6738       ttype = target_type (type);
6739     }
6740
6741   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
6742       && TYPE_NEEDS_CONSTRUCTING (type))
6743     {
6744
6745       /* Currently, GNU C++ puts constants in text space, making them
6746          impossible to initialize.  In the future, one would hope for
6747          an operating system which understood the difference between
6748          initialization and the running of a program.  */
6749       was_readonly = 1;
6750       TREE_READONLY (decl) = 0;
6751     }
6752
6753   if (TREE_CODE (decl) == FIELD_DECL)
6754     {
6755       if (init && init != error_mark_node)
6756         my_friendly_assert (TREE_PERMANENT (init), 147);
6757
6758       if (asmspec)
6759         {
6760           /* This must override the asm specifier which was placed
6761              by grokclassfn.  Lay this out fresh.  */
6762           DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
6763           DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6764           make_decl_rtl (decl, asmspec, 0);
6765         }
6766     }
6767   /* If `start_decl' didn't like having an initialization, ignore it now.  */
6768   else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
6769     init = NULL_TREE;
6770   else if (DECL_EXTERNAL (decl))
6771     ;
6772   else if (TREE_CODE (type) == REFERENCE_TYPE
6773            || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
6774     {
6775       if (TREE_STATIC (decl))
6776         make_decl_rtl (decl, NULL_PTR,
6777                        toplevel_bindings_p ()
6778                        || pseudo_global_level_p ());
6779       grok_reference_init (decl, type, init);
6780       init = NULL_TREE;
6781     }
6782
6783   GNU_xref_decl (current_function_decl, decl);
6784
6785   if (TREE_CODE (decl) == FIELD_DECL)
6786     ;
6787   else if (TREE_CODE (decl) == CONST_DECL)
6788     {
6789       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
6790
6791       DECL_INITIAL (decl) = init;
6792
6793       /* This will keep us from needing to worry about our obstacks.  */
6794       my_friendly_assert (init != NULL_TREE, 149);
6795       init = NULL_TREE;
6796     }
6797   else if (init)
6798     {
6799       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
6800         {
6801           if (TREE_CODE (type) == ARRAY_TYPE)
6802             init = digest_init (type, init, (tree *) 0);
6803           else if (TREE_CODE (init) == CONSTRUCTOR)
6804             {
6805               if (TYPE_NON_AGGREGATE_CLASS (type))
6806                 {
6807                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
6808                             decl);
6809                   init = error_mark_node;
6810                 }
6811               else
6812                 goto dont_use_constructor;
6813             }
6814         }
6815       else
6816         {
6817         dont_use_constructor:
6818           if (TREE_CODE (init) != TREE_VEC)
6819             init = store_init_value (decl, init);
6820         }
6821
6822       if (init)
6823         /* We must hide the initializer so that expand_decl
6824            won't try to do something it does not understand.  */
6825         init = obscure_complex_init (decl, init);
6826     }
6827   else if (DECL_EXTERNAL (decl))
6828     ;
6829   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
6830            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
6831     {
6832       tree ctype = type;
6833       while (TREE_CODE (ctype) == ARRAY_TYPE)
6834         ctype = TREE_TYPE (ctype);
6835       if (! TYPE_NEEDS_CONSTRUCTING (ctype))
6836         {
6837           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
6838             cp_error ("structure `%D' with uninitialized const members", decl);
6839           if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
6840             cp_error ("structure `%D' with uninitialized reference members",
6841                       decl);
6842         }
6843
6844       if (TREE_CODE (decl) == VAR_DECL
6845           && !DECL_INITIAL (decl)
6846           && !TYPE_NEEDS_CONSTRUCTING (type)
6847           && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6848         cp_error ("uninitialized const `%D'", decl);
6849
6850       if (TYPE_SIZE (type) != NULL_TREE
6851           && TYPE_NEEDS_CONSTRUCTING (type))
6852         init = obscure_complex_init (decl, NULL_TREE);
6853     }
6854   else if (TREE_CODE (decl) == VAR_DECL
6855            && TREE_CODE (type) != REFERENCE_TYPE
6856            && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6857     {
6858       /* ``Unless explicitly declared extern, a const object does not have
6859          external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
6860          However, if it's `const int foo = 1; const int foo;', don't complain
6861          about the second decl, since it does have an initializer before.
6862          We deliberately don't complain about arrays, because they're
6863          supposed to be initialized by a constructor.  */
6864       if (! DECL_INITIAL (decl)
6865           && TREE_CODE (type) != ARRAY_TYPE
6866           && (!pedantic || !current_class_type))
6867         cp_error ("uninitialized const `%#D'", decl);
6868     }
6869
6870   /* For top-level declaration, the initial value was read in
6871      the temporary obstack.  MAXINDEX, rtl, etc. to be made below
6872      must go in the permanent obstack; but don't discard the
6873      temporary data yet.  */
6874
6875   if (toplevel_bindings_p () && temporary)
6876     end_temporary_allocation ();
6877
6878   /* Deduce size of array from initialization, if not already known.  */
6879
6880   if (TREE_CODE (type) == ARRAY_TYPE
6881       && TYPE_DOMAIN (type) == NULL_TREE
6882       && TREE_CODE (decl) != TYPE_DECL)
6883     {
6884       int do_default
6885         = (TREE_STATIC (decl)
6886            /* Even if pedantic, an external linkage array
6887               may have incomplete type at first.  */
6888            ? pedantic && ! DECL_EXTERNAL (decl)
6889            : !DECL_EXTERNAL (decl));
6890       tree initializer = init ? init : DECL_INITIAL (decl);
6891       int failure = complete_array_type (type, initializer, do_default);
6892
6893       if (failure == 1)
6894         cp_error ("initializer fails to determine size of `%D'", decl);
6895
6896       if (failure == 2)
6897         {
6898           if (do_default)
6899             cp_error ("array size missing in `%D'", decl);
6900           /* If a `static' var's size isn't known, make it extern as
6901              well as static, so it does not get allocated.  If it's not
6902              `static', then don't mark it extern; finish_incomplete_decl
6903              will give it a default size and it will get allocated.  */
6904           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
6905             DECL_EXTERNAL (decl) = 1;
6906         }
6907
6908       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
6909           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
6910                               integer_zero_node))
6911         cp_error ("zero-size array `%D'", decl);
6912
6913       layout_decl (decl, 0);
6914     }
6915
6916   if (TREE_CODE (decl) == VAR_DECL)
6917     {
6918       if (DECL_SIZE (decl) == NULL_TREE
6919           && TYPE_SIZE (complete_type (TREE_TYPE (decl))) != NULL_TREE)
6920         layout_decl (decl, 0);
6921
6922       if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
6923         {
6924           /* A static variable with an incomplete type:
6925              that is an error if it is initialized.
6926              Otherwise, let it through, but if it is not `extern'
6927              then it may cause an error message later.  */
6928           if (DECL_INITIAL (decl) != NULL_TREE)
6929             cp_error ("storage size of `%D' isn't known", decl);
6930           init = NULL_TREE;
6931         }
6932       else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
6933         {
6934           /* An automatic variable with an incomplete type: that is an error.
6935              Don't talk about array types here, since we took care of that
6936              message in grokdeclarator.  */
6937           cp_error ("storage size of `%D' isn't known", decl);
6938           TREE_TYPE (decl) = error_mark_node;
6939         }
6940       else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
6941         /* Let debugger know it should output info for this type.  */
6942         note_debug_info_needed (ttype);
6943
6944       if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
6945         note_debug_info_needed (DECL_CONTEXT (decl));
6946
6947       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
6948           && DECL_SIZE (decl) != NULL_TREE
6949           && ! TREE_CONSTANT (DECL_SIZE (decl)))
6950         {
6951           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
6952             constant_expression_warning (DECL_SIZE (decl));
6953           else
6954             cp_error ("storage size of `%D' isn't constant", decl);
6955         }
6956
6957       if (! DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type)
6958           /* Cleanups for static variables are handled by `finish_file'.  */
6959           && ! TREE_STATIC (decl))
6960         {
6961           int yes = suspend_momentary ();
6962           cleanup = maybe_build_cleanup (decl);
6963           resume_momentary (yes);
6964         }
6965     }
6966   /* PARM_DECLs get cleanups, too.  */
6967   else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
6968     {
6969       if (temporary)
6970         end_temporary_allocation ();
6971       cleanup = maybe_build_cleanup (decl);
6972       if (temporary)
6973         resume_temporary_allocation ();
6974     }
6975
6976   /* Output the assembler code and/or RTL code for variables and functions,
6977      unless the type is an undefined structure or union.
6978      If not, it will get done when the type is completed.  */
6979
6980   was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
6981
6982   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
6983       || TREE_CODE (decl) == RESULT_DECL)
6984     {
6985       /* ??? FIXME: What about nested classes?  */
6986       int toplev = toplevel_bindings_p () || pseudo_global_level_p ();
6987       int was_temp
6988         = (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)
6989            && allocation_temporary_p ());
6990
6991       if (was_temp)
6992         end_temporary_allocation ();
6993
6994       /* Extern inline function static data has external linkage.
6995          Instead of trying to deal with that, we disable inlining of
6996          such functions.  The ASM_WRITTEN check is to avoid hitting this
6997          for __FUNCTION__.  */
6998       if (TREE_CODE (decl) == VAR_DECL
6999           && TREE_STATIC (decl)
7000           && ! TREE_ASM_WRITTEN (decl)
7001           && current_function_decl
7002           && DECL_CONTEXT (decl) == current_function_decl
7003           && DECL_THIS_INLINE (current_function_decl)
7004           && TREE_PUBLIC (current_function_decl))
7005         {
7006           current_function_cannot_inline
7007             = "function with static variable cannot be inline";
7008         }
7009
7010       else if (TREE_CODE (decl) == VAR_DECL
7011                && DECL_LANG_SPECIFIC (decl)
7012                && DECL_COMDAT (decl))
7013         {
7014           /* Dynamically initialized vars go into common.  */
7015           if (DECL_INITIAL (decl) == NULL_TREE
7016               || DECL_INITIAL (decl) == error_mark_node)
7017             DECL_COMMON (decl) = 1;
7018           else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7019             {
7020               DECL_COMMON (decl) = 1;
7021               DECL_INITIAL (decl) = error_mark_node;
7022             }
7023           else
7024             {
7025               /* Statically initialized vars are weak or comdat, if
7026                  supported.  */
7027               if (flag_weak)
7028                 make_decl_one_only (decl);
7029               else
7030                 {
7031                   /* We can't do anything useful; leave vars for explicit
7032                      instantiation.  */
7033                   DECL_EXTERNAL (decl) = 1;
7034                   DECL_NOT_REALLY_EXTERN (decl) = 0;
7035                 }
7036             }
7037         }
7038
7039       if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
7040         make_decl_rtl (decl, NULL_PTR, toplev);
7041       else if (TREE_CODE (decl) == VAR_DECL
7042                && TREE_READONLY (decl)
7043                && DECL_INITIAL (decl) != NULL_TREE
7044                && DECL_INITIAL (decl) != error_mark_node
7045                && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7046         {
7047           DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7048
7049           if (asmspec)
7050             DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7051
7052           if (! toplev
7053               && TREE_STATIC (decl)
7054               && ! TREE_SIDE_EFFECTS (decl)
7055               && ! TREE_PUBLIC (decl)
7056               && ! DECL_EXTERNAL (decl)
7057               && ! TYPE_NEEDS_DESTRUCTOR (type)
7058               && DECL_MODE (decl) != BLKmode)
7059             {
7060               /* If this variable is really a constant, then fill its DECL_RTL
7061                  slot with something which won't take up storage.
7062                  If something later should take its address, we can always give
7063                  it legitimate RTL at that time.  */
7064               DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
7065               store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
7066               TREE_ASM_WRITTEN (decl) = 1;
7067             }
7068           else if (toplev && ! TREE_PUBLIC (decl))
7069             {
7070               /* If this is a static const, change its apparent linkage
7071                  if it belongs to a #pragma interface.  */
7072               if (!interface_unknown)
7073                 {
7074                   TREE_PUBLIC (decl) = 1;
7075                   DECL_EXTERNAL (decl) = interface_only;
7076                 }
7077               make_decl_rtl (decl, asmspec, toplev);
7078             }
7079           else
7080             rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7081         }
7082       else if (TREE_CODE (decl) == VAR_DECL
7083                && DECL_LANG_SPECIFIC (decl)
7084                && DECL_IN_AGGR_P (decl))
7085         {
7086           if (TREE_STATIC (decl))
7087             {
7088               if (init == NULL_TREE
7089 #ifdef DEFAULT_STATIC_DEFS
7090                   /* If this code is dead, then users must
7091                      explicitly declare static member variables
7092                      outside the class def'n as well.  */
7093                   && TYPE_NEEDS_CONSTRUCTING (type)
7094 #endif
7095                   )
7096                 {
7097                   DECL_EXTERNAL (decl) = 1;
7098                   make_decl_rtl (decl, asmspec, 1);
7099                 }
7100               else
7101                 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7102             }
7103           else
7104             /* Just a constant field.  Should not need any rtl.  */
7105             goto finish_end0;
7106         }
7107       else
7108         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7109
7110       if (was_temp)
7111         resume_temporary_allocation ();
7112
7113       if (type != error_mark_node
7114           && TYPE_LANG_SPECIFIC (type)
7115           && CLASSTYPE_ABSTRACT_VIRTUALS (type))
7116         abstract_virtuals_error (decl, type);
7117       else if ((TREE_CODE (type) == FUNCTION_TYPE
7118                 || TREE_CODE (type) == METHOD_TYPE)
7119                && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7120                && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
7121         abstract_virtuals_error (decl, TREE_TYPE (type));
7122
7123       if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
7124         signature_error (decl, type);
7125       else if ((TREE_CODE (type) == FUNCTION_TYPE
7126                 || TREE_CODE (type) == METHOD_TYPE)
7127                && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7128                && IS_SIGNATURE (TREE_TYPE (type)))
7129         signature_error (decl, TREE_TYPE (type));
7130
7131       if (TREE_CODE (decl) == FUNCTION_DECL)
7132         ;
7133       else if (DECL_EXTERNAL (decl)
7134                && ! (DECL_LANG_SPECIFIC (decl)
7135                      && DECL_NOT_REALLY_EXTERN (decl)))
7136         {
7137           if (init)
7138             DECL_INITIAL (decl) = init;
7139         }
7140       else if (TREE_STATIC (decl) && type != error_mark_node)
7141         {
7142           /* Cleanups for static variables are handled by `finish_file'.  */
7143           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7144               || TYPE_NEEDS_DESTRUCTOR (type))
7145             expand_static_init (decl, init);
7146         }
7147       else if (! toplev)
7148         {
7149           /* This is a declared decl which must live until the
7150              end of the binding contour.  It may need a cleanup.  */
7151
7152           /* Recompute the RTL of a local array now
7153              if it used to be an incomplete type.  */
7154           if (was_incomplete && ! TREE_STATIC (decl))
7155             {
7156               /* If we used it already as memory, it must stay in memory.  */
7157               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7158               /* If it's still incomplete now, no init will save it.  */
7159               if (DECL_SIZE (decl) == NULL_TREE)
7160                 DECL_INITIAL (decl) = NULL_TREE;
7161               expand_decl (decl);
7162             }
7163           else if (! TREE_ASM_WRITTEN (decl)
7164                    && (TYPE_SIZE (type) != NULL_TREE
7165                        || TREE_CODE (type) == ARRAY_TYPE))
7166             {
7167               /* Do this here, because we did not expand this decl's
7168                  rtl in start_decl.  */
7169               if (DECL_RTL (decl) == NULL_RTX)
7170                 expand_decl (decl);
7171               else if (cleanup)
7172                 {
7173                   /* XXX: Why don't we use decl here?  */
7174                   /* Ans: Because it was already expanded? */
7175                   if (! expand_decl_cleanup (NULL_TREE, cleanup))
7176                     cp_error ("parser lost in parsing declaration of `%D'",
7177                               decl);
7178                   /* Cleanup used up here.  */
7179                   cleanup = NULL_TREE;
7180                 }
7181             }
7182
7183           if (current_binding_level->is_for_scope)
7184             {
7185               struct binding_level *outer = current_binding_level->level_chain;
7186
7187               /* Check to see if the same name is already bound at
7188                  the outer level, either because it was directly declared,
7189                  or because a dead for-decl got preserved.  In either case,
7190                  the code would not have been valid under the ARM
7191                  scope rules, so clear is_for_scope for the
7192                  current_binding_level.
7193
7194                  Otherwise, we need to preserve the temp slot for decl
7195                  to last into the outer binding level.  */
7196
7197               int handling_dead_for_vars = 0;
7198               tree link = outer->names;
7199               for (; ; link = TREE_CHAIN (link))
7200                 {
7201                   if (link == NULL && handling_dead_for_vars == 0)
7202                     {
7203                       link = outer->dead_vars_from_for;
7204                       handling_dead_for_vars = 1;
7205                     }
7206                   if (link == NULL)
7207                     {
7208                       if (DECL_IN_MEMORY_P (decl))
7209                         preserve_temp_slots (DECL_RTL (decl));
7210                       break;
7211                     }
7212                   if (DECL_NAME (link) == DECL_NAME (decl))
7213                     {
7214                       if (handling_dead_for_vars)
7215                         {
7216                           tree shadowing
7217                             = purpose_member (DECL_NAME (decl),
7218                                               current_binding_level->shadowed);
7219                           if (shadowing && TREE_VALUE (shadowing) == link)
7220                             TREE_VALUE (shadowing)
7221                               = DECL_SHADOWED_FOR_VAR (link);
7222                         }
7223                       current_binding_level->is_for_scope = 0;
7224                       break;
7225                     }
7226                 }
7227             }
7228
7229           expand_start_target_temps ();
7230
7231           if (DECL_SIZE (decl) && type != error_mark_node)
7232             {
7233               /* Compute and store the initial value.  */
7234               expand_decl_init (decl);
7235               already_used = TREE_USED (decl) || TREE_USED (type);
7236
7237               if (init || TYPE_NEEDS_CONSTRUCTING (type))
7238                 {
7239                   emit_line_note (DECL_SOURCE_FILE (decl),
7240                                   DECL_SOURCE_LINE (decl));
7241                   expand_aggr_init (decl, init, 0, flags);
7242                 }
7243
7244               /* Set this to 0 so we can tell whether an aggregate which
7245                  was initialized was ever used.  Don't do this if it has a
7246                  destructor, so we don't complain about the 'resource
7247                  allocation is initialization' idiom.  */
7248               /* Now set attribute((unused)) on types so decls of
7249                  that type will be marked used. (see TREE_USED, above.)
7250                  This avoids the warning problems this particular code
7251                  tried to work around. */
7252
7253               if (TYPE_NEEDS_CONSTRUCTING (type)
7254                   && ! already_used
7255                   && cleanup == NULL_TREE
7256                   && DECL_NAME (decl))
7257                 TREE_USED (decl) = 0;
7258
7259               if (already_used)
7260                 TREE_USED (decl) = 1;
7261             }
7262
7263           /* Cleanup any temporaries needed for the initial value.  */
7264           expand_end_target_temps ();
7265
7266           if (DECL_SIZE (decl) && type != error_mark_node)
7267             {
7268               /* Store the cleanup, if there was one.  */
7269               if (cleanup)
7270                 {
7271                   if (! expand_decl_cleanup (decl, cleanup))
7272                     cp_error ("parser lost in parsing declaration of `%D'",
7273                               decl);
7274                 }
7275             }
7276         }
7277     finish_end0:
7278
7279       /* Undo call to `pushclass' that was done in `start_decl'
7280          due to initialization of qualified member variable.
7281          I.e., Foo::x = 10;  */
7282       {
7283         tree context = DECL_REAL_CONTEXT (decl);
7284         if (context
7285             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7286             && (TREE_CODE (decl) == VAR_DECL
7287                 /* We also have a pushclass done that we need to undo here
7288                    if we're at top level and declare a method.  */
7289                 || TREE_CODE (decl) == FUNCTION_DECL)
7290             /* If size hasn't been set, we're still defining it,
7291                and therefore inside the class body; don't pop
7292                the binding level..  */
7293             && TYPE_SIZE (context) != NULL_TREE
7294             && context == current_class_type)
7295           popclass (1);
7296       }
7297     }
7298
7299  finish_end:
7300
7301   /* If requested, warn about definitions of large data objects.  */
7302
7303   if (warn_larger_than
7304       && ! processing_template_decl
7305       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7306       && !DECL_EXTERNAL (decl))
7307     {
7308       register tree decl_size = DECL_SIZE (decl);
7309
7310       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7311         {
7312           unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7313
7314           if (units > larger_than_size)
7315             warning_with_decl (decl, "size of `%s' is %u bytes", units);
7316         }
7317     }
7318
7319   if (need_pop)
7320     {
7321       /* Resume permanent allocation, if not within a function.  */
7322       /* The corresponding push_obstacks_nochange is in start_decl,
7323          start_method, groktypename, and in grokfield.  */
7324       pop_obstacks ();
7325     }
7326
7327   if (was_readonly)
7328     TREE_READONLY (decl) = 1;
7329 }
7330
7331 /* This is here for a midend callback from c-common.c */
7332
7333 void
7334 finish_decl (decl, init, asmspec_tree)
7335      tree decl, init;
7336      tree asmspec_tree;
7337 {
7338   cp_finish_decl (decl, init, asmspec_tree, 1, 0);
7339 }
7340
7341 void
7342 expand_static_init (decl, init)
7343      tree decl;
7344      tree init;
7345 {
7346   tree oldstatic = value_member (decl, static_aggregates);
7347
7348   if (oldstatic)
7349     {
7350       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
7351         cp_error ("multiple initializations given for `%D'", decl);
7352     }
7353   else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7354     {
7355       /* Emit code to perform this initialization but once.  */
7356       tree temp;
7357
7358       /* Remember this information until end of file.  */
7359       push_obstacks (&permanent_obstack, &permanent_obstack);
7360
7361       /* Emit code to perform this initialization but once.  */
7362       temp = get_temp_name (integer_type_node, 1);
7363       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
7364       expand_start_cond (build_binary_op (EQ_EXPR, temp,
7365                                           integer_zero_node, 1), 0);
7366       expand_start_target_temps ();
7367
7368       expand_assignment (temp, integer_one_node, 0, 0);
7369       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
7370           || (init && TREE_CODE (init) == TREE_LIST))
7371         {
7372           expand_aggr_init (decl, init, 0, 0);
7373           do_pending_stack_adjust ();
7374         }
7375       else if (init)
7376         expand_assignment (decl, init, 0, 0);
7377
7378       /* Cleanup any temporaries needed for the initial value.  */
7379       expand_end_target_temps ();
7380
7381       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7382         {
7383           tree cleanup, fcall;
7384           static tree Atexit = 0;
7385           if (Atexit == 0)
7386             {
7387               tree atexit_fndecl, PFV, pfvlist;
7388               /* Remember this information until end of file.  */
7389               push_obstacks (&permanent_obstack, &permanent_obstack);
7390               PFV = build_pointer_type (build_function_type
7391                                         (void_type_node, void_list_node));
7392
7393               pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
7394
7395               push_lang_context (lang_name_c);
7396               atexit_fndecl
7397                 = builtin_function ("atexit",
7398                                     build_function_type (void_type_node,
7399                                                          pfvlist),
7400                                     NOT_BUILT_IN, NULL_PTR);
7401               assemble_external (atexit_fndecl);
7402               Atexit = default_conversion (atexit_fndecl);
7403               pop_lang_context ();
7404               pop_obstacks ();
7405             }
7406
7407           cleanup = start_anon_func ();
7408           expand_expr_stmt (build_cleanup (decl));
7409           end_anon_func ();
7410           mark_addressable (cleanup);
7411           cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
7412           fcall = build_function_call (Atexit, expr_tree_cons (NULL_TREE, cleanup, NULL_TREE));
7413           expand_expr_stmt (fcall);
7414         }
7415
7416       expand_end_cond ();
7417       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7418         {
7419           static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
7420           TREE_STATIC (static_aggregates) = 1;
7421         }
7422
7423       /* Resume old (possibly temporary) allocation.  */
7424       pop_obstacks ();
7425     }
7426   else
7427     {
7428       /* This code takes into account memory allocation
7429          policy of `start_decl'.  Namely, if TYPE_NEEDS_CONSTRUCTING
7430          does not hold for this object, then we must make permanent
7431          the storage currently in the temporary obstack.  */
7432       if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
7433         preserve_initializer ();
7434       static_aggregates = perm_tree_cons (init, decl, static_aggregates);
7435     }
7436 }
7437 \f
7438 /* Make TYPE a complete type based on INITIAL_VALUE.
7439    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7440    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
7441
7442 int
7443 complete_array_type (type, initial_value, do_default)
7444      tree type, initial_value;
7445      int do_default;
7446 {
7447   register tree maxindex = NULL_TREE;
7448   int value = 0;
7449
7450   if (initial_value)
7451     {
7452       /* Note MAXINDEX  is really the maximum index,
7453          one less than the size.  */
7454       if (TREE_CODE (initial_value) == STRING_CST)
7455         {
7456           int eltsize
7457             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7458           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
7459                                    / eltsize) - 1, 0);
7460         }
7461       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7462         {
7463           tree elts = CONSTRUCTOR_ELTS (initial_value);
7464           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
7465           for (; elts; elts = TREE_CHAIN (elts))
7466             {
7467               if (TREE_PURPOSE (elts))
7468                 maxindex = TREE_PURPOSE (elts);
7469               else
7470                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
7471             }
7472           maxindex = copy_node (maxindex);
7473         }
7474       else
7475         {
7476           /* Make an error message unless that happened already.  */
7477           if (initial_value != error_mark_node)
7478             value = 1;
7479
7480           /* Prevent further error messages.  */
7481           maxindex = build_int_2 (0, 0);
7482         }
7483     }
7484
7485   if (!maxindex)
7486     {
7487       if (do_default)
7488         maxindex = build_int_2 (0, 0);
7489       value = 2;
7490     }
7491
7492   if (maxindex)
7493     {
7494       tree itype;
7495
7496       TYPE_DOMAIN (type) = build_index_type (maxindex);
7497       if (! TREE_TYPE (maxindex))
7498         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
7499       if (initial_value)
7500         itype = TREE_TYPE (initial_value);
7501       else
7502         itype = NULL;
7503       if (itype && !TYPE_DOMAIN (itype))
7504         TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
7505       /* The type of the main variant should never be used for arrays
7506          of different sizes.  It should only ever be completed with the
7507          size of the array.  */
7508       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
7509         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = TYPE_DOMAIN (type);
7510     }
7511
7512   /* Lay out the type now that we can get the real answer.  */
7513
7514   layout_type (type);
7515
7516   return value;
7517 }
7518 \f
7519 /* Return zero if something is declared to be a member of type
7520    CTYPE when in the context of CUR_TYPE.  STRING is the error
7521    message to print in that case.  Otherwise, quietly return 1.  */
7522
7523 static int
7524 member_function_or_else (ctype, cur_type, string)
7525      tree ctype, cur_type;
7526      char *string;
7527 {
7528   if (ctype && ctype != cur_type)
7529     {
7530       error (string, TYPE_NAME_STRING (ctype));
7531       return 0;
7532     }
7533   return 1;
7534 }
7535 \f
7536 /* Subroutine of `grokdeclarator'.  */
7537
7538 /* Generate errors possibly applicable for a given set of specifiers.
7539    This is for ARM $7.1.2.  */
7540
7541 static void
7542 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
7543      tree object;
7544      char *type;
7545      int virtualp, quals, friendp, raises, inlinep;
7546 {
7547   if (virtualp)
7548     cp_error ("`%D' declared as a `virtual' %s", object, type);
7549   if (inlinep)
7550     cp_error ("`%D' declared as an `inline' %s", object, type);
7551   if (quals)
7552     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7553               object, type);
7554   if (friendp)
7555     cp_error_at ("invalid friend declaration", object);
7556   if (raises)
7557     cp_error_at ("invalid exception specifications", object);
7558 }
7559
7560 /* CTYPE is class type, or null if non-class.
7561    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7562    or METHOD_TYPE.
7563    DECLARATOR is the function's name.
7564    VIRTUALP is truthvalue of whether the function is virtual or not.
7565    FLAGS are to be passed through to `grokclassfn'.
7566    QUALS are qualifiers indicating whether the function is `const'
7567    or `volatile'.
7568    RAISES is a list of exceptions that this function can raise.
7569    CHECK is 1 if we must find this method in CTYPE, 0 if we should
7570    not look, and -1 if we should not call `grokclassfn' at all.  */
7571
7572 static tree
7573 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
7574             raises, attrlist, check, friendp, publicp, inlinep, funcdef_flag,
7575             template_count, in_namespace)
7576      tree ctype, type;
7577      tree declarator;
7578      tree orig_declarator;
7579      int virtualp;
7580      enum overload_flags flags;
7581      tree quals, raises, attrlist;
7582      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
7583      tree in_namespace;
7584 {
7585   tree cname, decl;
7586   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7587   tree t;
7588
7589   if (ctype)
7590     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
7591       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
7592   else
7593     cname = NULL_TREE;
7594
7595   if (raises)
7596     {
7597       type = build_exception_variant (type, raises);
7598     }
7599
7600   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7601   /* Propagate volatile out from type to decl. */
7602   if (TYPE_VOLATILE (type))
7603     TREE_THIS_VOLATILE (decl) = 1;
7604
7605   /* This decl is not from the current namespace. */
7606   if (in_namespace)
7607     set_decl_namespace (decl, in_namespace);
7608
7609   /* Should probably propagate const out from type to decl I bet (mrs).  */
7610   if (staticp)
7611     {
7612       DECL_STATIC_FUNCTION_P (decl) = 1;
7613       DECL_CONTEXT (decl) = ctype;
7614     }
7615
7616   if (ctype)
7617     DECL_CLASS_CONTEXT (decl) = ctype;
7618
7619   if (ctype == NULL_TREE && MAIN_NAME_P (declarator))
7620     {
7621       if (inlinep)
7622         error ("cannot declare `main' to be inline");
7623       else if (! publicp)
7624         error ("cannot declare `main' to be static");
7625       inlinep = 0;
7626       publicp = 1;
7627     }
7628
7629   TREE_PUBLIC (decl) = publicp;
7630   if (! publicp)
7631     {
7632       DECL_INTERFACE_KNOWN (decl) = 1;
7633       DECL_NOT_REALLY_EXTERN (decl) = 1;
7634     }
7635
7636   if (inlinep)
7637     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
7638
7639   DECL_EXTERNAL (decl) = 1;
7640   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
7641     {
7642       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
7643                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
7644       quals = NULL_TREE;
7645     }
7646
7647   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
7648     grok_op_properties (decl, virtualp, check < 0);
7649
7650   if (ctype && hack_decl_function_context (decl))
7651     DECL_NO_STATIC_CHAIN (decl) = 1;
7652
7653   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7654     if (TREE_PURPOSE (t)
7655         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7656       {
7657         add_defarg_fn (decl);
7658         break;
7659       }
7660
7661   if (friendp
7662       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7663     {
7664       if (funcdef_flag)
7665         cp_error
7666           ("defining explicit specialization `%D' in friend declaration",
7667            orig_declarator);
7668       else
7669         {
7670           /* A friend declaration of the form friend void f<>().  Record
7671              the information in the TEMPLATE_ID_EXPR.  */
7672           SET_DECL_IMPLICIT_INSTANTIATION (decl);
7673           DECL_TEMPLATE_INFO (decl)
7674             = perm_tree_cons (TREE_OPERAND (orig_declarator, 0),
7675                               TREE_OPERAND (orig_declarator, 1),
7676                               NULL_TREE);
7677         }
7678     }
7679
7680   /* Caller will do the rest of this.  */
7681   if (check < 0)
7682     return decl;
7683
7684   if (check && funcdef_flag)
7685     DECL_INITIAL (decl) = error_mark_node;
7686
7687   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
7688     {
7689       tree tmp;
7690       /* Just handle constructors here.  We could do this
7691          inside the following if stmt, but I think
7692          that the code is more legible by breaking this
7693          case out.  See comments below for what each of
7694          the following calls is supposed to do.  */
7695       DECL_CONSTRUCTOR_P (decl) = 1;
7696
7697       grokclassfn (ctype, declarator, decl, flags, quals);
7698
7699       decl = check_explicit_specialization (orig_declarator, decl,
7700                                             template_count,
7701                                             2 * (funcdef_flag != 0) +
7702                                             4 * (friendp != 0));
7703
7704       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (ctype, decl))
7705           && check)
7706         {
7707           tmp = check_classfn (ctype, decl);
7708
7709           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
7710             tmp = DECL_TEMPLATE_RESULT(tmp);
7711
7712           if (tmp && DECL_ARTIFICIAL (tmp))
7713             cp_error ("definition of implicitly-declared `%D'", tmp);
7714           if (tmp && duplicate_decls (decl, tmp))
7715             return tmp;
7716         }
7717       if (! grok_ctor_properties (ctype, decl))
7718         return NULL_TREE;
7719
7720       if (check == 0 && ! current_function_decl)
7721         {
7722           /* Assembler names live in the global namespace. */
7723           tmp = IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl));
7724           if (tmp == NULL_TREE)
7725             SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
7726           else if (TREE_CODE (tmp) != TREE_CODE (decl))
7727             cp_error ("inconsistent declarations for `%D'", decl);
7728           else
7729             {
7730               duplicate_decls (decl, tmp);
7731               decl = tmp;
7732             }
7733           make_decl_rtl (decl, NULL_PTR, 1);
7734         }
7735     }
7736   else
7737     {
7738       tree tmp;
7739
7740       /* Function gets the ugly name, field gets the nice one.
7741          This call may change the type of the function (because
7742          of default parameters)!  */
7743       if (ctype != NULL_TREE)
7744         grokclassfn (ctype, cname, decl, flags, quals);
7745
7746       decl = check_explicit_specialization (orig_declarator, decl,
7747                                             template_count,
7748                                             2 * (funcdef_flag != 0) +
7749                                             4 * (friendp != 0));
7750       if (ctype != NULL_TREE
7751           && (! TYPE_FOR_JAVA (ctype) || check_java_method (ctype, decl))
7752           && check)
7753         {
7754           tmp = check_classfn (ctype, decl);
7755
7756           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
7757             tmp = DECL_TEMPLATE_RESULT (tmp);
7758
7759           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
7760               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7761             {
7762               /* Remove the `this' parm added by grokclassfn.
7763                  XXX Isn't this done in start_function, too?  */
7764               revert_static_member_fn (&decl, NULL, NULL);
7765               last_function_parms = TREE_CHAIN (last_function_parms);
7766             }
7767           if (tmp && DECL_ARTIFICIAL (tmp))
7768             cp_error ("definition of implicitly-declared `%D'", tmp);
7769           if (tmp)
7770             {
7771               if (!duplicate_decls (decl, tmp))
7772                 my_friendly_abort (892);
7773               return tmp;
7774             }
7775         }
7776
7777       if (ctype == NULL_TREE || check)
7778         return decl;
7779
7780       /* Now install the declaration of this function so that others may
7781          find it (esp. its DECL_FRIENDLIST).  Don't do this for local class
7782          methods, though.  */
7783       if (! current_function_decl)
7784         {
7785           if (!DECL_TEMPLATE_SPECIALIZATION (decl))
7786             {
7787               /* We don't do this for specializations since the
7788                  equivalent checks will be done later.  Also, at this
7789                  point the DECL_ASSEMBLER_NAME is not yet fully
7790                  accurate.  */
7791
7792               /* FIXME: this should only need to look at
7793                  IDENTIFIER_GLOBAL_VALUE.  */
7794               tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
7795               if (tmp == NULL_TREE)
7796                 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
7797               else if (TREE_CODE (tmp) != TREE_CODE (decl))
7798                 cp_error ("inconsistent declarations for `%D'", decl);
7799               else
7800                 {
7801                   duplicate_decls (decl, tmp);
7802                   decl = tmp;
7803                 }
7804             }
7805
7806           if (attrlist)
7807             cplus_decl_attributes (decl, TREE_PURPOSE (attrlist),
7808                                    TREE_VALUE (attrlist));
7809           make_decl_rtl (decl, NULL_PTR, 1);
7810         }
7811       if (virtualp)
7812         {
7813           DECL_VIRTUAL_P (decl) = 1;
7814           if (DECL_VINDEX (decl) == NULL_TREE)
7815             DECL_VINDEX (decl) = error_mark_node;
7816           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
7817         }
7818     }
7819   return decl;
7820 }
7821
7822 static tree
7823 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
7824      tree type;
7825      tree declarator;
7826      RID_BIT_TYPE *specbits_in;
7827      int initialized;
7828      int constp;
7829      tree in_namespace;
7830 {
7831   tree decl;
7832   RID_BIT_TYPE specbits;
7833
7834   specbits = *specbits_in;
7835
7836   if (TREE_CODE (type) == OFFSET_TYPE)
7837     {
7838       /* If you declare a static member so that it
7839          can be initialized, the code will reach here.  */
7840       tree basetype = TYPE_OFFSET_BASETYPE (type);
7841       type = TREE_TYPE (type);
7842       decl = build_lang_field_decl (VAR_DECL, declarator, type);
7843       DECL_CONTEXT (decl) = basetype;
7844       DECL_CLASS_CONTEXT (decl) = basetype;
7845       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
7846     }
7847   else
7848     {
7849       tree context = in_namespace ? in_namespace : current_namespace;
7850       decl = build_decl (VAR_DECL, declarator, complete_type (type));
7851       if (context != global_namespace)
7852         DECL_ASSEMBLER_NAME (decl) =  build_static_name (context,
7853                                                          declarator);
7854     }
7855
7856   if (in_namespace)
7857     set_decl_namespace (decl, in_namespace);
7858
7859   if (RIDBIT_SETP (RID_EXTERN, specbits))
7860     {
7861       DECL_THIS_EXTERN (decl) = 1;
7862       DECL_EXTERNAL (decl) = !initialized;
7863     }
7864
7865   /* In class context, static means one per class,
7866      public access, and static storage.  */
7867   if (DECL_FIELD_CONTEXT (decl) != NULL_TREE
7868       && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl)))
7869     {
7870       TREE_PUBLIC (decl) = 1;
7871       TREE_STATIC (decl) = 1;
7872       DECL_EXTERNAL (decl) = 0;
7873     }
7874   /* At top level, either `static' or no s.c. makes a definition
7875      (perhaps tentative), and absence of `static' makes it public.  */
7876   else if (toplevel_bindings_p ())
7877     {
7878       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
7879                             && (DECL_THIS_EXTERN (decl) || ! constp));
7880       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7881     }
7882   /* Not at top level, only `static' makes a static definition.  */
7883   else
7884     {
7885       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
7886       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7887     }
7888   return decl;
7889 }
7890
7891 /* Create a canonical pointer to member function type.  */
7892
7893 tree
7894 build_ptrmemfunc_type (type)
7895      tree type;
7896 {
7897   tree fields[4];
7898   tree t;
7899   tree u;
7900
7901   /* If a canonical type already exists for this type, use it.  We use
7902      this method instead of type_hash_canon, because it only does a
7903      simple equality check on the list of field members.  */
7904
7905   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7906     return t;
7907
7908   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
7909
7910   u = make_lang_type (UNION_TYPE);
7911   IS_AGGR_TYPE (u) = 0;
7912   fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
7913   fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
7914                                      delta_type_node);
7915   finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
7916   TYPE_NAME (u) = NULL_TREE;
7917
7918   t = make_lang_type (RECORD_TYPE);
7919
7920   /* Let the front-end know this is a pointer to member function...  */
7921   TYPE_PTRMEMFUNC_FLAG (t) = 1;
7922   /* ... and not really an aggregate.  */
7923   IS_AGGR_TYPE (t) = 0;
7924
7925   fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
7926                                      delta_type_node);
7927   fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
7928                                      delta_type_node);
7929   fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
7930   finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
7931
7932   pop_obstacks ();
7933
7934   /* Zap out the name so that the back-end will give us the debugging
7935      information for this anonymous RECORD_TYPE.  */
7936   TYPE_NAME (t) = NULL_TREE;
7937
7938   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7939
7940   /* Seems to be wanted.  */
7941   CLASSTYPE_GOT_SEMICOLON (t) = 1;
7942   return t;
7943 }
7944
7945 /* Given declspecs and a declarator,
7946    determine the name and type of the object declared
7947    and construct a ..._DECL node for it.
7948    (In one case we can return a ..._TYPE node instead.
7949     For invalid input we sometimes return 0.)
7950
7951    DECLSPECS is a chain of tree_list nodes whose value fields
7952     are the storage classes and type specifiers.
7953
7954    DECL_CONTEXT says which syntactic context this declaration is in:
7955      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7956      FUNCDEF for a function definition.  Like NORMAL but a few different
7957       error messages in each case.  Return value may be zero meaning
7958       this definition is too screwy to try to parse.
7959      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
7960       handle member functions (which have FIELD context).
7961       Return value may be zero meaning this definition is too screwy to
7962       try to parse.
7963      PARM for a parameter declaration (either within a function prototype
7964       or before a function body).  Make a PARM_DECL, or return void_type_node.
7965      CATCHPARM for a parameter declaration before a catch clause.
7966      TYPENAME if for a typename (in a cast or sizeof).
7967       Don't make a DECL node; just return the ..._TYPE node.
7968      FIELD for a struct or union field; make a FIELD_DECL.
7969      BITFIELD for a field with specified width.
7970    INITIALIZED is 1 if the decl has an initializer.
7971
7972    In the TYPENAME case, DECLARATOR is really an absolute declarator.
7973    It may also be so in the PARM case, for a prototype where the
7974    argument type is specified but not the name.
7975
7976    This function is where the complicated C meanings of `static'
7977    and `extern' are interpreted.
7978
7979    For C++, if there is any monkey business to do, the function which
7980    calls this one must do it, i.e., prepending instance variables,
7981    renaming overloaded function names, etc.
7982
7983    Note that for this C++, it is an error to define a method within a class
7984    which does not belong to that class.
7985
7986    Except in the case where SCOPE_REFs are implicitly known (such as
7987    methods within a class being redundantly qualified),
7988    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
7989    (class_name::decl_name).  The caller must also deal with this.
7990
7991    If a constructor or destructor is seen, and the context is FIELD,
7992    then the type gains the attribute TREE_HAS_x.  If such a declaration
7993    is erroneous, NULL_TREE is returned.
7994
7995    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
7996    function, these are the qualifiers to give to the `this' pointer.
7997
7998    May return void_type_node if the declarator turned out to be a friend.
7999    See grokfield for details.  */
8000
8001 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
8002
8003 tree
8004 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
8005      tree declspecs;
8006      tree declarator;
8007      enum decl_context decl_context;
8008      int initialized;
8009      tree attrlist;
8010 {
8011   RID_BIT_TYPE specbits;
8012   int nclasses = 0;
8013   tree spec;
8014   tree type = NULL_TREE;
8015   int longlong = 0;
8016   int constp;
8017   int volatilep;
8018   int virtualp, explicitp, friendp, inlinep, staticp;
8019   int explicit_int = 0;
8020   int explicit_char = 0;
8021   int defaulted_int = 0;
8022   int opaque_typedef = 0;
8023   tree typedef_decl = NULL_TREE;
8024   char *name;
8025   tree typedef_type = NULL_TREE;
8026   int funcdef_flag = 0;
8027   enum tree_code innermost_code = ERROR_MARK;
8028   int bitfield = 0;
8029 #if 0
8030   /* See the code below that used this.  */
8031   tree decl_machine_attr = NULL_TREE;
8032 #endif
8033   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8034      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
8035   tree init = NULL_TREE;
8036
8037   /* Keep track of what sort of function is being processed
8038      so that we can warn about default return values, or explicit
8039      return values which do not match prescribed defaults.  */
8040   enum return_types return_type = return_normal;
8041
8042   tree dname = NULL_TREE;
8043   tree ctype = current_class_type;
8044   tree ctor_return_type = NULL_TREE;
8045   enum overload_flags flags = NO_SPECIAL;
8046   tree quals = NULL_TREE;
8047   tree raises = NULL_TREE;
8048   int template_count = 0;
8049   tree in_namespace = NULL_TREE;
8050
8051   RIDBIT_RESET_ALL (specbits);
8052   if (decl_context == FUNCDEF)
8053     funcdef_flag = 1, decl_context = NORMAL;
8054   else if (decl_context == MEMFUNCDEF)
8055     funcdef_flag = -1, decl_context = FIELD;
8056   else if (decl_context == BITFIELD)
8057     bitfield = 1, decl_context = FIELD;
8058
8059   /* Look inside a declarator for the name being declared
8060      and get it as a string, for an error message.  */
8061   {
8062     tree *next = &declarator;
8063     register tree decl;
8064     name = NULL;
8065
8066     while (next && *next)
8067       {
8068         decl = *next;
8069         switch (TREE_CODE (decl))
8070           {
8071           case COND_EXPR:
8072             ctype = NULL_TREE;
8073             next = &TREE_OPERAND (decl, 0);
8074             break;
8075
8076           case BIT_NOT_EXPR:    /* For C++ destructors!  */
8077             {
8078               tree name = TREE_OPERAND (decl, 0);
8079               tree rename = NULL_TREE;
8080
8081               my_friendly_assert (flags == NO_SPECIAL, 152);
8082               flags = DTOR_FLAG;
8083               return_type = return_dtor;
8084               if (TREE_CODE (name) == TYPE_DECL)
8085                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
8086               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
8087               if (ctype == NULL_TREE)
8088                 {
8089                   if (current_class_type == NULL_TREE)
8090                     {
8091                       error ("destructors must be member functions");
8092                       flags = NO_SPECIAL;
8093                     }
8094                   else
8095                     {
8096                       tree t = constructor_name (current_class_name);
8097                       if (t != name)
8098                         rename = t;
8099                     }
8100                 }
8101               else
8102                 {
8103                   tree t = constructor_name (ctype);
8104                   if (t != name)
8105                     rename = t;
8106                 }
8107
8108               if (rename)
8109                 {
8110                   cp_error ("destructor `%T' must match class name `%T'",
8111                             name, rename);
8112                   TREE_OPERAND (decl, 0) = rename;
8113                 }
8114               next = &name;
8115             }
8116             break;
8117
8118           case ADDR_EXPR:       /* C++ reference declaration */
8119             /* Fall through. */
8120           case ARRAY_REF:
8121           case INDIRECT_REF:
8122             ctype = NULL_TREE;
8123             innermost_code = TREE_CODE (decl);
8124             next = &TREE_OPERAND (decl, 0);
8125             break;
8126
8127           case CALL_EXPR:
8128             if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
8129               {
8130                 /* This is actually a variable declaration using constructor
8131                    syntax.  We need to call start_decl and cp_finish_decl so we
8132                    can get the variable initialized...  */
8133
8134                 *next = TREE_OPERAND (decl, 0);
8135                 init = TREE_OPERAND (decl, 1);
8136
8137                 decl = start_decl (declarator, declspecs, 1, NULL_TREE, NULL_TREE);
8138                 /* Look for __unused__ attribute */
8139                 if (TREE_USED (TREE_TYPE (decl)))
8140                   TREE_USED (decl) = 1;
8141                 finish_decl (decl, init, NULL_TREE);
8142                 return 0;
8143               }
8144             innermost_code = TREE_CODE (decl);
8145             if (decl_context == FIELD && ctype == NULL_TREE)
8146               ctype = current_class_type;
8147             if (ctype
8148                 && TREE_OPERAND (decl, 0)
8149                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
8150                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
8151                          == constructor_name_full (ctype))
8152                         || (DECL_NAME (TREE_OPERAND (decl, 0))
8153                             == constructor_name (ctype)))))
8154               TREE_OPERAND (decl, 0) = constructor_name (ctype);
8155             next = &TREE_OPERAND (decl, 0);
8156             decl = *next;
8157             if (ctype != NULL_TREE
8158                 && decl != NULL_TREE && flags != DTOR_FLAG
8159                 && decl == constructor_name (ctype))
8160               {
8161                 return_type = return_ctor;
8162                 ctor_return_type = ctype;
8163               }
8164             ctype = NULL_TREE;
8165             break;
8166
8167           case TEMPLATE_ID_EXPR:
8168               {
8169                 tree fns = TREE_OPERAND (decl, 0);
8170
8171                 if (TREE_CODE (fns) == LOOKUP_EXPR)
8172                   fns = TREE_OPERAND (fns, 0);
8173
8174                 if (TREE_CODE (fns) == IDENTIFIER_NODE)
8175                   dname = fns;
8176                 else if (is_overloaded_fn (fns))
8177                   dname = DECL_NAME (get_first_fn (fns));
8178                 else
8179                   my_friendly_abort (0);
8180               }
8181           /* Fall through. */
8182
8183           case IDENTIFIER_NODE:
8184             if (TREE_CODE (decl) == IDENTIFIER_NODE)
8185               dname = decl;
8186
8187             next = 0;
8188
8189             if (is_rid (dname))
8190               {
8191                 cp_error ("declarator-id missing; using reserved word `%D'",
8192                           dname);
8193                 name = IDENTIFIER_POINTER (dname);
8194               }
8195             if (! IDENTIFIER_OPNAME_P (dname)
8196                 /* GNU/Linux headers use '__op'.  Arrgh.  */
8197                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
8198               name = IDENTIFIER_POINTER (dname);
8199             else
8200               {
8201                 if (IDENTIFIER_TYPENAME_P (dname))
8202                   {
8203                     my_friendly_assert (flags == NO_SPECIAL, 154);
8204                     flags = TYPENAME_FLAG;
8205                     ctor_return_type = TREE_TYPE (dname);
8206                     return_type = return_conversion;
8207                   }
8208                 name = operator_name_string (dname);
8209               }
8210             break;
8211
8212             /* C++ extension */
8213           case SCOPE_REF:
8214             {
8215               /* Perform error checking, and decide on a ctype.  */
8216               tree cname = TREE_OPERAND (decl, 0);
8217               if (cname == NULL_TREE)
8218                 ctype = NULL_TREE;
8219               else if (TREE_CODE (cname) == NAMESPACE_DECL)
8220                 {
8221                   ctype = NULL_TREE;
8222                   in_namespace = TREE_OPERAND (decl, 0);
8223                   TREE_OPERAND (decl, 0) = NULL_TREE;
8224                 }
8225               else if (! is_aggr_type (cname, 1))
8226                 TREE_OPERAND (decl, 0) = NULL_TREE;
8227               /* Must test TREE_OPERAND (decl, 1), in case user gives
8228                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
8229               else if (TREE_OPERAND (decl, 1)
8230                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
8231                 ctype = cname;
8232               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
8233                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
8234                 {
8235                   cp_error ("`%T::%D' is not a valid declarator", cname,
8236                             TREE_OPERAND (decl, 1));
8237                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
8238                             cname, TREE_OPERAND (decl, 1));
8239                   return void_type_node;
8240                 }
8241               else if (ctype == NULL_TREE)
8242                 ctype = cname;
8243               else if (TREE_COMPLEXITY (decl) == current_class_depth)
8244                 TREE_OPERAND (decl, 0) = ctype;
8245               else
8246                 {
8247                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
8248                     {
8249                       cp_error ("type `%T' is not derived from type `%T'",
8250                                 cname, ctype);
8251                       TREE_OPERAND (decl, 0) = NULL_TREE;
8252                     }
8253                   else
8254                     ctype = cname;
8255                 }
8256
8257               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
8258                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
8259                        == constructor_name_full (ctype))
8260                       || (DECL_NAME (TREE_OPERAND (decl, 1))
8261                           == constructor_name (ctype))))
8262                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
8263               next = &TREE_OPERAND (decl, 1);
8264               decl = *next;
8265               if (ctype)
8266                 {
8267                   if (TREE_CODE (decl) == IDENTIFIER_NODE
8268                       && constructor_name (ctype) == decl)
8269                     {
8270                       return_type = return_ctor;
8271                       ctor_return_type = ctype;
8272                     }
8273                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
8274                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
8275                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
8276                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
8277                     {
8278                       return_type = return_dtor;
8279                       ctor_return_type = ctype;
8280                       flags = DTOR_FLAG;
8281                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
8282                       next = &TREE_OPERAND (decl, 0);
8283                     }
8284                 }
8285             }
8286             break;
8287
8288           case ERROR_MARK:
8289             next = 0;
8290             break;
8291
8292           case TYPE_DECL:
8293             /* Parse error puts this typespec where
8294                a declarator should go.  */
8295             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
8296             if (TREE_TYPE (decl) == current_class_type)
8297               cp_error ("  perhaps you want `%T' for a constructor",
8298                         current_class_name);
8299             dname = DECL_NAME (decl);
8300             name = IDENTIFIER_POINTER (dname);
8301
8302             /* Avoid giving two errors for this.  */
8303             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
8304
8305             declspecs = temp_tree_cons (NULL_TREE, integer_type_node,
8306                                         declspecs);
8307             *next = dname;
8308             next = 0;
8309             break;
8310
8311           default:
8312             cp_compiler_error ("`%D' as declarator", decl);
8313             return 0; /* We used to do a 155 abort here.  */
8314           }
8315       }
8316     if (name == NULL)
8317       name = "type name";
8318   }
8319
8320   /* A function definition's declarator must have the form of
8321      a function declarator.  */
8322
8323   if (funcdef_flag && innermost_code != CALL_EXPR)
8324     return 0;
8325
8326   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8327       && innermost_code != CALL_EXPR
8328       && ! (ctype && declspecs == NULL_TREE))
8329     {
8330       cp_error ("declaration of `%D' as non-function", dname);
8331       return void_type_node;
8332     }
8333
8334   /* Anything declared one level down from the top level
8335      must be one of the parameters of a function
8336      (because the body is at least two levels down).  */
8337
8338   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8339      by not allowing C++ class definitions to specify their parameters
8340      with xdecls (must be spec.d in the parmlist).
8341
8342      Since we now wait to push a class scope until we are sure that
8343      we are in a legitimate method context, we must set oldcname
8344      explicitly (since current_class_name is not yet alive).
8345
8346      We also want to avoid calling this a PARM if it is in a namespace.  */
8347
8348   if (decl_context == NORMAL && ! namespace_bindings_p ()
8349       && ! pseudo_global_level_p ())
8350     {
8351       struct binding_level *b = current_binding_level;
8352       current_binding_level = b->level_chain;
8353       if (current_binding_level != 0 && toplevel_bindings_p ())
8354         decl_context = PARM;
8355       current_binding_level = b;
8356     }
8357
8358   /* Look through the decl specs and record which ones appear.
8359      Some typespecs are defined as built-in typenames.
8360      Others, the ones that are modifiers of other types,
8361      are represented by bits in SPECBITS: set the bits for
8362      the modifiers that appear.  Storage class keywords are also in SPECBITS.
8363
8364      If there is a typedef name or a type, store the type in TYPE.
8365      This includes builtin typedefs such as `int'.
8366
8367      Set EXPLICIT_INT if the type is `int' or `char' and did not
8368      come from a user typedef.
8369
8370      Set LONGLONG if `long' is mentioned twice.
8371
8372      For C++, constructors and destructors have their own fast treatment.  */
8373
8374   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
8375     {
8376       register int i;
8377       register tree id;
8378
8379       /* Certain parse errors slip through.  For example,
8380          `int class;' is not caught by the parser. Try
8381          weakly to recover here.  */
8382       if (TREE_CODE (spec) != TREE_LIST)
8383         return 0;
8384
8385       id = TREE_VALUE (spec);
8386
8387       if (TREE_CODE (id) == IDENTIFIER_NODE)
8388         {
8389           if (id == ridpointers[(int) RID_INT]
8390               || id == ridpointers[(int) RID_CHAR]
8391               || id == ridpointers[(int) RID_BOOL]
8392               || id == ridpointers[(int) RID_WCHAR])
8393             {
8394               if (type)
8395                 {
8396                   if (id == ridpointers[(int) RID_BOOL])
8397                     error ("`bool' is now a keyword");
8398                   else
8399                     cp_error ("extraneous `%T' ignored", id);
8400                 }
8401               else
8402                 {
8403                   if (id == ridpointers[(int) RID_INT])
8404                     explicit_int = 1;
8405                   else if (id == ridpointers[(int) RID_CHAR])
8406                     explicit_char = 1;
8407                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
8408                 }
8409               goto found;
8410             }
8411           /* C++ aggregate types.  */
8412           if (IDENTIFIER_HAS_TYPE_VALUE (id))
8413             {
8414               if (type)
8415                 cp_error ("multiple declarations `%T' and `%T'", type, id);
8416               else
8417                 type = IDENTIFIER_TYPE_VALUE (id);
8418               goto found;
8419             }
8420
8421           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
8422             {
8423               if (ridpointers[i] == id)
8424                 {
8425                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
8426                     {
8427                       if (pedantic && ! in_system_header)
8428                         pedwarn ("ANSI C++ does not support `long long'");
8429                       if (longlong)
8430                         error ("`long long long' is too long for GCC");
8431                       else
8432                         longlong = 1;
8433                     }
8434                   else if (RIDBIT_SETP (i, specbits))
8435                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
8436                   RIDBIT_SET (i, specbits);
8437                   goto found;
8438                 }
8439             }
8440         }
8441       /* C++ aggregate types.  */
8442       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
8443         {
8444           if (type)
8445             cp_error ("multiple declarations `%T' and `%T'", type,
8446                       TREE_TYPE (id));
8447           else
8448             {
8449               type = TREE_TYPE (id);
8450               TREE_VALUE (spec) = type;
8451             }
8452           goto found;
8453         }
8454       if (type)
8455         error ("two or more data types in declaration of `%s'", name);
8456       else if (TREE_CODE (id) == IDENTIFIER_NODE)
8457         {
8458           register tree t = lookup_name (id, 1);
8459           if (!t || TREE_CODE (t) != TYPE_DECL)
8460             error ("`%s' fails to be a typedef or built in type",
8461                    IDENTIFIER_POINTER (id));
8462           else
8463             {
8464               type = TREE_TYPE (t);
8465 #if 0
8466               /* See the code below that used this.  */
8467               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
8468 #endif
8469               typedef_decl = t;
8470             }
8471         }
8472       else if (id != error_mark_node)
8473         /* Can't change CLASS nodes into RECORD nodes here!  */
8474         type = id;
8475
8476     found: ;
8477     }
8478
8479   typedef_type = type;
8480
8481   /* No type at all: default to `int', and set DEFAULTED_INT
8482      because it was not a user-defined typedef.
8483      Except when we have a `typedef' inside a signature, in
8484      which case the type defaults to `unknown type' and is
8485      instantiated when assigning to a signature pointer or ref.  */
8486
8487   if (type == NULL_TREE
8488       && (RIDBIT_SETP (RID_SIGNED, specbits)
8489           || RIDBIT_SETP (RID_UNSIGNED, specbits)
8490           || RIDBIT_SETP (RID_LONG, specbits)
8491           || RIDBIT_SETP (RID_SHORT, specbits)))
8492     {
8493       /* These imply 'int'.  */
8494       type = integer_type_node;
8495       defaulted_int = 1;
8496     }
8497
8498   if (type == NULL_TREE)
8499     {
8500       explicit_int = -1;
8501       if (return_type == return_dtor)
8502         type = void_type_node;
8503       else if (return_type == return_ctor)
8504         type = build_pointer_type (ctor_return_type);
8505       else if (return_type == return_conversion)
8506         type = ctor_return_type;
8507       else if (current_class_type
8508                && IS_SIGNATURE (current_class_type)
8509                && RIDBIT_SETP (RID_TYPEDEF, specbits)
8510                && (decl_context == FIELD || decl_context == NORMAL))
8511         {
8512           explicit_int = 0;
8513           opaque_typedef = 1;
8514           type = copy_node (opaque_type_node);
8515         }
8516       else
8517         {
8518           if (funcdef_flag)
8519             {
8520               if (warn_return_type
8521                   && return_type == return_normal)
8522                 /* Save warning until we know what is really going on.  */
8523                 warn_about_return_type = 1;
8524             }
8525           else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8526             pedwarn ("ANSI C++ forbids typedef which does not specify a type");
8527           else if (innermost_code != CALL_EXPR || pedantic
8528                    || (warn_return_type && return_type == return_normal))
8529             {
8530               if (innermost_code == CALL_EXPR)
8531                 cp_pedwarn ("return-type of `%D' defaults to `int'", dname);
8532               else
8533                 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
8534                             dname);
8535             }
8536           type = integer_type_node;
8537         }
8538     }
8539   else if (return_type == return_dtor)
8540     {
8541       error ("return type specification for destructor invalid");
8542       type = void_type_node;
8543     }
8544   else if (return_type == return_ctor)
8545     {
8546       error ("return type specification for constructor invalid");
8547       type = build_pointer_type (ctor_return_type);
8548     }
8549   else if (return_type == return_conversion)
8550     {
8551       if (comptypes (type, ctor_return_type, 1) == 0)
8552         cp_error ("operator `%T' declared to return `%T'",
8553                   ctor_return_type, type);
8554       else
8555         cp_pedwarn ("return type specified for `operator %T'",
8556                     ctor_return_type);
8557
8558       type = ctor_return_type;
8559     }
8560
8561   ctype = NULL_TREE;
8562
8563   /* Now process the modifiers that were specified
8564      and check for invalid combinations.  */
8565
8566   /* Long double is a special combination.  */
8567
8568   if (RIDBIT_SETP (RID_LONG, specbits)
8569       && TYPE_MAIN_VARIANT (type) == double_type_node)
8570     {
8571       RIDBIT_RESET (RID_LONG, specbits);
8572       type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
8573                                  TYPE_VOLATILE (type));
8574     }
8575
8576   /* Check all other uses of type modifiers.  */
8577
8578   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8579       || RIDBIT_SETP (RID_SIGNED, specbits)
8580       || RIDBIT_SETP (RID_LONG, specbits)
8581       || RIDBIT_SETP (RID_SHORT, specbits))
8582     {
8583       int ok = 0;
8584
8585       if (TREE_CODE (type) == REAL_TYPE)
8586         error ("short, signed or unsigned invalid for `%s'", name);
8587       else if (TREE_CODE (type) != INTEGER_TYPE)
8588         error ("long, short, signed or unsigned invalid for `%s'", name);
8589       else if (RIDBIT_SETP (RID_LONG, specbits)
8590                && RIDBIT_SETP (RID_SHORT, specbits))
8591         error ("long and short specified together for `%s'", name);
8592       else if ((RIDBIT_SETP (RID_LONG, specbits)
8593                 || RIDBIT_SETP (RID_SHORT, specbits))
8594                && explicit_char)
8595         error ("long or short specified with char for `%s'", name);
8596       else if ((RIDBIT_SETP (RID_LONG, specbits)
8597                 || RIDBIT_SETP (RID_SHORT, specbits))
8598                && TREE_CODE (type) == REAL_TYPE)
8599         error ("long or short specified with floating type for `%s'", name);
8600       else if (RIDBIT_SETP (RID_SIGNED, specbits)
8601                && RIDBIT_SETP (RID_UNSIGNED, specbits))
8602         error ("signed and unsigned given together for `%s'", name);
8603       else
8604         {
8605           ok = 1;
8606           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
8607             {
8608               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
8609                        name);
8610               if (flag_pedantic_errors)
8611                 ok = 0;
8612             }
8613         }
8614
8615       /* Discard the type modifiers if they are invalid.  */
8616       if (! ok)
8617         {
8618           RIDBIT_RESET (RID_UNSIGNED, specbits);
8619           RIDBIT_RESET (RID_SIGNED, specbits);
8620           RIDBIT_RESET (RID_LONG, specbits);
8621           RIDBIT_RESET (RID_SHORT, specbits);
8622           longlong = 0;
8623         }
8624     }
8625
8626   if (RIDBIT_SETP (RID_COMPLEX, specbits)
8627       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8628     {
8629       error ("complex invalid for `%s'", name);
8630       RIDBIT_RESET (RID_COMPLEX, specbits);
8631     }
8632
8633   /* Decide whether an integer type is signed or not.
8634      Optionally treat bitfields as signed by default.  */
8635   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8636       || (bitfield && ! flag_signed_bitfields
8637           && (explicit_int || defaulted_int || explicit_char
8638               /* A typedef for plain `int' without `signed'
8639                  can be controlled just like plain `int'.  */
8640               || ! (typedef_decl != NULL_TREE
8641                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8642           && TREE_CODE (type) != ENUMERAL_TYPE
8643           && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
8644     {
8645       if (longlong)
8646         type = long_long_unsigned_type_node;
8647       else if (RIDBIT_SETP (RID_LONG, specbits))
8648         type = long_unsigned_type_node;
8649       else if (RIDBIT_SETP (RID_SHORT, specbits))
8650         type = short_unsigned_type_node;
8651       else if (type == char_type_node)
8652         type = unsigned_char_type_node;
8653       else if (typedef_decl)
8654         type = unsigned_type (type);
8655       else
8656         type = unsigned_type_node;
8657     }
8658   else if (RIDBIT_SETP (RID_SIGNED, specbits)
8659            && type == char_type_node)
8660     type = signed_char_type_node;
8661   else if (longlong)
8662     type = long_long_integer_type_node;
8663   else if (RIDBIT_SETP (RID_LONG, specbits))
8664     type = long_integer_type_node;
8665   else if (RIDBIT_SETP (RID_SHORT, specbits))
8666     type = short_integer_type_node;
8667
8668   if (RIDBIT_SETP (RID_COMPLEX, specbits))
8669     {
8670       /* If we just have "complex", it is equivalent to
8671          "complex double", but if any modifiers at all are specified it is
8672          the complex form of TYPE.  E.g, "complex short" is
8673          "complex short int".  */
8674
8675       if (defaulted_int && ! longlong
8676           && ! (RIDBIT_SETP (RID_LONG, specbits)
8677                 || RIDBIT_SETP (RID_SHORT, specbits)
8678                 || RIDBIT_SETP (RID_SIGNED, specbits)
8679                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
8680         type = complex_double_type_node;
8681       else if (type == integer_type_node)
8682         type = complex_integer_type_node;
8683       else if (type == float_type_node)
8684         type = complex_float_type_node;
8685       else if (type == double_type_node)
8686         type = complex_double_type_node;
8687       else if (type == long_double_type_node)
8688         type = complex_long_double_type_node;
8689       else
8690         type = build_complex_type (type);
8691     }
8692
8693   if (return_type == return_conversion
8694       && (RIDBIT_SETP (RID_CONST, specbits)
8695           || RIDBIT_SETP (RID_VOLATILE, specbits)))
8696     cp_error ("`operator %T' cannot be cv-qualified",
8697               ctor_return_type);
8698
8699   /* Set CONSTP if this declaration is `const', whether by
8700      explicit specification or via a typedef.
8701      Likewise for VOLATILEP.  */
8702
8703   constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
8704   volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
8705   type = build_type_variant (type, 0, 0);
8706   staticp = 0;
8707   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
8708   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
8709   RIDBIT_RESET (RID_VIRTUAL, specbits);
8710   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
8711   RIDBIT_RESET (RID_EXPLICIT, specbits);
8712
8713   if (RIDBIT_SETP (RID_STATIC, specbits))
8714     staticp = 1 + (decl_context == FIELD);
8715
8716   if (virtualp && staticp == 2)
8717     {
8718       cp_error ("member `%D' cannot be declared both virtual and static",
8719                 dname);
8720       staticp = 0;
8721     }
8722   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
8723   RIDBIT_RESET (RID_FRIEND, specbits);
8724
8725   if (RIDBIT_SETP (RID_MUTABLE, specbits))
8726     {
8727       if (decl_context == PARM)
8728         {
8729           error ("non-member `%s' cannot be declared `mutable'", name);
8730           RIDBIT_RESET (RID_MUTABLE, specbits);
8731         }
8732       else if (friendp || decl_context == TYPENAME)
8733         {
8734           error ("non-object member `%s' cannot be declared `mutable'", name);
8735           RIDBIT_RESET (RID_MUTABLE, specbits);
8736         }
8737     }
8738
8739   /* Warn if two storage classes are given. Default to `auto'.  */
8740
8741   if (RIDBIT_ANY_SET (specbits))
8742     {
8743       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
8744       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
8745       if (decl_context == PARM && nclasses > 0)
8746         error ("storage class specifiers invalid in parameter declarations");
8747       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8748         {
8749           if (decl_context == PARM)
8750             error ("typedef declaration invalid in parameter declaration");
8751           nclasses++;
8752         }
8753       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
8754       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
8755     }
8756
8757   /* Give error if `virtual' is used outside of class declaration.  */
8758   if (virtualp
8759       && (current_class_name == NULL_TREE || decl_context != FIELD))
8760     {
8761       error ("virtual outside class declaration");
8762       virtualp = 0;
8763     }
8764   if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
8765     {
8766       error ("only members can be declared mutable");
8767       RIDBIT_RESET (RID_MUTABLE, specbits);
8768     }
8769
8770   /* Static anonymous unions are dealt with here.  */
8771   if (staticp && decl_context == TYPENAME
8772       && TREE_CODE (declspecs) == TREE_LIST
8773       && ANON_UNION_TYPE_P (TREE_VALUE (declspecs)))
8774     decl_context = FIELD;
8775
8776   /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
8777      is used in a signature member function declaration.  */
8778   if (decl_context == FIELD
8779       && IS_SIGNATURE (current_class_type)
8780       && RIDBIT_NOTSETP (RID_TYPEDEF, specbits))
8781     {
8782       if (constp)
8783         {
8784           error ("`const' specified for signature member function `%s'", name);
8785           constp = 0;
8786         }
8787       if (volatilep)
8788         {
8789           error ("`volatile' specified for signature member function `%s'",
8790                  name);
8791           volatilep = 0;
8792         }
8793       if (inlinep)
8794         {
8795           error ("`inline' specified for signature member function `%s'", name);
8796           /* Later, we'll make signature member functions inline.  */
8797           inlinep = 0;
8798         }
8799       if (friendp)
8800         {
8801           error ("`friend' declaration in signature definition");
8802           friendp = 0;
8803         }
8804       if (virtualp)
8805         {
8806           error ("`virtual' specified for signature member function `%s'",
8807                  name);
8808           /* Later, we'll make signature member functions virtual.  */
8809           virtualp = 0;
8810         }
8811     }
8812
8813   /* Warn about storage classes that are invalid for certain
8814      kinds of declarations (parameters, typenames, etc.).  */
8815
8816   if (nclasses > 1)
8817     error ("multiple storage classes in declaration of `%s'", name);
8818   else if (decl_context != NORMAL && nclasses > 0)
8819     {
8820       if ((decl_context == PARM || decl_context == CATCHPARM)
8821           && (RIDBIT_SETP (RID_REGISTER, specbits)
8822               || RIDBIT_SETP (RID_AUTO, specbits)))
8823         ;
8824       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8825         ;
8826       else if (decl_context == FIELD
8827                && ! IS_SIGNATURE (current_class_type)
8828                /* C++ allows static class elements  */
8829                && RIDBIT_SETP (RID_STATIC, specbits))
8830         /* C++ also allows inlines and signed and unsigned elements,
8831            but in those cases we don't come in here.  */
8832         ;
8833       else
8834         {
8835           if (decl_context == FIELD)
8836             {
8837               tree tmp = NULL_TREE;
8838               register int op = 0;
8839
8840               if (declarator)
8841                 {
8842                   /* Avoid trying to get an operand off an identifier node.  */
8843                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8844                     tmp = declarator;
8845                   else
8846                     tmp = TREE_OPERAND (declarator, 0);
8847                   op = IDENTIFIER_OPNAME_P (tmp);
8848                 }
8849               error ("storage class specified for %s `%s'",
8850                      IS_SIGNATURE (current_class_type)
8851                      ? (op
8852                         ? "signature member operator"
8853                         : "signature member function")
8854                      : (op ? "member operator" : "field"),
8855                      op ? operator_name_string (tmp) : name);
8856             }
8857           else
8858             error (((decl_context == PARM || decl_context == CATCHPARM)
8859                     ? "storage class specified for parameter `%s'"
8860                     : "storage class specified for typename"), name);
8861           RIDBIT_RESET (RID_REGISTER, specbits);
8862           RIDBIT_RESET (RID_AUTO, specbits);
8863           RIDBIT_RESET (RID_EXTERN, specbits);
8864
8865           if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
8866             {
8867               RIDBIT_RESET (RID_STATIC, specbits);
8868               staticp = 0;
8869             }
8870         }
8871     }
8872   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
8873     {
8874       if (toplevel_bindings_p ())
8875         {
8876           /* It's common practice (and completely valid) to have a const
8877              be initialized and declared extern.  */
8878           if (! constp)
8879             warning ("`%s' initialized and declared `extern'", name);
8880         }
8881       else
8882         error ("`%s' has both `extern' and initializer", name);
8883     }
8884   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
8885            && ! toplevel_bindings_p ())
8886     error ("nested function `%s' declared `extern'", name);
8887   else if (toplevel_bindings_p ())
8888     {
8889       if (RIDBIT_SETP (RID_AUTO, specbits))
8890         error ("top-level declaration of `%s' specifies `auto'", name);
8891     }
8892
8893   if (nclasses > 0 && friendp)
8894     error ("storage class specifiers invalid in friend function declarations");
8895
8896   /* Now figure out the structure of the declarator proper.
8897      Descend through it, creating more complex types, until we reach
8898      the declared identifier (or NULL_TREE, in an absolute declarator).  */
8899
8900   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
8901          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
8902     {
8903       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
8904          an INDIRECT_REF (for *...),
8905          a CALL_EXPR (for ...(...)),
8906          an identifier (for the name being declared)
8907          or a null pointer (for the place in an absolute declarator
8908          where the name was omitted).
8909          For the last two cases, we have just exited the loop.
8910
8911          For C++ it could also be
8912          a SCOPE_REF (for class :: ...).  In this case, we have converted
8913          sensible names to types, and those are the values we use to
8914          qualify the member name.
8915          an ADDR_EXPR (for &...),
8916          a BIT_NOT_EXPR (for destructors)
8917
8918          At this point, TYPE is the type of elements of an array,
8919          or for a function to return, or for a pointer to point to.
8920          After this sequence of ifs, TYPE is the type of the
8921          array or function or pointer, and DECLARATOR has had its
8922          outermost layer removed.  */
8923
8924       if (type == error_mark_node)
8925         {
8926           if (TREE_CODE (declarator) == SCOPE_REF)
8927             declarator = TREE_OPERAND (declarator, 1);
8928           else
8929             declarator = TREE_OPERAND (declarator, 0);
8930           continue;
8931         }
8932       if (quals != NULL_TREE
8933           && (declarator == NULL_TREE
8934               || TREE_CODE (declarator) != SCOPE_REF))
8935         {
8936           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
8937             ctype = TYPE_METHOD_BASETYPE (type);
8938           if (ctype != NULL_TREE)
8939             {
8940               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
8941               ctype = grok_method_quals (ctype, dummy, quals);
8942               type = TREE_TYPE (dummy);
8943               quals = NULL_TREE;
8944             }
8945         }
8946       switch (TREE_CODE (declarator))
8947         {
8948         case ARRAY_REF:
8949           {
8950             register tree itype = NULL_TREE;
8951             register tree size = TREE_OPERAND (declarator, 1);
8952             /* The index is a signed object `sizetype' bits wide.  */
8953             tree index_type = signed_type (sizetype);
8954
8955             declarator = TREE_OPERAND (declarator, 0);
8956
8957             /* Check for some types that there cannot be arrays of.  */
8958
8959             if (TREE_CODE (type) == VOID_TYPE)
8960               {
8961                 cp_error ("declaration of `%D' as array of voids", dname);
8962                 type = error_mark_node;
8963               }
8964
8965             if (TREE_CODE (type) == FUNCTION_TYPE)
8966               {
8967                 cp_error ("declaration of `%D' as array of functions", dname);
8968                 type = error_mark_node;
8969               }
8970
8971             /* ARM $8.4.3: Since you can't have a pointer to a reference,
8972                you can't have arrays of references.  If we allowed them,
8973                then we'd be saying x[i] is valid for an array x, but
8974                then you'd have to ask: what does `*(x + i)' mean?  */
8975             if (TREE_CODE (type) == REFERENCE_TYPE)
8976               {
8977                 if (decl_context == TYPENAME)
8978                   cp_error ("cannot make arrays of references");
8979                 else
8980                   cp_error ("declaration of `%D' as array of references",
8981                             dname);
8982                 type = error_mark_node;
8983               }
8984
8985             if (TREE_CODE (type) == OFFSET_TYPE)
8986               {
8987                   cp_error ("declaration of `%D' as array of data members",
8988                             dname);
8989                 type = error_mark_node;
8990               }
8991
8992             if (TREE_CODE (type) == METHOD_TYPE)
8993               {
8994                 cp_error ("declaration of `%D' as array of function members",
8995                           dname);
8996                 type = error_mark_node;
8997               }
8998
8999             if (size == error_mark_node)
9000               type = error_mark_node;
9001
9002             if (type == error_mark_node)
9003               continue;
9004
9005             if (size)
9006               {
9007                 /* Must suspend_momentary here because the index
9008                    type may need to live until the end of the function.
9009                    For example, it is used in the declaration of a
9010                    variable which requires destructing at the end of
9011                    the function; then build_vec_delete will need this
9012                    value.  */
9013                 int yes = suspend_momentary ();
9014                 /* Might be a cast. */
9015                 if (TREE_CODE (size) == NOP_EXPR
9016                     && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
9017                   size = TREE_OPERAND (size, 0);
9018
9019                 /* If this involves a template parameter, it'll be
9020                    constant, but we don't know what the value is yet.  */
9021                 if (processing_template_decl)
9022                   {
9023                     itype = make_node (INTEGER_TYPE);
9024                     TYPE_MIN_VALUE (itype) = size_zero_node;
9025                     TYPE_MAX_VALUE (itype) = build_min
9026                       (MINUS_EXPR, sizetype, size, integer_one_node);
9027                     goto dont_grok_size;
9028                   }
9029
9030                 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9031                     && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
9032                   {
9033                     cp_error ("size of array `%D' has non-integer type",
9034                               dname);
9035                     size = integer_one_node;
9036                   }
9037                 if (TREE_READONLY_DECL_P (size))
9038                   size = decl_constant_value (size);
9039                 if (pedantic && integer_zerop (size))
9040                   cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
9041                 if (TREE_CONSTANT (size))
9042                   {
9043                     int old_flag_pedantic_errors = flag_pedantic_errors;
9044                     int old_pedantic = pedantic;
9045                     pedantic = flag_pedantic_errors = 1;
9046                     /* Always give overflow errors on array subscripts.  */
9047                     constant_expression_warning (size);
9048                     pedantic = old_pedantic;
9049                     flag_pedantic_errors = old_flag_pedantic_errors;
9050                     if (INT_CST_LT (size, integer_zero_node))
9051                       {
9052                         cp_error ("size of array `%D' is negative", dname);
9053                         size = integer_one_node;
9054                       }
9055                   }
9056                 else
9057                   {
9058                     if (pedantic)
9059                       {
9060                         if (dname)
9061                           cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9062                                       dname);
9063                         else
9064                           cp_pedwarn ("ANSI C++ forbids variable-size array");
9065                       }
9066                   }
9067
9068                 itype
9069                   = fold (build_binary_op (MINUS_EXPR,
9070                                            cp_convert (index_type, size),
9071                                            cp_convert (index_type,
9072                                                        integer_one_node), 1));
9073                 if (! TREE_CONSTANT (itype))
9074                   itype = variable_size (itype);
9075                 else if (TREE_OVERFLOW (itype))
9076                   {
9077                     error ("overflow in array dimension");
9078                     TREE_OVERFLOW (itype) = 0;
9079                   }
9080
9081                 /* If we're a parm, we need to have a permanent type so
9082                    mangling checks for re-use will work right.  If both the
9083                    element and index types are permanent, the array type
9084                    will be, too.  */
9085                 if (decl_context == PARM
9086                     && allocation_temporary_p () && TREE_PERMANENT (type))
9087                   {
9088                     push_obstacks (&permanent_obstack, &permanent_obstack);
9089                     itype = build_index_type (itype);
9090                     pop_obstacks ();
9091                   }
9092                 else
9093                   itype = build_index_type (itype);
9094
9095               dont_grok_size:
9096                 resume_momentary (yes);
9097               }
9098
9099           /* Build the array type itself, then merge any constancy or
9100              volatility into the target type.  We must do it in this order
9101              to ensure that the TYPE_MAIN_VARIANT field of the array type
9102              is set correctly.  */
9103
9104             type = build_cplus_array_type (type, itype);
9105             if (constp || volatilep)
9106               type = cp_build_type_variant (type, constp, volatilep);
9107
9108             ctype = NULL_TREE;
9109           }
9110           break;
9111
9112         case CALL_EXPR:
9113           {
9114             tree arg_types;
9115             int funcdecl_p;
9116             tree inner_parms = TREE_OPERAND (declarator, 1);
9117             tree inner_decl = TREE_OPERAND (declarator, 0);
9118
9119             /* Declaring a function type.
9120                Make sure we have a valid type for the function to return.  */
9121 #if 0
9122             /* Is this an error?  Should they be merged into TYPE here?  */
9123             if (pedantic && (constp || volatilep))
9124               pedwarn ("function declared to return const or volatile result");
9125 #else
9126             /* Merge any constancy or volatility into the function return
9127                type.  */
9128
9129             if (constp || volatilep)
9130               {
9131                 type = cp_build_type_variant (type, constp, volatilep);
9132                 if (IS_AGGR_TYPE (type))
9133                   build_pointer_type (type);
9134                 constp = 0;
9135                 volatilep = 0;
9136               }
9137 #endif
9138
9139             /* Warn about some types functions can't return.  */
9140
9141             if (TREE_CODE (type) == FUNCTION_TYPE)
9142               {
9143                 error ("`%s' declared as function returning a function", name);
9144                 type = integer_type_node;
9145               }
9146             if (TREE_CODE (type) == ARRAY_TYPE)
9147               {
9148                 error ("`%s' declared as function returning an array", name);
9149                 type = integer_type_node;
9150               }
9151
9152             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
9153               inner_decl = TREE_OPERAND (inner_decl, 1);
9154
9155             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
9156               inner_decl = dname;
9157
9158             /* Pick up type qualifiers which should be applied to `this'.  */
9159             quals = TREE_OPERAND (declarator, 2);
9160
9161             /* Pick up the exception specifications.  */
9162             raises = TREE_TYPE (declarator);
9163
9164             /* Say it's a definition only for the CALL_EXPR
9165                closest to the identifier.  */
9166             funcdecl_p
9167               = inner_decl
9168               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
9169                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
9170                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
9171
9172             if (ctype == NULL_TREE
9173                 && decl_context == FIELD
9174                 && funcdecl_p
9175                 && (friendp == 0 || dname == current_class_name))
9176               ctype = current_class_type;
9177
9178             if (ctype && return_type == return_conversion)
9179               TYPE_HAS_CONVERSION (ctype) = 1;
9180             if (ctype && constructor_name (ctype) == dname)
9181               {
9182                 /* We are within a class's scope. If our declarator name
9183                    is the same as the class name, and we are defining
9184                    a function, then it is a constructor/destructor, and
9185                    therefore returns a void type.  */
9186
9187                 if (flags == DTOR_FLAG)
9188                   {
9189                     /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
9190                        not be declared const or volatile.  A destructor
9191                        may not be static.  */
9192                     if (staticp == 2)
9193                       error ("destructor cannot be static member function");
9194                     if (quals)
9195                       {
9196                         error ("destructors cannot be declared `const' or `volatile'");
9197                         return void_type_node;
9198                       }
9199                     if (decl_context == FIELD)
9200                       {
9201                         if (! member_function_or_else (ctype, current_class_type,
9202                                                        "destructor for alien class `%s' cannot be a member"))
9203                           return void_type_node;
9204                       }
9205                   }
9206                 else            /* It's a constructor.  */
9207                   {
9208                     if (explicitp == 1)
9209                       explicitp = 2;
9210                     /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
9211                        not be declared const or volatile.  A constructor may
9212                        not be virtual.  A constructor may not be static.  */
9213                     if (staticp == 2)
9214                       error ("constructor cannot be static member function");
9215                     if (virtualp)
9216                       {
9217                         pedwarn ("constructors cannot be declared virtual");
9218                         virtualp = 0;
9219                       }
9220                     if (quals)
9221                       {
9222                         error ("constructors cannot be declared `const' or `volatile'");
9223                         return void_type_node;
9224                       }
9225                     {
9226                       RID_BIT_TYPE tmp_bits;
9227                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
9228                       RIDBIT_RESET (RID_INLINE, tmp_bits);
9229                       RIDBIT_RESET (RID_STATIC, tmp_bits);
9230                       if (RIDBIT_ANY_SET (tmp_bits))
9231                         error ("return value type specifier for constructor ignored");
9232                     }
9233                     type = build_pointer_type (ctype);
9234                     if (decl_context == FIELD
9235                         && IS_SIGNATURE (current_class_type))
9236                       {
9237                         error ("constructor not allowed in signature");
9238                         return void_type_node;
9239                       }
9240                     else if (decl_context == FIELD)
9241                       {
9242                         if (! member_function_or_else (ctype, current_class_type,
9243                                                        "constructor for alien class `%s' cannot be member"))
9244                           return void_type_node;
9245                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
9246                         if (return_type != return_ctor)
9247                           return NULL_TREE;
9248                       }
9249                   }
9250                 if (decl_context == FIELD)
9251                   staticp = 0;
9252               }
9253             else if (friendp)
9254               {
9255                 if (initialized)
9256                   error ("can't initialize friend function `%s'", name);
9257                 if (virtualp)
9258                   {
9259                     /* Cannot be both friend and virtual.  */
9260                     error ("virtual functions cannot be friends");
9261                     RIDBIT_RESET (RID_FRIEND, specbits);
9262                     friendp = 0;
9263                   }
9264                 if (decl_context == NORMAL)
9265                   error ("friend declaration not in class definition");
9266                 if (current_function_decl && funcdef_flag)
9267                   cp_error ("can't define friend function `%s' in a local class definition",
9268                             name);
9269               }
9270
9271             /* Construct the function type and go to the next
9272                inner layer of declarator.  */
9273
9274             declarator = TREE_OPERAND (declarator, 0);
9275
9276             /* FIXME: This is where default args should be fully
9277                processed.  */
9278
9279             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
9280
9281             if (declarator)
9282               {
9283                 /* Get past destructors, etc.
9284                    We know we have one because FLAGS will be non-zero.
9285
9286                    Complain about improper parameter lists here.  */
9287                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
9288                   {
9289                     declarator = TREE_OPERAND (declarator, 0);
9290
9291                     if (strict_prototype == 0 && arg_types == NULL_TREE)
9292                       arg_types = void_list_node;
9293                     else if (arg_types == NULL_TREE
9294                              || arg_types != void_list_node)
9295                       {
9296                         error ("destructors cannot be specified with parameters");
9297                         arg_types = void_list_node;
9298                       }
9299                   }
9300               }
9301
9302             /* ANSI says that `const int foo ();'
9303                does not make the function foo const.  */
9304             type = build_function_type (type, arg_types);
9305
9306             {
9307               tree t;
9308               for (t = arg_types; t; t = TREE_CHAIN (t))
9309                 if (TREE_PURPOSE (t)
9310                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9311                   {
9312                     add_defarg_fn (type);
9313                     break;
9314                   }
9315             }
9316           }
9317           break;
9318
9319         case ADDR_EXPR:
9320         case INDIRECT_REF:
9321           /* Filter out pointers-to-references and references-to-references.
9322              We can get these if a TYPE_DECL is used.  */
9323
9324           if (TREE_CODE (type) == REFERENCE_TYPE)
9325             {
9326               error ("cannot declare %s to references",
9327                      TREE_CODE (declarator) == ADDR_EXPR
9328                      ? "references" : "pointers");
9329               declarator = TREE_OPERAND (declarator, 0);
9330               continue;
9331             }
9332
9333           if (TREE_CODE (type) == OFFSET_TYPE
9334               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
9335                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
9336             {
9337               cp_error ("cannot declare pointer to `%#T' member",
9338                         TREE_TYPE (type));
9339               type = TREE_TYPE (type);
9340             }
9341
9342           /* Merge any constancy or volatility into the target type
9343              for the pointer.  */
9344
9345           if (constp || volatilep)
9346             {
9347               /* A const or volatile signature pointer/reference is
9348                  pointing to a const or volatile object, i.e., the
9349                  `optr' is const or volatile, respectively, not the
9350                  signature pointer/reference itself.  */
9351               if (! IS_SIGNATURE (type))
9352                 {
9353                   type = cp_build_type_variant (type, constp, volatilep);
9354                   if (IS_AGGR_TYPE (type))
9355                     build_pointer_type (type);
9356                   constp = 0;
9357                   volatilep = 0;
9358                 }
9359             }
9360
9361           if (IS_SIGNATURE (type))
9362             {
9363               if (TREE_CODE (declarator) == ADDR_EXPR)
9364                 {
9365                   if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9366                       && TYPE_SIZE (type))
9367                     cp_warning ("empty signature `%T' used in signature reference declaration",
9368                                 type);
9369 #if 0
9370                   type = build_signature_reference_type (type,
9371                                                          constp, volatilep);
9372 #else
9373                   sorry ("signature reference");
9374                   return NULL_TREE;
9375 #endif
9376                 }
9377               else
9378                 {
9379                   if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9380                       && TYPE_SIZE (type))
9381                     cp_warning ("empty signature `%T' used in signature pointer declaration",
9382                                 type);
9383                   type = build_signature_pointer_type (type,
9384                                                        constp, volatilep);
9385                 }
9386               constp = 0;
9387               volatilep = 0;
9388             }
9389           else if (TREE_CODE (declarator) == ADDR_EXPR)
9390             {
9391               if (TREE_CODE (type) == FUNCTION_TYPE)
9392                 {
9393                   error ("cannot declare references to functions; use pointer to function instead");
9394                   type = build_pointer_type (type);
9395                 }
9396               else
9397                 {
9398                   if (TREE_CODE (type) == VOID_TYPE)
9399                     error ("invalid type: `void &'");
9400                   else
9401                     type = build_reference_type (type);
9402                 }
9403             }
9404           else if (TREE_CODE (type) == METHOD_TYPE)
9405             {
9406               type = build_ptrmemfunc_type (build_pointer_type (type));
9407             }
9408           else
9409             type = build_pointer_type (type);
9410
9411           /* Process a list of type modifier keywords (such as
9412              const or volatile) that were given inside the `*' or `&'.  */
9413
9414           if (TREE_TYPE (declarator))
9415             {
9416               register tree typemodlist;
9417               int erred = 0;
9418               for (typemodlist = TREE_TYPE (declarator); typemodlist;
9419                    typemodlist = TREE_CHAIN (typemodlist))
9420                 {
9421                   if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
9422                     constp++;
9423                   else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
9424                     volatilep++;
9425                   else if (!erred)
9426                     {
9427                       erred = 1;
9428                       error ("invalid type modifier within %s declarator",
9429                              TREE_CODE (declarator) == ADDR_EXPR
9430                              ? "reference" : "pointer");
9431                     }
9432                 }
9433               if (constp > 1)
9434                 pedwarn ("duplicate `const'");
9435               if (volatilep > 1)
9436                 pedwarn ("duplicate `volatile'");
9437               if (TREE_CODE (declarator) == ADDR_EXPR
9438                   && (constp || volatilep))
9439                 {
9440                   if (constp)
9441                     pedwarn ("discarding `const' applied to a reference");
9442                   if (volatilep)
9443                     pedwarn ("discarding `volatile' applied to a reference");
9444                   constp = volatilep = 0;
9445                 }
9446             }
9447           declarator = TREE_OPERAND (declarator, 0);
9448           ctype = NULL_TREE;
9449           break;
9450
9451         case SCOPE_REF:
9452           {
9453             /* We have converted type names to NULL_TREE if the
9454                name was bogus, or to a _TYPE node, if not.
9455
9456                The variable CTYPE holds the type we will ultimately
9457                resolve to.  The code here just needs to build
9458                up appropriate member types.  */
9459             tree sname = TREE_OPERAND (declarator, 1);
9460             tree t;
9461
9462             /* Destructors can have their visibilities changed as well.  */
9463             if (TREE_CODE (sname) == BIT_NOT_EXPR)
9464               sname = TREE_OPERAND (sname, 0);
9465
9466             if (TREE_COMPLEXITY (declarator) == 0)
9467               /* This needs to be here, in case we are called
9468                  multiple times.  */ ;
9469             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
9470               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
9471             else if (! IS_AGGR_TYPE_CODE
9472                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
9473               ;
9474             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
9475               {
9476                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9477                    that refer to ctype.  They couldn't be resolved earlier
9478                    because we hadn't pushed into the class yet.
9479                    Example: resolve 'B<T>::type' in
9480                    'B<typename B<T>::type> B<T>::f () { }'.  */
9481                 if (current_template_parms
9482                     && uses_template_parms (type)
9483                     && uses_template_parms (current_class_type))
9484                   {
9485                     tree args = current_template_args ();
9486                     type = tsubst (type, args, NULL_TREE);
9487                   }
9488
9489                 /* This pop_nested_class corresponds to the
9490                    push_nested_class used to push into class scope for
9491                    parsing the argument list of a function decl, in
9492                    qualified_id.  */
9493                 pop_nested_class (1);
9494                 TREE_COMPLEXITY (declarator) = current_class_depth;
9495               }
9496             else
9497               my_friendly_abort (16);
9498
9499             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
9500               {
9501                 /* We had a reference to a global decl, or
9502                    perhaps we were given a non-aggregate typedef,
9503                    in which case we cleared this out, and should just
9504                    keep going as though it wasn't there.  */
9505                 declarator = sname;
9506                 continue;
9507               }
9508             ctype = TREE_OPERAND (declarator, 0);
9509
9510             t = ctype;
9511             while (t != NULL_TREE)
9512               {
9513                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
9514                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
9515                   template_count += 1;
9516                 t = TYPE_MAIN_DECL (t);
9517                 if (DECL_LANG_SPECIFIC (t))
9518                   t = DECL_CLASS_CONTEXT (t);
9519                 else
9520                   t = NULL_TREE;
9521               }
9522
9523             if (sname == NULL_TREE)
9524               goto done_scoping;
9525
9526             if (TREE_CODE (sname) == IDENTIFIER_NODE)
9527               {
9528                 /* This is the `standard' use of the scoping operator:
9529                    basetype :: member .  */
9530
9531                 if (ctype == current_class_type)
9532                   {
9533                     /* class A {
9534                          void A::f ();
9535                        };
9536
9537                        Is this ill-formed?  */
9538
9539                     if (pedantic)
9540                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
9541                                   ctype, name);
9542                   }
9543                 else if (TREE_CODE (type) == FUNCTION_TYPE)
9544                   {
9545                     if (current_class_type == NULL_TREE
9546                         || friendp)
9547                       type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9548                                                       TREE_TYPE (type), TYPE_ARG_TYPES (type));
9549                     else
9550                       {
9551                         cp_error ("cannot declare member function `%T::%s' within `%T'",
9552                                   ctype, name, current_class_type);
9553                         return void_type_node;
9554                       }
9555                   }
9556                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
9557                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
9558                   {
9559                     /* Have to move this code elsewhere in this function.
9560                        this code is used for i.e., typedef int A::M; M *pm;
9561
9562                        It is?  How? jason 10/2/94 */
9563
9564                     if (current_class_type)
9565                       {
9566                         cp_error ("cannot declare member `%T::%s' within `%T'",
9567                                   ctype, name, current_class_type);
9568                         return void_type_node;
9569                       }
9570                     type = build_offset_type (ctype, type);
9571                   }
9572                 else if (uses_template_parms (ctype))
9573                   {
9574                     if (TREE_CODE (type) == FUNCTION_TYPE)
9575                       type
9576                         = build_cplus_method_type (build_type_variant (ctype,
9577                                                                        constp,
9578                                                                        volatilep),
9579                                                    TREE_TYPE (type),
9580                                                    TYPE_ARG_TYPES (type));
9581                   }
9582                 else
9583                   {
9584                     cp_error ("structure `%T' not yet defined", ctype);
9585                     return error_mark_node;
9586                   }
9587
9588                 declarator = sname;
9589               }
9590             else if (TREE_CODE (sname) == SCOPE_REF)
9591               my_friendly_abort (17);
9592             else
9593               {
9594               done_scoping:
9595                 declarator = TREE_OPERAND (declarator, 1);
9596                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
9597                   /* In this case, we will deal with it later.  */
9598                   ;
9599                 else
9600                   {
9601                     if (TREE_CODE (type) == FUNCTION_TYPE)
9602                       type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
9603                     else
9604                       type = build_offset_type (ctype, type);
9605                   }
9606               }
9607           }
9608           break;
9609
9610         case BIT_NOT_EXPR:
9611           declarator = TREE_OPERAND (declarator, 0);
9612           break;
9613
9614         case RECORD_TYPE:
9615         case UNION_TYPE:
9616         case ENUMERAL_TYPE:
9617           declarator = NULL_TREE;
9618           break;
9619
9620         case ERROR_MARK:
9621           declarator = NULL_TREE;
9622           break;
9623
9624         default:
9625           my_friendly_abort (158);
9626         }
9627     }
9628
9629   if (explicitp == 1)
9630     {
9631       error ("only constructors can be declared `explicit'");
9632       explicitp = 0;
9633     }
9634
9635   /* Now TYPE has the actual type.  */
9636
9637   /* If this is declaring a typedef name, return a TYPE_DECL.  */
9638
9639   if (RIDBIT_SETP (RID_MUTABLE, specbits))
9640     {
9641       if (constp)
9642         {
9643           error ("const `%s' cannot be declared `mutable'", name);
9644           RIDBIT_RESET (RID_MUTABLE, specbits);
9645         }
9646       else if (staticp)
9647         {
9648           error ("static `%s' cannot be declared `mutable'", name);
9649           RIDBIT_RESET (RID_MUTABLE, specbits);
9650         }
9651     }
9652
9653   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
9654     {
9655       tree decl;
9656
9657       /* Note that the grammar rejects storage classes
9658          in typenames, fields or parameters.  */
9659       if (constp || volatilep)
9660         type = cp_build_type_variant (type, constp, volatilep);
9661       if (current_lang_name == lang_name_java)
9662         TYPE_FOR_JAVA (type) = 1;
9663
9664       if (decl_context == FIELD)
9665         {
9666           if (declarator == current_class_name)
9667             cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
9668                         declarator);
9669           decl = build_lang_decl (TYPE_DECL, declarator, type);
9670           if (IS_SIGNATURE (current_class_type) && opaque_typedef)
9671             SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
9672         }
9673       else
9674         {
9675           /* Make sure this typedef lives as long as its type,
9676              since it might be used as a template parameter. */
9677           if (type != error_mark_node)
9678             push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
9679           decl = build_decl (TYPE_DECL, declarator, type);
9680           if (type != error_mark_node)
9681             pop_obstacks ();
9682         }
9683
9684       /* If the user declares "struct {...} foo" then `foo' will have
9685          an anonymous name.  Fill that name in now.  Nothing can
9686          refer to it, so nothing needs know about the name change.
9687          The TYPE_NAME field was filled in by build_struct_xref.  */
9688       if (type != error_mark_node
9689           && !TYPE_READONLY (type) && !TYPE_VOLATILE (type)
9690           && TYPE_NAME (type)
9691           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9692           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
9693         {
9694           /* Replace the anonymous name with the real name everywhere.  */
9695           lookup_tag_reverse (type, declarator);
9696           TYPE_NAME (type) = decl;
9697
9698           if (TYPE_LANG_SPECIFIC (type))
9699             TYPE_WAS_ANONYMOUS (type) = 1;
9700
9701           /* XXX Temporarily set the scope.
9702              When returning, start_decl expects it as NULL_TREE,
9703              and will then then set it using pushdecl. */
9704           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
9705           if (current_class_type)
9706             DECL_CONTEXT (decl) = current_class_type;
9707           else
9708             DECL_CONTEXT (decl) = current_namespace;
9709
9710           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
9711           DECL_ASSEMBLER_NAME (decl)
9712             = get_identifier (build_overload_name (type, 1, 1));
9713           DECL_CONTEXT (decl) = NULL_TREE;
9714         }
9715
9716       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
9717         {
9718           cp_error_at ("typedef name may not be class-qualified", decl);
9719           return NULL_TREE;
9720         }
9721       else if (quals)
9722         {
9723           if (ctype == NULL_TREE)
9724             {
9725               if (TREE_CODE (type) != METHOD_TYPE)
9726                 cp_error_at ("invalid type qualifier for non-method type", decl);
9727               else
9728                 ctype = TYPE_METHOD_BASETYPE (type);
9729             }
9730           if (ctype != NULL_TREE)
9731             grok_method_quals (ctype, decl, quals);
9732         }
9733
9734       if (RIDBIT_SETP (RID_SIGNED, specbits)
9735           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9736         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
9737
9738       if (RIDBIT_SETP (RID_MUTABLE, specbits))
9739         {
9740           error ("non-object member `%s' cannot be declared mutable", name);
9741         }
9742
9743       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
9744                       inlinep, friendp, raises != NULL_TREE);
9745
9746       if (initialized)
9747         error ("typedef declaration includes an initializer");
9748
9749       return decl;
9750     }
9751
9752   /* Detect the case of an array type of unspecified size
9753      which came, as such, direct from a typedef name.
9754      We must copy the type, so that each identifier gets
9755      a distinct type, so that each identifier's size can be
9756      controlled separately by its own initializer.  */
9757
9758   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
9759       && TYPE_DOMAIN (type) == NULL_TREE)
9760     {
9761       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
9762     }
9763
9764   /* If this is a type name (such as, in a cast or sizeof),
9765      compute the type and return it now.  */
9766
9767   if (decl_context == TYPENAME)
9768     {
9769       /* Note that the grammar rejects storage classes
9770          in typenames, fields or parameters.  */
9771       if (constp || volatilep)
9772         {
9773           if (IS_SIGNATURE (type))
9774             error ("`const' or `volatile' specified with signature type");
9775           else
9776             type = cp_build_type_variant (type, constp, volatilep);
9777         }
9778
9779       /* Special case: "friend class foo" looks like a TYPENAME context.  */
9780       if (friendp)
9781         {
9782           if (volatilep)
9783             {
9784               cp_error ("`volatile' specified for friend class declaration");
9785               volatilep = 0;
9786             }
9787           if (inlinep)
9788             {
9789               cp_error ("`inline' specified for friend class declaration");
9790               inlinep = 0;
9791             }
9792
9793           /* Only try to do this stuff if we didn't already give up.  */
9794           if (type != integer_type_node)
9795             {
9796               /* A friendly class?  */
9797               if (current_class_type)
9798                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
9799               else
9800                 error ("trying to make class `%s' a friend of global scope",
9801                        TYPE_NAME_STRING (type));
9802               type = void_type_node;
9803             }
9804         }
9805       else if (quals)
9806         {
9807           tree dummy = build_decl (TYPE_DECL, declarator, type);
9808           if (ctype == NULL_TREE)
9809             {
9810               my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
9811               ctype = TYPE_METHOD_BASETYPE (type);
9812             }
9813           grok_method_quals (ctype, dummy, quals);
9814           type = TREE_TYPE (dummy);
9815         }
9816
9817       return type;
9818     }
9819   else if (declarator == NULL_TREE && decl_context != PARM
9820            && decl_context != CATCHPARM
9821            && TREE_CODE (type) != UNION_TYPE
9822            && ! bitfield)
9823     {
9824       cp_error ("abstract declarator `%T' used as declaration", type);
9825       declarator = make_anon_name ();
9826     }
9827
9828   /* `void' at top level (not within pointer)
9829      is allowed only in typedefs or type names.
9830      We don't complain about parms either, but that is because
9831      a better error message can be made later.  */
9832
9833   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
9834     {
9835       if (! declarator)
9836         error ("unnamed variable or field declared void");
9837       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9838         {
9839           if (IDENTIFIER_OPNAME_P (declarator))
9840             my_friendly_abort (356);
9841           else
9842             error ("variable or field `%s' declared void", name);
9843         }
9844       else
9845         error ("variable or field declared void");
9846       type = integer_type_node;
9847     }
9848
9849   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9850      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
9851
9852   {
9853     register tree decl;
9854
9855     if (decl_context == PARM)
9856       {
9857         if (ctype)
9858           error ("cannot use `::' in parameter declaration");
9859
9860         /* A parameter declared as an array of T is really a pointer to T.
9861            One declared as a function is really a pointer to a function.
9862            One declared as a member is really a pointer to member.  */
9863
9864         if (TREE_CODE (type) == ARRAY_TYPE)
9865           {
9866             /* Transfer const-ness of array into that of type pointed to.  */
9867             type = build_pointer_type
9868               (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
9869             volatilep = constp = 0;
9870           }
9871         else if (TREE_CODE (type) == FUNCTION_TYPE)
9872           type = build_pointer_type (type);
9873         else if (TREE_CODE (type) == OFFSET_TYPE)
9874           type = build_pointer_type (type);
9875         else if (TREE_CODE (type) == VOID_TYPE && declarator)
9876           {
9877             error ("declaration of `%s' as void", name);
9878             return NULL_TREE;
9879           }
9880
9881         decl = build_decl (PARM_DECL, declarator, complete_type (type));
9882
9883         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
9884                         inlinep, friendp, raises != NULL_TREE);
9885         if (current_class_type
9886             && IS_SIGNATURE (current_class_type))
9887           {
9888             if (inlinep)
9889               error ("parameter of signature member function declared `inline'");
9890             if (RIDBIT_SETP (RID_AUTO, specbits))
9891               error ("parameter of signature member function declared `auto'");
9892             if (RIDBIT_SETP (RID_REGISTER, specbits))
9893               error ("parameter of signature member function declared `register'");
9894           }
9895
9896         /* Compute the type actually passed in the parmlist,
9897            for the case where there is no prototype.
9898            (For example, shorts and chars are passed as ints.)
9899            When there is a prototype, this is overridden later.  */
9900
9901         DECL_ARG_TYPE (decl) = type_promotes_to (type);
9902       }
9903     else if (decl_context == FIELD)
9904       {
9905         if (type == error_mark_node)
9906           {
9907             /* Happens when declaring arrays of sizes which
9908                are error_mark_node, for example.  */
9909             decl = NULL_TREE;
9910           }
9911         else if (TREE_CODE (type) == FUNCTION_TYPE)
9912           {
9913             int publicp = 0;
9914             tree function_context;
9915
9916             /* We catch the others as conflicts with the builtin
9917                typedefs.  */
9918             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
9919               {
9920                 cp_error ("function `%D' cannot be declared friend",
9921                           declarator);
9922                 friendp = 0;
9923               }
9924
9925             if (friendp == 0)
9926               {
9927                 if (ctype == NULL_TREE)
9928                   ctype = current_class_type;
9929
9930                 if (ctype == NULL_TREE)
9931                   {
9932                     cp_error ("can't make `%D' into a method -- not in a class",
9933                               declarator);
9934                     return void_type_node;
9935                   }
9936
9937                 /* ``A union may [ ... ] not [ have ] virtual functions.''
9938                    ARM 9.5 */
9939                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9940                   {
9941                     cp_error ("function `%D' declared virtual inside a union",
9942                               declarator);
9943                     return void_type_node;
9944                   }
9945
9946                 if (declarator == ansi_opname[(int) NEW_EXPR]
9947                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
9948                     || declarator == ansi_opname[(int) DELETE_EXPR]
9949                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
9950                   {
9951                     if (virtualp)
9952                       {
9953                         cp_error ("`%D' cannot be declared virtual, since it is always static",
9954                                   declarator);
9955                         virtualp = 0;
9956                       }
9957                   }
9958                 else if (staticp < 2)
9959                   type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9960                                                   TREE_TYPE (type), TYPE_ARG_TYPES (type));
9961               }
9962
9963             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
9964             function_context = (ctype != NULL_TREE) ?
9965               hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9966             publicp = (! friendp || ! staticp)
9967               && function_context == NULL_TREE;
9968             decl = grokfndecl (ctype, type,
9969                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
9970                                ? declarator : dname,
9971                                declarator,
9972                                virtualp, flags, quals, raises, attrlist,
9973                                friendp ? -1 : 0, friendp, publicp, inlinep,
9974                                funcdef_flag, template_count, in_namespace);
9975             if (decl == NULL_TREE)
9976               return NULL_TREE;
9977 #if 0
9978             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
9979             /* The decl and setting of decl_machine_attr is also turned off.  */
9980             decl = build_decl_attribute_variant (decl, decl_machine_attr);
9981 #endif
9982
9983             if (explicitp == 2)
9984               DECL_NONCONVERTING_P (decl) = 1;
9985           }
9986         else if (TREE_CODE (type) == METHOD_TYPE)
9987           {
9988             /* We only get here for friend declarations of
9989                members of other classes.  */
9990             /* All method decls are public, so tell grokfndecl to set
9991                TREE_PUBLIC, also.  */
9992             decl = grokfndecl (ctype, type, declarator, declarator,
9993                                virtualp, flags, quals, raises, attrlist,
9994                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
9995                                template_count, in_namespace);
9996             if (decl == NULL_TREE)
9997               return NULL_TREE;
9998           }
9999         else if (!staticp && ! processing_template_decl
10000                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
10001                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10002           {
10003             if (declarator)
10004               cp_error ("field `%D' has incomplete type", declarator);
10005             else
10006               cp_error ("name `%T' has incomplete type", type);
10007
10008             /* If we're instantiating a template, tell them which
10009                instantiation made the field's type be incomplete.  */
10010             if (current_class_type
10011                 && TYPE_NAME (current_class_type)
10012                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
10013                 && declspecs && TREE_VALUE (declspecs)
10014                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
10015               cp_error ("  in instantiation of template `%T'",
10016                         current_class_type);
10017
10018             type = error_mark_node;
10019             decl = NULL_TREE;
10020           }
10021         else
10022           {
10023             if (friendp)
10024               {
10025                 error ("`%s' is neither function nor method; cannot be declared friend",
10026                        IDENTIFIER_POINTER (declarator));
10027                 friendp = 0;
10028               }
10029             decl = NULL_TREE;
10030           }
10031
10032         if (friendp)
10033           {
10034             /* Friends are treated specially.  */
10035             if (ctype == current_class_type)
10036               warning ("member functions are implicitly friends of their class");
10037             else
10038               {
10039                 tree t = NULL_TREE;
10040                 if (decl && DECL_NAME (decl))
10041                   t = do_friend (ctype, declarator, decl,
10042                                  last_function_parms, flags, quals,
10043                                  funcdef_flag);
10044                 if (t && funcdef_flag)
10045                   return t;
10046
10047                 return void_type_node;
10048               }
10049           }
10050
10051         /* Structure field.  It may not be a function, except for C++ */
10052
10053         if (decl == NULL_TREE)
10054           {
10055             if (initialized)
10056               {
10057                 if (!staticp)
10058                   {
10059                     /* An attempt is being made to initialize a non-static
10060                        member.  But, from [class.mem]:
10061
10062                        4 A member-declarator can contain a
10063                        constant-initializer only if it declares a static
10064                        member (_class.static_) of integral or enumeration
10065                        type, see _class.static.data_.
10066
10067                        This used to be relatively common practice, but
10068                        the rest of the compiler does not correctly
10069                        handle the initialization unless the member is
10070                        static so we make it static below.  */
10071                     cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
10072                                 constp ? "const member" : "member",
10073                                 declarator);
10074                     cp_pedwarn ("making `%D' static", declarator);
10075                     staticp = 1;
10076                   }
10077
10078                 /* Motion 10 at San Diego: If a static const integral data
10079                    member is initialized with an integral constant
10080                    expression, the initializer may appear either in the
10081                    declaration (within the class), or in the definition,
10082                    but not both.  If it appears in the class, the member is
10083                    a member constant.  The file-scope definition is always
10084                    required.  */
10085                 if (! constp)
10086                   /* According to Mike Stump, we generate bad code for
10087                      this case, so we might as well always make it an
10088                      error.  */
10089                   cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
10090                             declarator);
10091
10092                 if (pedantic && ! INTEGRAL_TYPE_P (type)
10093                     && !uses_template_parms (type))
10094                   cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator, type);
10095               }
10096
10097             if (staticp)
10098               {
10099                 /* ANSI C++ Apr '95 wp 9.2 */
10100                 if (declarator == current_class_name)
10101                   cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10102                               declarator);
10103
10104                 /* C++ allows static class members.
10105                    All other work for this is done by grokfield.
10106                    This VAR_DECL is built by build_lang_field_decl.
10107                    All other VAR_DECLs are built by build_decl.  */
10108                 decl = build_lang_field_decl (VAR_DECL, declarator, type);
10109                 TREE_STATIC (decl) = 1;
10110                 /* In class context, 'static' means public access.  */
10111                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
10112               }
10113             else
10114               {
10115                 decl = build_lang_field_decl (FIELD_DECL, declarator, type);
10116                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10117                   {
10118                     DECL_MUTABLE_P (decl) = 1;
10119                     RIDBIT_RESET (RID_MUTABLE, specbits);
10120                   }
10121               }
10122
10123             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
10124                             inlinep, friendp, raises != NULL_TREE);
10125           }
10126       }
10127     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
10128       {
10129         tree original_name;
10130         int publicp = 0;
10131
10132         if (! declarator)
10133           return NULL_TREE;
10134
10135         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10136           original_name = dname;
10137         else
10138           original_name = declarator;
10139
10140         if (RIDBIT_SETP (RID_AUTO, specbits))
10141           error ("storage class `auto' invalid for function `%s'", name);
10142         else if (RIDBIT_SETP (RID_REGISTER, specbits))
10143           error ("storage class `register' invalid for function `%s'", name);
10144
10145         /* Function declaration not at top level.
10146            Storage classes other than `extern' are not allowed
10147            and `extern' makes no difference.  */
10148         if (! toplevel_bindings_p ()
10149             && (RIDBIT_SETP (RID_STATIC, specbits)
10150                 || RIDBIT_SETP (RID_INLINE, specbits))
10151             && pedantic)
10152           {
10153             if (RIDBIT_SETP (RID_STATIC, specbits))
10154               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
10155             else
10156               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
10157           }
10158
10159         if (ctype == NULL_TREE)
10160           {
10161             if (virtualp)
10162               {
10163                 error ("virtual non-class function `%s'", name);
10164                 virtualp = 0;
10165               }
10166
10167             if (current_lang_name == lang_name_cplusplus
10168                 && ! processing_template_decl
10169                 && ! MAIN_NAME_P (original_name)
10170                 && ! (IDENTIFIER_LENGTH (original_name) > 10
10171                       && IDENTIFIER_POINTER (original_name)[0] == '_'
10172                       && IDENTIFIER_POINTER (original_name)[1] == '_'
10173                       && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
10174               /* Plain overloading: will not be grok'd by grokclassfn.  */
10175               if (name_mangling_version < 1
10176                   || TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10177                 declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
10178           }
10179         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
10180           type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
10181                                           TREE_TYPE (type), TYPE_ARG_TYPES (type));
10182
10183         /* Record presence of `static'.  */
10184         publicp = (ctype != NULL_TREE
10185                    || RIDBIT_SETP (RID_EXTERN, specbits)
10186                    || !RIDBIT_SETP (RID_STATIC, specbits));
10187
10188         decl = grokfndecl (ctype, type, original_name, declarator,
10189                            virtualp, flags, quals, raises, attrlist,
10190                            1, friendp,
10191                            publicp, inlinep, funcdef_flag,
10192                            template_count, in_namespace);
10193         if (decl == NULL_TREE)
10194           return NULL_TREE;
10195
10196         /* Among other times, could occur from check_explicit_specialization
10197            returning an error_mark_node.  */
10198         if (decl == error_mark_node)
10199           return error_mark_node;
10200
10201         if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c
10202             && (! DECL_USE_TEMPLATE (decl) ||
10203                 name_mangling_version < 1))
10204           DECL_ASSEMBLER_NAME (decl) = declarator;
10205
10206         if (staticp == 1)
10207           {
10208             int illegal_static = 0;
10209
10210             /* Don't allow a static member function in a class, and forbid
10211                declaring main to be static.  */
10212             if (TREE_CODE (type) == METHOD_TYPE)
10213               {
10214                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
10215                 illegal_static = 1;
10216               }
10217             else if (current_function_decl)
10218               {
10219                 /* FIXME need arm citation */
10220                 error ("cannot declare static function inside another function");
10221                 illegal_static = 1;
10222               }
10223
10224             if (illegal_static)
10225               {
10226                 staticp = 0;
10227                 RIDBIT_RESET (RID_STATIC, specbits);
10228               }
10229           }
10230       }
10231     else
10232       {
10233         /* It's a variable.  */
10234
10235         if (decl_context == CATCHPARM)
10236           {
10237             if (ctype)
10238               {
10239                 ctype = NULL_TREE;
10240                 error ("cannot use `::' in parameter declaration");
10241               }
10242
10243             /* A parameter declared as an array of T is really a pointer to T.
10244                One declared as a function is really a pointer to a function.
10245                One declared as a member is really a pointer to member.  */
10246
10247             if (TREE_CODE (type) == ARRAY_TYPE)
10248               {
10249                 /* Transfer const-ness of array into that of type
10250                    pointed to.  */
10251                 type = build_pointer_type
10252                   (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
10253                 volatilep = constp = 0;
10254               }
10255             else if (TREE_CODE (type) == FUNCTION_TYPE)
10256               type = build_pointer_type (type);
10257             else if (TREE_CODE (type) == OFFSET_TYPE)
10258               type = build_pointer_type (type);
10259           }
10260
10261         /* An uninitialized decl with `extern' is a reference.  */
10262         decl = grokvardecl (type, declarator, &specbits,
10263                             initialized, constp, in_namespace);
10264         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
10265                         inlinep, friendp, raises != NULL_TREE);
10266
10267         if (ctype)
10268           {
10269             DECL_CONTEXT (decl) = ctype;
10270             if (staticp == 1)
10271               {
10272                 cp_pedwarn ("static member `%D' re-declared as static", decl);
10273                 staticp = 0;
10274                 RIDBIT_RESET (RID_STATIC, specbits);
10275               }
10276             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
10277               {
10278                 cp_error ("static member `%D' declared `register'", decl);
10279                 RIDBIT_RESET (RID_REGISTER, specbits);
10280               }
10281             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
10282               {
10283                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10284                             decl);
10285                 RIDBIT_RESET (RID_EXTERN, specbits);
10286               }
10287           }
10288       }
10289
10290     if (RIDBIT_SETP (RID_MUTABLE, specbits))
10291       {
10292         error ("`%s' cannot be declared mutable", name);
10293       }
10294
10295     /* Record `register' declaration for warnings on &
10296        and in case doing stupid register allocation.  */
10297
10298     if (RIDBIT_SETP (RID_REGISTER, specbits))
10299       DECL_REGISTER (decl) = 1;
10300
10301     if (RIDBIT_SETP (RID_EXTERN, specbits))
10302       DECL_THIS_EXTERN (decl) = 1;
10303
10304     if (RIDBIT_SETP (RID_STATIC, specbits))
10305       DECL_THIS_STATIC (decl) = 1;
10306
10307     /* Record constancy and volatility.  */
10308
10309     if (constp)
10310       TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
10311     if (volatilep)
10312       {
10313         TREE_SIDE_EFFECTS (decl) = 1;
10314         TREE_THIS_VOLATILE (decl) = 1;
10315       }
10316
10317     return decl;
10318   }
10319 }
10320 \f
10321 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10322    An empty exprlist is a parmlist.  An exprlist which
10323    contains only identifiers at the global level
10324    is a parmlist.  Otherwise, it is an exprlist.  */
10325
10326 int
10327 parmlist_is_exprlist (exprs)
10328      tree exprs;
10329 {
10330   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
10331     return 0;
10332
10333   if (toplevel_bindings_p ())
10334     {
10335       /* At the global level, if these are all identifiers,
10336          then it is a parmlist.  */
10337       while (exprs)
10338         {
10339           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
10340             return 1;
10341           exprs = TREE_CHAIN (exprs);
10342         }
10343       return 0;
10344     }
10345   return 1;
10346 }
10347
10348 /* Subroutine of `grokparms'.  In a fcn definition, arg types must
10349    be complete.
10350
10351    C++: also subroutine of `start_function'.  */
10352
10353 static void
10354 require_complete_types_for_parms (parms)
10355      tree parms;
10356 {
10357   if (processing_template_decl)
10358     return;
10359
10360   while (parms)
10361     {
10362       tree type = TREE_TYPE (parms);
10363       if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
10364         {
10365           if (DECL_NAME (parms))
10366             error ("parameter `%s' has incomplete type",
10367                    IDENTIFIER_POINTER (DECL_NAME (parms)));
10368           else
10369             error ("parameter has incomplete type");
10370           TREE_TYPE (parms) = error_mark_node;
10371         }
10372 #if 0
10373       /* If the arg types are incomplete in a declaration,
10374          they must include undefined tags.
10375          These tags can never be defined in the scope of the declaration,
10376          so the types can never be completed,
10377          and no call can be compiled successfully.  */
10378       /* This is not the right behavior for C++, but not having
10379          it is also probably wrong.  */
10380       else
10381         {
10382           /* Now warn if is a pointer to an incomplete type.  */
10383           while (TREE_CODE (type) == POINTER_TYPE
10384                  || TREE_CODE (type) == REFERENCE_TYPE)
10385             type = TREE_TYPE (type);
10386           type = TYPE_MAIN_VARIANT (type);
10387           if (TYPE_SIZE (type) == NULL_TREE)
10388             {
10389               if (DECL_NAME (parm) != NULL_TREE)
10390                 warning ("parameter `%s' points to incomplete type",
10391                          IDENTIFIER_POINTER (DECL_NAME (parm)));
10392               else
10393                 warning ("parameter points to incomplete type");
10394             }
10395         }
10396 #endif
10397       parms = TREE_CHAIN (parms);
10398     }
10399 }
10400
10401 /* Decode the list of parameter types for a function type.
10402    Given the list of things declared inside the parens,
10403    return a list of types.
10404
10405    The list we receive can have three kinds of elements:
10406    an IDENTIFIER_NODE for names given without types,
10407    a TREE_LIST node for arguments given as typespecs or names with typespecs,
10408    or void_type_node, to mark the end of an argument list
10409    when additional arguments are not permitted (... was not used).
10410
10411    FUNCDEF_FLAG is nonzero for a function definition, 0 for
10412    a mere declaration.  A nonempty identifier-list gets an error message
10413    when FUNCDEF_FLAG is zero.
10414    If FUNCDEF_FLAG is 1, then parameter types must be complete.
10415    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10416
10417    If all elements of the input list contain types,
10418    we return a list of the types.
10419    If all elements contain no type (except perhaps a void_type_node
10420    at the end), we return a null list.
10421    If some have types and some do not, it is an error, and we
10422    return a null list.
10423
10424    Also set last_function_parms to either
10425    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10426    A list of names is converted to a chain of PARM_DECLs
10427    by store_parm_decls so that ultimately it is always a chain of decls.
10428
10429    Note that in C++, parameters can take default values.  These default
10430    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
10431    an error to specify default values which are followed by parameters
10432    that have no default values, or an ELLIPSES.  For simplicities sake,
10433    only parameters which are specified with their types can take on
10434    default values.  */
10435
10436 static tree
10437 grokparms (first_parm, funcdef_flag)
10438      tree first_parm;
10439      int funcdef_flag;
10440 {
10441   tree result = NULL_TREE;
10442   tree decls = NULL_TREE;
10443
10444   if (first_parm != NULL_TREE
10445       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
10446     {
10447       if (! funcdef_flag)
10448         pedwarn ("parameter names (without types) in function declaration");
10449       last_function_parms = first_parm;
10450       return NULL_TREE;
10451     }
10452   else if (first_parm != NULL_TREE
10453            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
10454            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
10455     my_friendly_abort (145);
10456   else
10457     {
10458       /* Types were specified.  This is a list of declarators
10459          each represented as a TREE_LIST node.  */
10460       register tree parm, chain;
10461       int any_init = 0, any_error = 0;
10462
10463       if (first_parm != NULL_TREE)
10464         {
10465           tree last_result = NULL_TREE;
10466           tree last_decl = NULL_TREE;
10467
10468           for (parm = first_parm; parm != NULL_TREE; parm = chain)
10469             {
10470               tree type = NULL_TREE, list_node = parm;
10471               register tree decl = TREE_VALUE (parm);
10472               tree init = TREE_PURPOSE (parm);
10473
10474               chain = TREE_CHAIN (parm);
10475               /* @@ weak defense against parse errors.  */
10476               if (TREE_CODE (decl) != VOID_TYPE
10477                   && TREE_CODE (decl) != TREE_LIST)
10478                 {
10479                   /* Give various messages as the need arises.  */
10480                   if (TREE_CODE (decl) == STRING_CST)
10481                     cp_error ("invalid string constant `%E'", decl);
10482                   else if (TREE_CODE (decl) == INTEGER_CST)
10483                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
10484                   continue;
10485                 }
10486
10487               if (TREE_CODE (decl) != VOID_TYPE)
10488                 {
10489                   decl = grokdeclarator (TREE_VALUE (decl),
10490                                          TREE_PURPOSE (decl),
10491                                          PARM, init != NULL_TREE,
10492                                          NULL_TREE);
10493                   if (! decl)
10494                     continue;
10495                   type = TREE_TYPE (decl);
10496                   if (TREE_CODE (type) == VOID_TYPE)
10497                     decl = void_type_node;
10498                   else if (TREE_CODE (type) == METHOD_TYPE)
10499                     {
10500                       if (DECL_NAME (decl))
10501                         /* Cannot use the decl here because
10502                            we don't have DECL_CONTEXT set up yet.  */
10503                         cp_error ("parameter `%D' invalidly declared method type",
10504                                   DECL_NAME (decl));
10505                       else
10506                         error ("parameter invalidly declared method type");
10507                       type = build_pointer_type (type);
10508                       TREE_TYPE (decl) = type;
10509                     }
10510                   else if (TREE_CODE (type) == OFFSET_TYPE)
10511                     {
10512                       if (DECL_NAME (decl))
10513                         cp_error ("parameter `%D' invalidly declared offset type",
10514                                   DECL_NAME (decl));
10515                       else
10516                         error ("parameter invalidly declared offset type");
10517                       type = build_pointer_type (type);
10518                       TREE_TYPE (decl) = type;
10519                     }
10520                   else if (TREE_CODE (type) == RECORD_TYPE
10521                            && TYPE_LANG_SPECIFIC (type)
10522                            && CLASSTYPE_ABSTRACT_VIRTUALS (type))
10523                     {
10524                       abstract_virtuals_error (decl, type);
10525                       any_error = 1;  /* Seems like a good idea. */
10526                     }
10527                   else if (TREE_CODE (type) == RECORD_TYPE
10528                            && TYPE_LANG_SPECIFIC (type)
10529                            && IS_SIGNATURE (type))
10530                     {
10531                       signature_error (decl, type);
10532                       any_error = 1;  /* Seems like a good idea. */
10533                     }
10534                 }
10535
10536               if (TREE_CODE (decl) == VOID_TYPE)
10537                 {
10538                   if (result == NULL_TREE)
10539                     {
10540                       result = void_list_node;
10541                       last_result = result;
10542                     }
10543                   else
10544                     {
10545                       TREE_CHAIN (last_result) = void_list_node;
10546                       last_result = void_list_node;
10547                     }
10548                   if (chain
10549                       && (chain != void_list_node || TREE_CHAIN (chain)))
10550                     error ("`void' in parameter list must be entire list");
10551                   break;
10552                 }
10553
10554               /* Since there is a prototype, args are passed in their own types.  */
10555               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
10556 #ifdef PROMOTE_PROTOTYPES
10557               if ((TREE_CODE (type) == INTEGER_TYPE
10558                    || TREE_CODE (type) == ENUMERAL_TYPE)
10559                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
10560                 DECL_ARG_TYPE (decl) = integer_type_node;
10561 #endif
10562               if (!any_error)
10563                 {
10564                   if (init)
10565                     {
10566                       any_init++;
10567                       if (TREE_CODE (init) == SAVE_EXPR)
10568                         PARM_DECL_EXPR (init) = 1;
10569                       else if (processing_template_decl)
10570                         ;
10571                       /* Unparsed default arg from in-class decl.  */
10572                       else if (TREE_CODE (init) == DEFAULT_ARG)
10573                         ;
10574                       else if (TREE_CODE (init) == VAR_DECL
10575                                || TREE_CODE (init) == PARM_DECL)
10576                         {
10577                           if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
10578                             {
10579                               /* ``Local variables may not be used in default
10580                                  argument expressions.'' dpANSI C++ 8.2.6 */
10581                               /* If extern int i; within a function is not
10582                                  considered a local variable, then this code is
10583                                  wrong.  */
10584                               cp_error ("local variable `%D' may not be used as a default argument", init);
10585                               any_error = 1;
10586                             }
10587                           else if (TREE_READONLY_DECL_P (init))
10588                             init = decl_constant_value (init);
10589                         }
10590                       else
10591                         init = require_instantiated_type (type, init, integer_zero_node);
10592                       if (! processing_template_decl
10593                           && init != error_mark_node
10594                           && TREE_CODE (init) != DEFAULT_ARG
10595                           && ! can_convert_arg (type, TREE_TYPE (init), init))
10596                         cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
10597                                     TREE_TYPE (init), decl);
10598                     }
10599                 }
10600               else
10601                 init = NULL_TREE;
10602
10603               if (decls == NULL_TREE)
10604                 {
10605                   decls = decl;
10606                   last_decl = decls;
10607                 }
10608               else
10609                 {
10610                   TREE_CHAIN (last_decl) = decl;
10611                   last_decl = decl;
10612                 }
10613               if (! current_function_decl && TREE_PERMANENT (list_node))
10614                 {
10615                   TREE_PURPOSE (list_node) = init;
10616                   TREE_VALUE (list_node) = type;
10617                   TREE_CHAIN (list_node) = NULL_TREE;
10618                 }
10619               else
10620                 list_node = saveable_tree_cons (init, type, NULL_TREE);
10621               if (result == NULL_TREE)
10622                 {
10623                   result = list_node;
10624                   last_result = result;
10625                 }
10626               else
10627                 {
10628                   TREE_CHAIN (last_result) = list_node;
10629                   last_result = list_node;
10630                 }
10631             }
10632           if (last_result)
10633             TREE_CHAIN (last_result) = NULL_TREE;
10634           /* If there are no parameters, and the function does not end
10635              with `...', then last_decl will be NULL_TREE.  */
10636           if (last_decl != NULL_TREE)
10637             TREE_CHAIN (last_decl) = NULL_TREE;
10638         }
10639     }
10640
10641   last_function_parms = decls;
10642
10643   /* In a fcn definition, arg types must be complete.  */
10644   if (funcdef_flag > 0)
10645     require_complete_types_for_parms (last_function_parms);
10646
10647   return result;
10648 }
10649
10650 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
10651    FUNCTION_TYPE with the newly parsed version of its default argument, which
10652    was previously digested as text.  See snarf_defarg et al in lex.c.  */
10653
10654 void
10655 replace_defarg (arg, init)
10656      tree arg, init;
10657 {
10658   if (! processing_template_decl
10659       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
10660     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
10661                 TREE_TYPE (init), TREE_VALUE (arg));
10662   TREE_PURPOSE (arg) = init;
10663 }
10664 \f
10665 int
10666 copy_args_p (d)
10667      tree d;
10668 {
10669   tree t = FUNCTION_ARG_CHAIN (d);
10670   if (DECL_CONSTRUCTOR_P (d)
10671       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
10672     t = TREE_CHAIN (t);
10673   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
10674       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
10675           == DECL_CLASS_CONTEXT (d))
10676       && (TREE_CHAIN (t) == NULL_TREE
10677           || TREE_CHAIN (t) == void_list_node
10678           || TREE_PURPOSE (TREE_CHAIN (t))))
10679     return 1;
10680   return 0;
10681 }
10682
10683 /* These memoizing functions keep track of special properties which
10684    a class may have.  `grok_ctor_properties' notices whether a class
10685    has a constructor of the form X(X&), and also complains
10686    if the class has a constructor of the form X(X).
10687    `grok_op_properties' takes notice of the various forms of
10688    operator= which are defined, as well as what sorts of type conversion
10689    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
10690
10691 int
10692 grok_ctor_properties (ctype, decl)
10693      tree ctype, decl;
10694 {
10695   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
10696   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
10697
10698   /* When a type has virtual baseclasses, a magical first int argument is
10699      added to any ctor so we can tell if the class has been initialized
10700      yet.  This could screw things up in this function, so we deliberately
10701      ignore the leading int if we're in that situation.  */
10702   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
10703     {
10704       my_friendly_assert (parmtypes
10705                           && TREE_VALUE (parmtypes) == integer_type_node,
10706                           980529);
10707       parmtypes = TREE_CHAIN (parmtypes);
10708       parmtype = TREE_VALUE (parmtypes);
10709     }
10710
10711   if (TREE_CODE (parmtype) == REFERENCE_TYPE
10712       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
10713       && (TREE_CHAIN (parmtypes) == NULL_TREE
10714           || TREE_CHAIN (parmtypes) == void_list_node
10715           || TREE_PURPOSE (TREE_CHAIN (parmtypes))))
10716     {
10717       TYPE_HAS_INIT_REF (ctype) = 1;
10718       if (TYPE_READONLY (TREE_TYPE (parmtype)))
10719         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
10720     }
10721   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
10722            && TREE_CHAIN (parmtypes) != NULL_TREE
10723            && TREE_CHAIN (parmtypes) == void_list_node)
10724     {
10725       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
10726                 ctype, ctype);
10727       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
10728       return 0;
10729     }
10730   else if (TREE_CODE (parmtype) == VOID_TYPE
10731            || TREE_PURPOSE (parmtypes) != NULL_TREE)
10732     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
10733
10734   return 1;
10735 }
10736
10737 /* An operator with this name can be either unary or binary.  */
10738
10739 static int
10740 ambi_op_p (name)
10741      tree name;
10742 {
10743   return (name == ansi_opname [(int) INDIRECT_REF]
10744           || name == ansi_opname [(int) ADDR_EXPR]
10745           || name == ansi_opname [(int) NEGATE_EXPR]
10746           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
10747           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
10748           || name == ansi_opname [(int) CONVERT_EXPR]);
10749 }
10750
10751 /* An operator with this name can only be unary.  */
10752
10753 static int
10754 unary_op_p (name)
10755      tree name;
10756 {
10757   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
10758           || name == ansi_opname [(int) BIT_NOT_EXPR]
10759           || name == ansi_opname [(int) COMPONENT_REF]
10760           || OPERATOR_TYPENAME_P (name));
10761 }
10762
10763 /* Do a little sanity-checking on how they declared their operator.  */
10764
10765 void
10766 grok_op_properties (decl, virtualp, friendp)
10767      tree decl;
10768      int virtualp, friendp;
10769 {
10770   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10771   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10772   tree name = DECL_NAME (decl);
10773
10774   if (current_class_type == NULL_TREE)
10775     friendp = 1;
10776
10777   if (! friendp)
10778     {
10779       if (name == ansi_opname[(int) MODIFY_EXPR])
10780         TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
10781       else if (name == ansi_opname[(int) CALL_EXPR])
10782         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
10783       else if (name == ansi_opname[(int) ARRAY_REF])
10784         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
10785       else if (name == ansi_opname[(int) COMPONENT_REF]
10786                || name == ansi_opname[(int) MEMBER_REF])
10787         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
10788       else if (name == ansi_opname[(int) NEW_EXPR])
10789         TYPE_GETS_NEW (current_class_type) |= 1;
10790       else if (name == ansi_opname[(int) DELETE_EXPR])
10791         TYPE_GETS_DELETE (current_class_type) |= 1;
10792       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
10793         TYPE_GETS_NEW (current_class_type) |= 2;
10794       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
10795         TYPE_GETS_DELETE (current_class_type) |= 2;
10796     }
10797
10798   if (name == ansi_opname[(int) NEW_EXPR]
10799       || name == ansi_opname[(int) VEC_NEW_EXPR])
10800     {
10801       /* When the compiler encounters the definition of A::operator new, it
10802          doesn't look at the class declaration to find out if it's static.  */
10803       if (methodp)
10804         revert_static_member_fn (&decl, NULL, NULL);
10805
10806       /* Take care of function decl if we had syntax errors.  */
10807       if (argtypes == NULL_TREE)
10808         TREE_TYPE (decl)
10809           = build_function_type (ptr_type_node,
10810                                  hash_tree_chain (integer_type_node,
10811                                                   void_list_node));
10812       else
10813         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10814     }
10815   else if (name == ansi_opname[(int) DELETE_EXPR]
10816            || name == ansi_opname[(int) VEC_DELETE_EXPR])
10817     {
10818       if (methodp)
10819         revert_static_member_fn (&decl, NULL, NULL);
10820
10821       if (argtypes == NULL_TREE)
10822         TREE_TYPE (decl)
10823           = build_function_type (void_type_node,
10824                                  hash_tree_chain (ptr_type_node,
10825                                                   void_list_node));
10826       else
10827         {
10828           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10829
10830           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
10831               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
10832                   != void_list_node))
10833             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
10834         }
10835     }
10836   else
10837     {
10838       /* An operator function must either be a non-static member function
10839          or have at least one parameter of a class, a reference to a class,
10840          an enumeration, or a reference to an enumeration.  13.4.0.6 */
10841       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10842         {
10843           if (OPERATOR_TYPENAME_P (name)
10844               || name == ansi_opname[(int) CALL_EXPR]
10845               || name == ansi_opname[(int) MODIFY_EXPR]
10846               || name == ansi_opname[(int) COMPONENT_REF]
10847               || name == ansi_opname[(int) ARRAY_REF])
10848             cp_error ("`%D' must be a nonstatic member function", decl);
10849           else
10850             {
10851               tree p = argtypes;
10852
10853               if (DECL_STATIC_FUNCTION_P (decl))
10854                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
10855
10856               if (p)
10857                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
10858                   {
10859                     tree arg = TREE_VALUE (p);
10860                     if (TREE_CODE (arg) == REFERENCE_TYPE)
10861                       arg = TREE_TYPE (arg);
10862
10863                     /* This lets bad template code slip through.  */
10864                     if (IS_AGGR_TYPE (arg)
10865                         || TREE_CODE (arg) == ENUMERAL_TYPE
10866                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
10867                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
10868                       goto foundaggr;
10869                   }
10870               cp_error
10871                 ("`%D' must have an argument of class or enumerated type",
10872                  decl);
10873             foundaggr:
10874               ;
10875             }
10876         }
10877
10878       if (name == ansi_opname[(int) CALL_EXPR])
10879         return;                 /* No restrictions on args. */
10880
10881       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
10882         {
10883           tree t = TREE_TYPE (name);
10884           if (TREE_CODE (t) == VOID_TYPE)
10885             pedwarn ("void is not a valid type conversion operator");
10886           else if (! friendp)
10887             {
10888               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10889               char *what = 0;
10890               if (ref)
10891                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10892
10893               if (t == current_class_type)
10894                 what = "the same type";
10895               /* Don't force t to be complete here.  */
10896               else if (IS_AGGR_TYPE (t)
10897                        && TYPE_SIZE (t)
10898                        && DERIVED_FROM_P (t, current_class_type))
10899                 what = "a base class";
10900
10901               if (what)
10902                 warning ("conversion to %s%s will never use a type conversion operator",
10903                          ref ? "a reference to " : "", what);
10904             }
10905         }
10906
10907       if (name == ansi_opname[(int) MODIFY_EXPR])
10908         {
10909           tree parmtype;
10910
10911           if (list_length (argtypes) != 3 && methodp)
10912             {
10913               cp_error ("`%D' must take exactly one argument", decl);
10914               return;
10915             }
10916           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
10917
10918           if (copy_assignment_arg_p (parmtype, virtualp)
10919               && ! friendp)
10920             {
10921               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
10922               if (TREE_CODE (parmtype) != REFERENCE_TYPE
10923                   || TYPE_READONLY (TREE_TYPE (parmtype)))
10924                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
10925             }
10926         }
10927       else if (name == ansi_opname[(int) COND_EXPR])
10928         {
10929           /* 13.4.0.3 */
10930           pedwarn ("ANSI C++ prohibits overloading operator ?:");
10931           if (list_length (argtypes) != 4)
10932             cp_error ("`%D' must take exactly three arguments", decl);
10933         }
10934       else if (ambi_op_p (name))
10935         {
10936           if (list_length (argtypes) == 2)
10937             /* prefix */;
10938           else if (list_length (argtypes) == 3)
10939             {
10940               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
10941                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
10942                   && ! processing_template_decl
10943                   && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
10944                 {
10945                   if (methodp)
10946                     cp_error ("postfix `%D' must take `int' as its argument",
10947                               decl);
10948                   else
10949                     cp_error
10950                       ("postfix `%D' must take `int' as its second argument",
10951                        decl);
10952                 }
10953             }
10954           else
10955             {
10956               if (methodp)
10957                 cp_error ("`%D' must take either zero or one argument", decl);
10958               else
10959                 cp_error ("`%D' must take either one or two arguments", decl);
10960             }
10961
10962           /* More Effective C++ rule 6.  */
10963           if (warn_ecpp
10964               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
10965                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
10966             {
10967               tree arg = TREE_VALUE (argtypes);
10968               tree ret = TREE_TYPE (TREE_TYPE (decl));
10969               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10970                 arg = TREE_TYPE (arg);
10971               arg = TYPE_MAIN_VARIANT (arg);
10972               if (list_length (argtypes) == 2)
10973                 {
10974                   if (TREE_CODE (ret) != REFERENCE_TYPE
10975                       || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10976                                      arg, 1))
10977                     cp_warning ("prefix `%D' should return `%T'", decl,
10978                                 build_reference_type (arg));
10979                 }
10980               else
10981                 {
10982                   if (!comptypes (TYPE_MAIN_VARIANT (ret), arg, 1))
10983                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
10984                 }
10985             }
10986         }
10987       else if (unary_op_p (name))
10988         {
10989           if (list_length (argtypes) != 2)
10990             {
10991               if (methodp)
10992                 cp_error ("`%D' must take `void'", decl);
10993               else
10994                 cp_error ("`%D' must take exactly one argument", decl);
10995             }
10996         }
10997       else /* if (binary_op_p (name)) */
10998         {
10999           if (list_length (argtypes) != 3)
11000             {
11001               if (methodp)
11002                 cp_error ("`%D' must take exactly one argument", decl);
11003               else
11004                 cp_error ("`%D' must take exactly two arguments", decl);
11005             }
11006
11007           /* More Effective C++ rule 7.  */
11008           if (warn_ecpp
11009               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
11010                   || name == ansi_opname [TRUTH_ORIF_EXPR]
11011                   || name == ansi_opname [COMPOUND_EXPR]))
11012             cp_warning ("user-defined `%D' always evaluates both arguments",
11013                         decl);
11014         }
11015
11016       /* Effective C++ rule 23.  */
11017       if (warn_ecpp
11018           && list_length (argtypes) == 3
11019           && (name == ansi_opname [PLUS_EXPR]
11020               || name == ansi_opname [MINUS_EXPR]
11021               || name == ansi_opname [TRUNC_DIV_EXPR]
11022               || name == ansi_opname [MULT_EXPR])
11023           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11024         cp_warning ("`%D' should return by value", decl);
11025
11026       /* 13.4.0.8 */
11027       if (argtypes)
11028         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
11029           if (TREE_PURPOSE (argtypes))
11030             {
11031               TREE_PURPOSE (argtypes) = NULL_TREE;
11032               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
11033                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11034                 {
11035                   if (pedantic)
11036                     cp_pedwarn ("`%D' cannot have default arguments", decl);
11037                 }
11038               else
11039                 cp_error ("`%D' cannot have default arguments", decl);
11040             }
11041     }
11042 }
11043 \f
11044 /* Get the struct, enum or union (CODE says which) with tag NAME.
11045    Define the tag as a forward-reference if it is not defined.
11046
11047    C++: If a class derivation is given, process it here, and report
11048    an error if multiple derivation declarations are not identical.
11049
11050    If this is a definition, come in through xref_tag and only look in
11051    the current frame for the name (since C++ allows new names in any
11052    scope.)  */
11053
11054 tree
11055 xref_tag (code_type_node, name, binfo, globalize)
11056      tree code_type_node;
11057      tree name, binfo;
11058      int globalize;
11059 {
11060   enum tag_types tag_code;
11061   enum tree_code code;
11062   int temp = 0;
11063   register tree ref, t;
11064   struct binding_level *b = inner_binding_level;
11065   int got_type = 0;
11066
11067   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11068   switch (tag_code)
11069     {
11070     case record_type:
11071     case class_type:
11072     case signature_type:
11073       code = RECORD_TYPE;
11074       break;
11075     case union_type:
11076       code = UNION_TYPE;
11077       break;
11078     case enum_type:
11079       code = ENUMERAL_TYPE;
11080       break;
11081     default:
11082       my_friendly_abort (18);
11083     }
11084
11085   /* If a cross reference is requested, look up the type
11086      already defined for this tag and return it.  */
11087   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
11088     {
11089       t = name;
11090       name = TYPE_IDENTIFIER (t);
11091       got_type = 1;
11092     }
11093   else
11094     t = IDENTIFIER_TYPE_VALUE (name);
11095   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
11096       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
11097     t = NULL_TREE;
11098
11099   if (! globalize)
11100     {
11101       if (pedantic && t && (TREE_CODE (t) == TEMPLATE_TYPE_PARM
11102                             || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM))
11103         {
11104           cp_pedwarn ("redeclaration of template type-parameter `%T'", name);
11105           cp_pedwarn_at ("  previously declared here", t);
11106         }
11107       if (t && TYPE_CONTEXT (t) && got_type)
11108         ref = t;
11109       else
11110         {
11111           /* If we know we are defining this tag, only look it up in
11112              this scope and don't try to find it as a type.  */
11113           ref = lookup_tag (code, name, b, 1);
11114         }
11115     }
11116   else
11117     {
11118       if (t)
11119         ref = t;
11120       else
11121         ref = lookup_tag (code, name, b, 0);
11122
11123       if (! ref)
11124         {
11125           /* Try finding it as a type declaration.  If that wins, use it.  */
11126           ref = lookup_name (name, 1);
11127
11128           if (ref != NULL_TREE
11129               && processing_template_decl
11130               && DECL_CLASS_TEMPLATE_P (ref)
11131               && template_class_depth (current_class_type) == 0)
11132             /* Since GLOBALIZE is true, we're declaring a global
11133                template, so we want this type.  */
11134             ref = DECL_RESULT (ref);
11135
11136           if (ref && TREE_CODE (ref) == TYPE_DECL
11137               && TREE_CODE (TREE_TYPE (ref)) == code)
11138             ref = TREE_TYPE (ref);
11139           else
11140             ref = NULL_TREE;
11141         }
11142     }
11143
11144   push_obstacks_nochange ();
11145
11146   if (! ref)
11147     {
11148       /* If no such tag is yet defined, create a forward-reference node
11149          and record it as the "definition".
11150          When a real declaration of this type is found,
11151          the forward-reference will be altered into a real type.  */
11152
11153       /* In C++, since these migrate into the global scope, we must
11154          build them on the permanent obstack.  */
11155
11156       temp = allocation_temporary_p ();
11157       if (temp)
11158         end_temporary_allocation ();
11159
11160       if (code == ENUMERAL_TYPE)
11161         {
11162           cp_error ("use of enum `%#D' without previous declaration", name);
11163
11164           ref = make_node (ENUMERAL_TYPE);
11165
11166           /* Give the type a default layout like unsigned int
11167              to avoid crashing if it does not get defined.  */
11168           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
11169           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
11170           TREE_UNSIGNED (ref) = 1;
11171           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
11172           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
11173           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
11174
11175           /* Enable us to recognize when a type is created in class context.
11176              To do nested classes correctly, this should probably be cleared
11177              out when we leave this classes scope.  Currently this in only
11178              done in `start_enum'.  */
11179
11180           pushtag (name, ref, globalize);
11181         }
11182       else
11183         {
11184           struct binding_level *old_b = class_binding_level;
11185
11186           ref = make_lang_type (code);
11187
11188           if (tag_code == signature_type)
11189             {
11190               SET_SIGNATURE (ref);
11191               /* Since a signature type will be turned into the type
11192                  of signature tables, it's not only an interface.  */
11193               CLASSTYPE_INTERFACE_ONLY (ref) = 0;
11194               SET_CLASSTYPE_INTERFACE_KNOWN (ref);
11195               /* A signature doesn't have a vtable.  */
11196               CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
11197             }
11198
11199 #ifdef NONNESTED_CLASSES
11200           /* Class types don't nest the way enums do.  */
11201           class_binding_level = (struct binding_level *)0;
11202 #endif
11203           pushtag (name, ref, globalize);
11204           class_binding_level = old_b;
11205         }
11206     }
11207   else
11208     {
11209       /* If it no longer looks like a nested type, make sure it's
11210          in global scope.
11211          If it is not an IDENTIFIER, this is not a declaration */
11212       if (b->namespace_p && !class_binding_level
11213           && TREE_CODE (name) == IDENTIFIER_NODE)
11214         {
11215           if (IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
11216             SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
11217         }
11218
11219       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
11220         redeclare_class_template (ref, current_template_parms);
11221     }
11222
11223   if (binfo)
11224     xref_basetypes (code_type_node, name, ref, binfo);
11225
11226   /* Until the type is defined, tentatively accept whatever
11227      structure tag the user hands us.  */
11228   if (TYPE_SIZE (ref) == NULL_TREE
11229       && ref != current_class_type
11230       /* Have to check this, in case we have contradictory tag info.  */
11231       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
11232     {
11233       if (tag_code == class_type)
11234         CLASSTYPE_DECLARED_CLASS (ref) = 1;
11235       else if (tag_code == record_type || tag_code == signature_type)
11236         CLASSTYPE_DECLARED_CLASS (ref) = 0;
11237     }
11238
11239   pop_obstacks ();
11240
11241   return ref;
11242 }
11243
11244 tree
11245 xref_tag_from_type (old, id, globalize)
11246      tree old, id;
11247      int globalize;
11248 {
11249   tree code_type_node;
11250
11251   if (TREE_CODE (old) == RECORD_TYPE)
11252     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
11253                       ? class_type_node : record_type_node);
11254   else
11255     code_type_node = union_type_node;
11256
11257   if (id == NULL_TREE)
11258     id = TYPE_IDENTIFIER (old);
11259
11260   return xref_tag (code_type_node, id, NULL_TREE, globalize);
11261 }
11262
11263 void
11264 xref_basetypes (code_type_node, name, ref, binfo)
11265      tree code_type_node;
11266      tree name, ref;
11267      tree binfo;
11268 {
11269   /* In the declaration `A : X, Y, ... Z' we mark all the types
11270      (A, X, Y, ..., Z) so we can check for duplicates.  */
11271   tree binfos;
11272   int i, len;
11273   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11274
11275   if (tag_code == union_type)
11276     {
11277       cp_error ("derived union `%T' invalid", ref);
11278       return;
11279     }
11280
11281   len = list_length (binfo);
11282   push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
11283
11284   SET_CLASSTYPE_MARKED (ref);
11285   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
11286
11287   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
11288     {
11289       /* The base of a derived struct is public by default.  */
11290       int via_public
11291         = (TREE_PURPOSE (binfo) == access_public_node
11292            || TREE_PURPOSE (binfo) == access_public_virtual_node
11293            || (tag_code != class_type
11294                && (TREE_PURPOSE (binfo) == access_default_node
11295                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
11296       int via_protected
11297         = (TREE_PURPOSE (binfo) == access_protected_node
11298            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
11299       int via_virtual
11300         = (TREE_PURPOSE (binfo) == access_private_virtual_node
11301            || TREE_PURPOSE (binfo) == access_protected_virtual_node
11302            || TREE_PURPOSE (binfo) == access_public_virtual_node
11303            || TREE_PURPOSE (binfo) == access_default_virtual_node);
11304       tree basetype = TREE_VALUE (binfo);
11305       tree base_binfo;
11306
11307       GNU_xref_hier (IDENTIFIER_POINTER (name),
11308                      IDENTIFIER_POINTER (TREE_VALUE (binfo)),
11309                      via_public, via_virtual, 0);
11310
11311       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
11312         basetype = TREE_TYPE (basetype);
11313       if (!basetype
11314           || (TREE_CODE (basetype) != RECORD_TYPE
11315               && TREE_CODE (basetype) != TYPENAME_TYPE
11316               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
11317               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
11318         {
11319           cp_error ("base type `%T' fails to be a struct or class type",
11320                     TREE_VALUE (binfo));
11321           continue;
11322         }
11323 #if 1
11324       /* This code replaces similar code in layout_basetypes.
11325          We put the complete_type first for implicit `typename'.  */
11326       else if (TYPE_SIZE (complete_type (basetype)) == NULL_TREE
11327                && ! (current_template_parms && uses_template_parms (basetype)))
11328         {
11329           cp_error ("base class `%T' has incomplete type", basetype);
11330           continue;
11331         }
11332 #endif
11333       else
11334         {
11335           if (CLASSTYPE_MARKED (basetype))
11336             {
11337               if (basetype == ref)
11338                 cp_error ("recursive type `%T' undefined", basetype);
11339               else
11340                 cp_error ("duplicate base type `%T' invalid", basetype);
11341               continue;
11342             }
11343
11344           if (TYPE_FOR_JAVA (basetype)
11345               && current_lang_stack == current_lang_base)
11346             TYPE_FOR_JAVA (ref) = 1;
11347
11348           /* Note that the BINFO records which describe individual
11349              inheritances are *not* shared in the lattice!  They
11350              cannot be shared because a given baseclass may be
11351              inherited with different `accessibility' by different
11352              derived classes.  (Each BINFO record describing an
11353              individual inheritance contains flags which say what
11354              the `accessibility' of that particular inheritance is.)  */
11355
11356           base_binfo = make_binfo (integer_zero_node, basetype,
11357                                    TYPE_BINFO_VTABLE (basetype),
11358                                    TYPE_BINFO_VIRTUALS (basetype), NULL_TREE);
11359
11360           TREE_VEC_ELT (binfos, i) = base_binfo;
11361           TREE_VIA_PUBLIC (base_binfo) = via_public;
11362           TREE_VIA_PROTECTED (base_binfo) = via_protected;
11363           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
11364           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
11365
11366           SET_CLASSTYPE_MARKED (basetype);
11367
11368           /* We are free to modify these bits because they are meaningless
11369              at top level, and BASETYPE is a top-level type.  */
11370           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
11371             {
11372               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
11373               TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11374             }
11375
11376           TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
11377           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11378           CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
11379           i += 1;
11380         }
11381     }
11382   if (i)
11383     TREE_VEC_LENGTH (binfos) = i;
11384   else
11385     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
11386
11387   if (i > 1)
11388     TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
11389   else if (i == 1)
11390     TYPE_USES_MULTIPLE_INHERITANCE (ref)
11391       = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
11392   if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
11393     TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11394
11395   /* Unmark all the types.  */
11396   while (--i >= 0)
11397     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
11398   CLEAR_CLASSTYPE_MARKED (ref);
11399
11400   pop_obstacks ();
11401 }
11402
11403 \f
11404 tree current_local_enum = NULL_TREE;
11405
11406 /* Begin compiling the definition of an enumeration type.
11407    NAME is its name (or null if anonymous).
11408    Returns the type object, as yet incomplete.
11409    Also records info about it so that build_enumerator
11410    may be used to declare the individual values as they are read.  */
11411
11412 tree
11413 start_enum (name)
11414      tree name;
11415 {
11416   register tree enumtype = NULL_TREE;
11417   struct binding_level *b = inner_binding_level;
11418
11419   if (processing_template_decl && current_function_decl)
11420     end_temporary_allocation ();
11421
11422   /* If this is the real definition for a previous forward reference,
11423      fill in the contents in the same object that used to be the
11424      forward reference.  */
11425
11426   if (name != NULL_TREE)
11427     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
11428
11429   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
11430     cp_error ("multiple definition of `%#T'", enumtype);
11431   else
11432     {
11433       enumtype = make_node (ENUMERAL_TYPE);
11434       pushtag (name, enumtype, 0);
11435     }
11436
11437   if (b->pseudo_global)
11438     cp_error ("template declaration of `%#T'", enumtype);
11439
11440   if (current_class_type)
11441     TREE_ADDRESSABLE (b->tags) = 1;
11442
11443   current_local_enum = NULL_TREE;
11444
11445   /* We don't copy this value because build_enumerator needs to do it.  */
11446   enum_next_value = integer_zero_node;
11447   enum_overflow = 0;
11448
11449   GNU_xref_decl (current_function_decl, enumtype);
11450   return enumtype;
11451 }
11452
11453 /* After processing and defining all the values of an enumeration type,
11454    install their decls in the enumeration type and finish it off.
11455    ENUMTYPE is the type object and VALUES a list of name-value pairs.
11456    Returns ENUMTYPE.  */
11457
11458 tree
11459 finish_enum (enumtype, values)
11460      register tree enumtype, values;
11461 {
11462   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
11463   /* Calculate the maximum value of any enumerator in this type.  */
11464
11465   if (values)
11466     {
11467       register tree pair;
11468       register tree value = DECL_INITIAL (TREE_VALUE (values));
11469
11470       if (! processing_template_decl)
11471         {
11472           /* Speed up the main loop by performing some precalculations */
11473           TREE_TYPE (TREE_VALUE (values)) = enumtype;
11474           TREE_TYPE (value) = enumtype;
11475           minnode = maxnode = value;
11476         }
11477       TREE_VALUE (values) = value;
11478
11479       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
11480         {
11481           value = DECL_INITIAL (TREE_VALUE (pair));
11482           if (! processing_template_decl)
11483             {
11484               TREE_TYPE (TREE_VALUE (pair)) = enumtype;
11485               TREE_TYPE (value) = enumtype;
11486               if (tree_int_cst_lt (maxnode, value))
11487                 maxnode = value;
11488               else if (tree_int_cst_lt (value, minnode))
11489                 minnode = value;
11490             }
11491           TREE_VALUE (pair) = value;
11492         }
11493     }
11494   else
11495     maxnode = minnode = integer_zero_node;
11496
11497   TYPE_VALUES (enumtype) = nreverse (values);
11498
11499   if (processing_template_decl)
11500     {
11501       if (current_function_decl)
11502         {
11503           add_tree (build_min (TAG_DEFN, enumtype));
11504           resume_temporary_allocation ();
11505         }
11506       return enumtype;
11507     }
11508
11509   {
11510     int unsignedp = tree_int_cst_sgn (minnode) >= 0;
11511     int lowprec = min_precision (minnode, unsignedp);
11512     int highprec = min_precision (maxnode, unsignedp);
11513     int precision = MAX (lowprec, highprec);
11514
11515     TYPE_SIZE (enumtype) = NULL_TREE;
11516
11517     /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
11518
11519     TYPE_PRECISION (enumtype) = precision;
11520     if (unsignedp)
11521       fixup_unsigned_type (enumtype);
11522     else
11523       fixup_signed_type (enumtype);
11524
11525     if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
11526       /* Use the width of the narrowest normal C type which is wide enough.  */
11527       TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
11528                                                   (precision, 1));
11529     else
11530       TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
11531
11532     TYPE_SIZE (enumtype) = 0;
11533     layout_type (enumtype);
11534   }
11535
11536   {
11537     register tree tem;
11538
11539     /* Fix up all variant types of this enum type.  */
11540     for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
11541          tem = TYPE_NEXT_VARIANT (tem))
11542       {
11543         TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
11544         TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
11545         TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
11546         TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
11547         TYPE_MODE (tem) = TYPE_MODE (enumtype);
11548         TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
11549         TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
11550         TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
11551       }
11552   }
11553
11554   /* Finish debugging output for this type.  */
11555   rest_of_type_compilation (enumtype, namespace_bindings_p ());
11556
11557   return enumtype;
11558 }
11559
11560 /* Build and install a CONST_DECL for one value of the
11561    current enumeration type (one that was begun with start_enum).
11562    Return a tree-list containing the name and its value.
11563    Assignment of sequential values by default is handled here.  */
11564
11565 tree
11566 build_enumerator (name, value)
11567      tree name, value;
11568 {
11569   tree decl, result;
11570
11571   /* Remove no-op casts from the value.  */
11572   if (value)
11573     STRIP_TYPE_NOPS (value);
11574
11575  if (! processing_template_decl)
11576    {
11577      /* Validate and default VALUE.  */
11578      if (value != NULL_TREE)
11579        {
11580          if (TREE_READONLY_DECL_P (value))
11581            value = decl_constant_value (value);
11582
11583          if (TREE_CODE (value) == INTEGER_CST)
11584            {
11585              value = default_conversion (value);
11586              constant_expression_warning (value);
11587            }
11588          else
11589            {
11590              cp_error ("enumerator value for `%D' not integer constant", name);
11591              value = NULL_TREE;
11592            }
11593        }
11594
11595      /* Default based on previous value.  */
11596      if (value == NULL_TREE && ! processing_template_decl)
11597        {
11598          value = enum_next_value;
11599          if (enum_overflow)
11600            cp_error ("overflow in enumeration values at `%D'", name);
11601        }
11602
11603      /* Remove no-op casts from the value.  */
11604      if (value)
11605        STRIP_TYPE_NOPS (value);
11606
11607      /* We have to always copy here; not all INTEGER_CSTs are unshared,
11608         and there's no wedding ring. Look at size_int()...*/
11609      value = copy_node (value);
11610 #if 0
11611      /* To fix MAX_VAL enum consts. (bkoz)  */
11612      TREE_TYPE (value) = integer_type_node;
11613 #endif
11614    }
11615
11616   /* C++ associates enums with global, function, or class declarations.  */
11617
11618   decl = current_scope ();
11619   if (decl && decl == current_class_type)
11620     {
11621       /* This enum declaration is local to the class, so we must put
11622          it in that class's list of decls.  */
11623       decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
11624       DECL_INITIAL (decl) = value;
11625       TREE_READONLY (decl) = 1;
11626       pushdecl_class_level (decl);
11627       TREE_CHAIN (decl) = current_local_enum;
11628       current_local_enum = decl;
11629     }
11630   else
11631     {
11632       /* It's a global enum, or it's local to a function.  (Note local to
11633          a function could mean local to a class method.  */
11634       decl = build_decl (CONST_DECL, name, integer_type_node);
11635       DECL_INITIAL (decl) = value;
11636       TREE_READONLY (decl) = 1;
11637
11638       pushdecl (decl);
11639       GNU_xref_decl (current_function_decl, decl);
11640     }
11641
11642  if (! processing_template_decl)
11643    {
11644      /* Set basis for default for next value.  */
11645      enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
11646                                                   integer_one_node, PLUS_EXPR);
11647      enum_overflow = tree_int_cst_lt (enum_next_value, value);
11648    }
11649
11650   result = saveable_tree_cons (name, decl, NULL_TREE);
11651   return result;
11652 }
11653
11654 tree
11655 grok_enum_decls (decl)
11656      tree decl;
11657 {
11658   tree d = current_local_enum;
11659
11660   if (d == NULL_TREE)
11661     return decl;
11662
11663   while (1)
11664     {
11665       if (TREE_CHAIN (d) == NULL_TREE)
11666         {
11667           TREE_CHAIN (d) = decl;
11668           break;
11669         }
11670       d = TREE_CHAIN (d);
11671     }
11672
11673   decl = current_local_enum;
11674   current_local_enum = NULL_TREE;
11675
11676   return decl;
11677 }
11678 \f
11679 static int function_depth;
11680
11681 /* Create the FUNCTION_DECL for a function definition.
11682    DECLSPECS and DECLARATOR are the parts of the declaration;
11683    they describe the function's name and the type it returns,
11684    but twisted together in a fashion that parallels the syntax of C.
11685
11686    This function creates a binding context for the function body
11687    as well as setting up the FUNCTION_DECL in current_function_decl.
11688
11689    Returns 1 on success.  If the DECLARATOR is not suitable for a function
11690    (it defines a datum instead), we return 0, which tells
11691    yyparse to report a parse error.
11692
11693    For C++, we must first check whether that datum makes any sense.
11694    For example, "class A local_a(1,2);" means that variable local_a
11695    is an aggregate of type A, which should have a constructor
11696    applied to it with the argument list [1, 2].
11697
11698    @@ There is currently no way to retrieve the storage
11699    @@ allocated to FUNCTION (or all of its parms) if we return
11700    @@ something we had previously.  */
11701
11702 int
11703 start_function (declspecs, declarator, attrs, pre_parsed_p)
11704      tree declspecs, declarator, attrs;
11705      int pre_parsed_p;
11706 {
11707   tree decl1;
11708   tree ctype = NULL_TREE;
11709   tree fntype;
11710   tree restype;
11711   extern int have_extern_spec;
11712   extern int used_extern_spec;
11713   int doing_friend = 0;
11714
11715   /* Sanity check.  */
11716   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
11717   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
11718
11719   /* Assume, until we see it does.  */
11720   current_function_returns_value = 0;
11721   current_function_returns_null = 0;
11722   warn_about_return_type = 0;
11723   named_labels = 0;
11724   shadowed_labels = 0;
11725   current_function_assigns_this = 0;
11726   current_function_just_assigned_this = 0;
11727   current_function_parms_stored = 0;
11728   original_result_rtx = NULL_RTX;
11729   base_init_expr = NULL_TREE;
11730   current_base_init_list = NULL_TREE;
11731   current_member_init_list = NULL_TREE;
11732   ctor_label = dtor_label = NULL_TREE;
11733   static_labelno = 0;
11734
11735   clear_temp_name ();
11736
11737   /* This should only be done once on the top most decl.  */
11738   if (have_extern_spec && !used_extern_spec)
11739     {
11740       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
11741       used_extern_spec = 1;
11742     }
11743
11744   if (pre_parsed_p)
11745     {
11746       decl1 = declarator;
11747
11748       if (! DECL_ARGUMENTS (decl1)
11749           && !DECL_STATIC_FUNCTION_P (decl1)
11750           && DECL_CLASS_SCOPE_P (decl1)
11751           && TYPE_IDENTIFIER (DECL_CONTEXT (decl1))
11752           && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1))))
11753         {
11754           tree binding = binding_for_name (DECL_NAME (decl1),
11755                                            current_namespace);
11756           cp_error ("redeclaration of `%#D'", decl1);
11757           if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
11758             cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
11759           else if (BINDING_VALUE (binding))
11760             cp_error_at ("previous declaration here", BINDING_VALUE (binding));
11761         }
11762
11763       fntype = TREE_TYPE (decl1);
11764       if (TREE_CODE (fntype) == METHOD_TYPE)
11765         ctype = TYPE_METHOD_BASETYPE (fntype);
11766
11767       /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
11768          class is in the (lexical) scope of the class in which it is
11769          defined.  */
11770       if (!ctype && DECL_FRIEND_P (decl1))
11771         {
11772           ctype = DECL_CLASS_CONTEXT (decl1);
11773
11774           /* CTYPE could be null here if we're dealing with a template;
11775              for example, `inline friend float foo()' inside a template
11776              will have no CTYPE set.  */
11777           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11778             ctype = NULL_TREE;
11779           else
11780             doing_friend = 1;
11781         }
11782
11783       /* In a fcn definition, arg types must be complete.  */
11784       require_complete_types_for_parms (DECL_ARGUMENTS (decl1));
11785
11786       /* In case some arg types were completed since the declaration was
11787          parsed, fix up the decls.  */
11788       {
11789         tree t = DECL_ARGUMENTS (decl1);
11790         for (; t; t = TREE_CHAIN (t))
11791           layout_decl (t, 0);
11792       }
11793
11794       last_function_parms = DECL_ARGUMENTS (decl1);
11795       last_function_parm_tags = NULL_TREE;
11796     }
11797   else
11798     {
11799       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
11800       /* If the declarator is not suitable for a function definition,
11801          cause a syntax error.  */
11802       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
11803
11804       fntype = TREE_TYPE (decl1);
11805
11806       restype = TREE_TYPE (fntype);
11807       if (IS_AGGR_TYPE (restype) && ! TYPE_PTRMEMFUNC_P (restype)
11808           && ! CLASSTYPE_GOT_SEMICOLON (restype))
11809         {
11810           cp_error ("semicolon missing after declaration of `%#T'", restype);
11811           shadow_tag (build_expr_list (NULL_TREE, restype));
11812           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
11813           if (TREE_CODE (fntype) == FUNCTION_TYPE)
11814             fntype = build_function_type (integer_type_node,
11815                                           TYPE_ARG_TYPES (fntype));
11816           else
11817             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
11818                                               integer_type_node,
11819                                               TYPE_ARG_TYPES (fntype));
11820           TREE_TYPE (decl1) = fntype;
11821         }
11822
11823       if (TREE_CODE (fntype) == METHOD_TYPE)
11824         ctype = TYPE_METHOD_BASETYPE (fntype);
11825       else if (DECL_MAIN_P (decl1))
11826         {
11827           /* If this doesn't return integer_type, complain.  */
11828           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
11829             {
11830               if (pedantic || warn_return_type)
11831                 pedwarn ("return type for `main' changed to `int'");
11832               TREE_TYPE (decl1) = fntype = default_function_type;
11833             }
11834           warn_about_return_type = 0;
11835         }
11836     }
11837
11838   /* Warn if function was previously implicitly declared
11839      (but not if we warned then).  */
11840   if (! warn_implicit
11841       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
11842     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
11843
11844   current_function_decl = decl1;
11845   /* Save the parm names or decls from this function's declarator
11846      where store_parm_decls will find them.  */
11847   current_function_parms = last_function_parms;
11848   current_function_parm_tags = last_function_parm_tags;
11849
11850   announce_function (decl1);
11851
11852   if (! processing_template_decl)
11853     {
11854       if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
11855         {
11856           cp_error ("return-type `%#T' is an incomplete type",
11857                     TREE_TYPE (fntype));
11858
11859           /* Make it return void instead, but don't change the
11860              type of the DECL_RESULT, in case we have a named return value.  */
11861           if (ctype)
11862             TREE_TYPE (decl1)
11863               = build_cplus_method_type (build_type_variant (ctype,
11864                                                              TREE_READONLY (decl1),
11865                                                              TREE_SIDE_EFFECTS (decl1)),
11866                                          void_type_node,
11867                                          FUNCTION_ARG_CHAIN (decl1));
11868           else
11869             TREE_TYPE (decl1)
11870               = build_function_type (void_type_node,
11871                                      TYPE_ARG_TYPES (TREE_TYPE (decl1)));
11872           DECL_RESULT (decl1)
11873             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype)));
11874           TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (TREE_TYPE (fntype));
11875           TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (TREE_TYPE (fntype));
11876         }
11877
11878       if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
11879           && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
11880         abstract_virtuals_error (decl1, TREE_TYPE (fntype));
11881     }
11882
11883   if (warn_about_return_type)
11884     pedwarn ("return-type defaults to `int'");
11885
11886   /* Effective C++ rule 15.  See also c_expand_return.  */
11887   if (warn_ecpp
11888       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
11889       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11890     cp_warning ("`operator=' should return a reference to `*this'");
11891
11892   /* Make the init_value nonzero so pushdecl knows this is not tentative.
11893      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
11894   DECL_INITIAL (decl1) = error_mark_node;
11895
11896   /* This function exists in static storage.
11897      (This does not mean `static' in the C sense!)  */
11898   TREE_STATIC (decl1) = 1;
11899
11900   /* Record the decl so that the function name is defined.
11901      If we already have a decl for this name, and it is a FUNCTION_DECL,
11902      use the old decl.  */
11903
11904   if (processing_template_decl)
11905     decl1 = push_template_decl (decl1);
11906   else if (pre_parsed_p == 0)
11907     {
11908       /* A specialization is not used to guide overload resolution.  */
11909       if ((flag_guiding_decls
11910            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
11911           && ! DECL_FUNCTION_MEMBER_P (decl1))
11912         decl1 = pushdecl (decl1);
11913       else
11914         {
11915           /* We need to set the DECL_CONTEXT. */
11916           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11917             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11918           /* And make sure we have enough default args.  */
11919           check_default_args (decl1);
11920         }
11921       DECL_MAIN_VARIANT (decl1) = decl1;
11922       fntype = TREE_TYPE (decl1);
11923     }
11924
11925   current_function_decl = decl1;
11926
11927   if (DECL_INTERFACE_KNOWN (decl1))
11928     {
11929       tree ctx = hack_decl_function_context (decl1);
11930
11931       if (DECL_NOT_REALLY_EXTERN (decl1))
11932         DECL_EXTERNAL (decl1) = 0;
11933
11934       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
11935           && TREE_PUBLIC (ctx))
11936         /* This is a function in a local class in an extern inline
11937            function.  */
11938         comdat_linkage (decl1);
11939     }
11940   /* If this function belongs to an interface, it is public.
11941      If it belongs to someone else's interface, it is also external.
11942      It doesn't matter whether it's inline or not.  */
11943   else if (interface_unknown == 0
11944            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
11945                || flag_alt_external_templates))
11946     {
11947       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
11948           || processing_template_decl)
11949         DECL_EXTERNAL (decl1)
11950           = (interface_only
11951              || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines));
11952       else
11953         DECL_EXTERNAL (decl1) = 0;
11954       DECL_NOT_REALLY_EXTERN (decl1) = 0;
11955       DECL_INTERFACE_KNOWN (decl1) = 1;
11956     }
11957   else
11958     {
11959       /* This is a definition, not a reference.
11960          So clear DECL_EXTERNAL.  */
11961       DECL_EXTERNAL (decl1) = 0;
11962
11963       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
11964           && ! DECL_INTERFACE_KNOWN (decl1)
11965           /* Don't try to defer nested functions for now.  */
11966           && ! hack_decl_function_context (decl1))
11967         DECL_DEFER_OUTPUT (decl1) = 1;
11968       else
11969         DECL_INTERFACE_KNOWN (decl1) = 1;
11970     }
11971
11972   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
11973     {
11974       if (TREE_CODE (fntype) == METHOD_TYPE)
11975         TREE_TYPE (decl1) = fntype
11976           = build_function_type (TREE_TYPE (fntype),
11977                                  TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
11978       current_function_parms = TREE_CHAIN (current_function_parms);
11979       DECL_ARGUMENTS (decl1) = current_function_parms;
11980       ctype = NULL_TREE;
11981     }
11982   restype = TREE_TYPE (fntype);
11983
11984   if (ctype)
11985     {
11986       push_nested_class (ctype, 1);
11987
11988       /* If we're compiling a friend function, neither of the variables
11989          current_class_ptr nor current_class_type will have values.  */
11990       if (! doing_friend)
11991         {
11992           /* We know that this was set up by `grokclassfn'.
11993              We do not wait until `store_parm_decls', since evil
11994              parse errors may never get us to that point.  Here
11995              we keep the consistency between `current_class_type'
11996              and `current_class_ptr'.  */
11997           tree t = current_function_parms;
11998
11999           my_friendly_assert (t != NULL_TREE
12000                               && TREE_CODE (t) == PARM_DECL, 162);
12001
12002           if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
12003             {
12004               int i = suspend_momentary ();
12005
12006               /* Fool build_indirect_ref.  */
12007               current_class_ptr = NULL_TREE;
12008               current_class_ref = build_indirect_ref (t, NULL_PTR);
12009               current_class_ptr = t;
12010               resume_momentary (i);
12011             }
12012           else
12013             /* We're having a signature pointer here.  */
12014             current_class_ref = current_class_ptr = t;
12015
12016         }
12017     }
12018   else
12019     {
12020       if (DECL_STATIC_FUNCTION_P (decl1))
12021         push_nested_class (DECL_CONTEXT (decl1), 2);
12022       else
12023         push_memoized_context (0, 1);
12024       current_class_ptr = current_class_ref = NULL_TREE;
12025     }
12026
12027   pushlevel (0);
12028   current_binding_level->parm_flag = 1;
12029
12030   GNU_xref_function (decl1, current_function_parms);
12031
12032   if (attrs)
12033     cplus_decl_attributes (decl1, NULL_TREE, attrs);
12034   make_function_rtl (decl1);
12035
12036   /* Promote the value to int before returning it.  */
12037   if (C_PROMOTING_INTEGER_TYPE_P (restype))
12038     restype = type_promotes_to (restype);
12039
12040   /* If this fcn was already referenced via a block-scope `extern' decl
12041      (or an implicit decl), propagate certain information about the usage.  */
12042   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
12043     TREE_ADDRESSABLE (decl1) = 1;
12044
12045   if (DECL_RESULT (decl1) == NULL_TREE)
12046     {
12047       DECL_RESULT (decl1)
12048         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
12049       TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (restype);
12050       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (restype);
12051     }
12052
12053   /* Allocate further tree nodes temporarily during compilation
12054      of this function only.  Tiemann moved up here from bottom of fn.  */
12055   /* If this is a nested function, then we must continue to allocate RTL
12056      on the permanent obstack in case we need to inline it later.  */
12057   if (! hack_decl_function_context (decl1))
12058     temporary_allocation ();
12059
12060   if (processing_template_decl)
12061     {
12062       ++minimal_parse_mode;
12063       last_tree = DECL_SAVED_TREE (decl1)
12064         = build_nt (EXPR_STMT, void_zero_node);
12065     }
12066
12067   ++function_depth;
12068
12069   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
12070       && DECL_LANGUAGE (decl1) == lang_cplusplus)
12071     {
12072       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12073       ctor_label = NULL_TREE;
12074     }
12075   else
12076     {
12077       dtor_label = NULL_TREE;
12078       if (DECL_CONSTRUCTOR_P (decl1))
12079         ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12080     }
12081
12082   return 1;
12083 }
12084 \f
12085 /* Called after store_parm_decls for a function-try-block.  We need to update
12086    last_parm_cleanup_insn so that the base initializers for a constructor
12087    are run within this block, not before it.  */
12088
12089 void
12090 expand_start_early_try_stmts ()
12091 {
12092   expand_start_try_stmts ();
12093   last_parm_cleanup_insn = get_last_insn ();
12094 }
12095
12096 /* Store the parameter declarations into the current function declaration.
12097    This is called after parsing the parameter declarations, before
12098    digesting the body of the function.
12099
12100    Also install to binding contour return value identifier, if any.  */
12101
12102 void
12103 store_parm_decls ()
12104 {
12105   register tree fndecl = current_function_decl;
12106   register tree parm;
12107   int parms_have_cleanups = 0;
12108   tree cleanups = NULL_TREE;
12109
12110   /* This is either a chain of PARM_DECLs (when a prototype is used).  */
12111   tree specparms = current_function_parms;
12112
12113   /* This is a list of types declared among parms in a prototype.  */
12114   tree parmtags = current_function_parm_tags;
12115
12116   /* This is a chain of any other decls that came in among the parm
12117      declarations.  If a parm is declared with  enum {foo, bar} x;
12118      then CONST_DECLs for foo and bar are put here.  */
12119   tree nonparms = NULL_TREE;
12120
12121   if (toplevel_bindings_p ())
12122     fatal ("parse errors have confused me too much");
12123
12124   /* Initialize RTL machinery.  */
12125   init_function_start (fndecl, input_filename, lineno);
12126
12127   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
12128   declare_function_name ();
12129
12130   /* Create a binding level for the parms.  */
12131   expand_start_bindings (0);
12132
12133   if (specparms != NULL_TREE)
12134     {
12135       /* This case is when the function was defined with an ANSI prototype.
12136          The parms already have decls, so we need not do anything here
12137          except record them as in effect
12138          and complain if any redundant old-style parm decls were written.  */
12139
12140       register tree next;
12141
12142       /* Must clear this because it might contain TYPE_DECLs declared
12143          at class level.  */
12144       storedecls (NULL_TREE);
12145
12146       for (parm = nreverse (specparms); parm; parm = next)
12147         {
12148           next = TREE_CHAIN (parm);
12149           if (TREE_CODE (parm) == PARM_DECL)
12150             {
12151               tree cleanup;
12152               if (DECL_NAME (parm) == NULL_TREE)
12153                 {
12154                   pushdecl (parm);
12155                 }
12156               else if (TREE_CODE (TREE_TYPE (parm)) == VOID_TYPE)
12157                 cp_error ("parameter `%D' declared void", parm);
12158               else
12159                 {
12160                   /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12161                      A parameter is assumed not to have any side effects.
12162                      If this should change for any reason, then this
12163                      will have to wrap the bashed reference type in a save_expr.
12164
12165                      Also, if the parameter type is declared to be an X
12166                      and there is an X(X&) constructor, we cannot lay it
12167                      into the stack (any more), so we make this parameter
12168                      look like it is really of reference type.  Functions
12169                      which pass parameters to this function will know to
12170                      create a temporary in their frame, and pass a reference
12171                      to that.  */
12172
12173                   if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
12174                       && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
12175                     SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
12176
12177                   pushdecl (parm);
12178                 }
12179               if (! processing_template_decl
12180                   && (cleanup = maybe_build_cleanup (parm), cleanup))
12181                 {
12182                   expand_decl (parm);
12183                   parms_have_cleanups = 1;
12184
12185                   /* Keep track of the cleanups.  */
12186                   cleanups = tree_cons (parm, cleanup, cleanups);
12187                 }
12188             }
12189           else
12190             {
12191               /* If we find an enum constant or a type tag,
12192                  put it aside for the moment.  */
12193               TREE_CHAIN (parm) = NULL_TREE;
12194               nonparms = chainon (nonparms, parm);
12195             }
12196         }
12197
12198       /* Get the decls in their original chain order
12199          and record in the function.  This is all and only the
12200          PARM_DECLs that were pushed into scope by the loop above.  */
12201       DECL_ARGUMENTS (fndecl) = getdecls ();
12202
12203       storetags (chainon (parmtags, gettags ()));
12204     }
12205   else
12206     DECL_ARGUMENTS (fndecl) = NULL_TREE;
12207
12208   /* Now store the final chain of decls for the arguments
12209      as the decl-chain of the current lexical scope.
12210      Put the enumerators in as well, at the front so that
12211      DECL_ARGUMENTS is not modified.  */
12212
12213   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
12214
12215   /* Initialize the RTL code for the function.  */
12216   DECL_SAVED_INSNS (fndecl) = NULL_RTX;
12217   if (! processing_template_decl)
12218     expand_function_start (fndecl, parms_have_cleanups);
12219
12220   current_function_parms_stored = 1;
12221
12222   /* If this function is `main', emit a call to `__main'
12223      to run global initializers, etc.  */
12224   if (DECL_MAIN_P (fndecl))
12225     expand_main_function ();
12226
12227   /* Now that we have initialized the parms, we can start their
12228      cleanups.  We cannot do this before, since expand_decl_cleanup
12229      should not be called before the parm can be used.  */
12230   if (cleanups
12231       && ! processing_template_decl)
12232     {
12233       for (cleanups = nreverse (cleanups); cleanups; cleanups = TREE_CHAIN (cleanups))
12234         {
12235           if (! expand_decl_cleanup (TREE_PURPOSE (cleanups), TREE_VALUE (cleanups)))
12236             cp_error ("parser lost in parsing declaration of `%D'",
12237                       TREE_PURPOSE (cleanups));
12238         }
12239     }
12240
12241   /* Create a binding contour which can be used to catch
12242      cleanup-generated temporaries.  Also, if the return value needs or
12243      has initialization, deal with that now.  */
12244   if (parms_have_cleanups)
12245     {
12246       pushlevel (0);
12247       expand_start_bindings (0);
12248     }
12249
12250   if (! processing_template_decl && flag_exceptions)
12251     {
12252       /* Do the starting of the exception specifications, if we have any.  */
12253       if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
12254         expand_start_eh_spec ();
12255     }
12256
12257   last_parm_cleanup_insn = get_last_insn ();
12258   last_dtor_insn = get_last_insn ();
12259 }
12260
12261 /* Bind a name and initialization to the return value of
12262    the current function.  */
12263
12264 void
12265 store_return_init (return_id, init)
12266      tree return_id, init;
12267 {
12268   tree decl = DECL_RESULT (current_function_decl);
12269
12270   if (pedantic)
12271     /* Give this error as many times as there are occurrences,
12272        so that users can use Emacs compilation buffers to find
12273        and fix all such places.  */
12274     pedwarn ("ANSI C++ does not permit named return values");
12275
12276   if (return_id != NULL_TREE)
12277     {
12278       if (DECL_NAME (decl) == NULL_TREE)
12279         {
12280           DECL_NAME (decl) = return_id;
12281           DECL_ASSEMBLER_NAME (decl) = return_id;
12282         }
12283       else
12284         cp_error ("return identifier `%D' already in place", decl);
12285     }
12286
12287   /* Can't let this happen for constructors.  */
12288   if (DECL_CONSTRUCTOR_P (current_function_decl))
12289     {
12290       error ("can't redefine default return value for constructors");
12291       return;
12292     }
12293
12294   /* If we have a named return value, put that in our scope as well.  */
12295   if (DECL_NAME (decl) != NULL_TREE)
12296     {
12297       /* If this named return value comes in a register,
12298          put it in a pseudo-register.  */
12299       if (DECL_REGISTER (decl))
12300         {
12301           original_result_rtx = DECL_RTL (decl);
12302           DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
12303         }
12304
12305       /* Let `cp_finish_decl' know that this initializer is ok.  */
12306       DECL_INITIAL (decl) = init;
12307       pushdecl (decl);
12308
12309       if (minimal_parse_mode)
12310         add_tree (build_min_nt (RETURN_INIT, return_id,
12311                                 copy_to_permanent (init)));
12312       else
12313         cp_finish_decl (decl, init, NULL_TREE, 0, 0);
12314     }
12315 }
12316
12317 \f
12318 /* Finish up a function declaration and compile that function
12319    all the way to assembler language output.  The free the storage
12320    for the function definition.
12321
12322    This is called after parsing the body of the function definition.
12323    LINENO is the current line number.
12324
12325    C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12326    (and expand_end_bindings) must be made to take care of the binding
12327    contour for the base initializers.  This is only relevant for
12328    constructors.
12329
12330    NESTED is nonzero if we were in the middle of compiling another function
12331    when we started on this one.  */
12332
12333 void
12334 finish_function (lineno, call_poplevel, nested)
12335      int lineno;
12336      int call_poplevel;
12337      int nested;
12338 {
12339   register tree fndecl = current_function_decl;
12340   tree fntype, ctype = NULL_TREE;
12341   rtx last_parm_insn, insns;
12342   /* Label to use if this function is supposed to return a value.  */
12343   tree no_return_label = NULL_TREE;
12344   tree decls = NULL_TREE;
12345
12346   /* When we get some parse errors, we can end up without a
12347      current_function_decl, so cope.  */
12348   if (fndecl == NULL_TREE)
12349     return;
12350
12351   if (! nested && function_depth > 1)
12352     nested = 1;
12353
12354   fntype = TREE_TYPE (fndecl);
12355
12356 /*  TREE_READONLY (fndecl) = 1;
12357     This caused &foo to be of type ptr-to-const-function
12358     which then got a warning when stored in a ptr-to-function variable.  */
12359
12360   /* This happens on strange parse errors.  */
12361   if (! current_function_parms_stored)
12362     {
12363       call_poplevel = 0;
12364       store_parm_decls ();
12365     }
12366
12367   if (processing_template_decl)
12368     {
12369       if (DECL_CONSTRUCTOR_P (fndecl) && call_poplevel)
12370         {
12371           decls = getdecls ();
12372           expand_end_bindings (decls, decls != NULL_TREE, 0);
12373           poplevel (decls != NULL_TREE, 0, 0);
12374         }
12375     }
12376   else
12377     {
12378       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
12379         {
12380           tree ttype = target_type (fntype);
12381           tree parmdecl;
12382
12383           if (IS_AGGR_TYPE (ttype))
12384             /* Let debugger know it should output info for this type.  */
12385             note_debug_info_needed (ttype);
12386
12387           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
12388             {
12389               ttype = target_type (TREE_TYPE (parmdecl));
12390               if (IS_AGGR_TYPE (ttype))
12391                 /* Let debugger know it should output info for this type.  */
12392                 note_debug_info_needed (ttype);
12393             }
12394         }
12395
12396       /* Clean house because we will need to reorder insns here.  */
12397       do_pending_stack_adjust ();
12398
12399       if (dtor_label)
12400         {
12401           tree binfo = TYPE_BINFO (current_class_type);
12402           tree cond = integer_one_node;
12403           tree exprstmt;
12404           tree in_charge_node = lookup_name (in_charge_identifier, 0);
12405           tree virtual_size;
12406           int ok_to_optimize_dtor = 0;
12407           int empty_dtor = get_last_insn () == last_dtor_insn;
12408
12409           if (current_function_assigns_this)
12410             cond = build (NE_EXPR, boolean_type_node,
12411                           current_class_ptr, integer_zero_node);
12412           else
12413             {
12414               int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
12415
12416               /* If this destructor is empty, then we don't need to check
12417                  whether `this' is NULL in some cases.  */
12418               if ((flag_this_is_variable & 1) == 0)
12419                 ok_to_optimize_dtor = 1;
12420               else if (empty_dtor)
12421                 ok_to_optimize_dtor
12422                   = (n_baseclasses == 0
12423                      || (n_baseclasses == 1
12424                          && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
12425             }
12426
12427           /* These initializations might go inline.  Protect
12428              the binding level of the parms.  */
12429           pushlevel (0);
12430           expand_start_bindings (0);
12431
12432           if (current_function_assigns_this)
12433             {
12434               current_function_assigns_this = 0;
12435               current_function_just_assigned_this = 0;
12436             }
12437
12438           /* Generate the code to call destructor on base class.
12439              If this destructor belongs to a class with virtual
12440              functions, then set the virtual function table
12441              pointer to represent the type of our base class.  */
12442
12443           /* This side-effect makes call to `build_delete' generate the
12444              code we have to have at the end of this destructor.  */
12445           TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
12446
12447           /* These are two cases where we cannot delegate deletion.  */
12448           if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
12449               || TYPE_GETS_REG_DELETE (current_class_type))
12450             exprstmt = build_delete (current_class_type, current_class_ref, integer_zero_node,
12451                                      LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
12452           else
12453             exprstmt = build_delete (current_class_type, current_class_ref, in_charge_node,
12454                                      LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
12455
12456           /* If we did not assign to this, then `this' is non-zero at
12457              the end of a destructor.  As a special optimization, don't
12458              emit test if this is an empty destructor.  If it does nothing,
12459              it does nothing.  If it calls a base destructor, the base
12460              destructor will perform the test.  */
12461
12462           if (exprstmt != error_mark_node
12463               && (TREE_CODE (exprstmt) != NOP_EXPR
12464                   || TREE_OPERAND (exprstmt, 0) != integer_zero_node
12465                   || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
12466             {
12467               expand_label (dtor_label);
12468               if (cond != integer_one_node)
12469                 expand_start_cond (cond, 0);
12470               if (exprstmt != void_zero_node)
12471                 /* Don't call `expand_expr_stmt' if we're not going to do
12472                    anything, since -Wall will give a diagnostic.  */
12473                 expand_expr_stmt (exprstmt);
12474
12475               /* Run destructor on all virtual baseclasses.  */
12476               if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12477                 {
12478                   tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
12479                   expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
12480                                             in_charge_node, integer_two_node), 0);
12481                   while (vbases)
12482                     {
12483                       if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
12484                         {
12485                           tree vb = get_vbase
12486                             (BINFO_TYPE (vbases),
12487                              TYPE_BINFO (current_class_type));
12488                           expand_expr_stmt
12489                             (build_scoped_method_call
12490                              (current_class_ref, vb, dtor_identifier,
12491                               build_expr_list (NULL_TREE, integer_zero_node)));
12492                         }
12493                       vbases = TREE_CHAIN (vbases);
12494                     }
12495                   expand_end_cond ();
12496                 }
12497
12498               do_pending_stack_adjust ();
12499               if (cond != integer_one_node)
12500                 expand_end_cond ();
12501             }
12502
12503           TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
12504
12505           virtual_size = c_sizeof (current_class_type);
12506
12507           /* At the end, call delete if that's what's requested.  */
12508           if (TYPE_GETS_REG_DELETE (current_class_type))
12509             /* This NOP_EXPR means we are in a static call context.  */
12510             exprstmt
12511               = build_method_call (build_indirect_ref (build1 (NOP_EXPR,
12512                                                                build_pointer_type (current_class_type),
12513                                                                error_mark_node),
12514                                                        NULL_PTR),
12515                                    ansi_opname[(int) DELETE_EXPR],
12516                                    expr_tree_cons (NULL_TREE, current_class_ptr,
12517                                               build_expr_list (NULL_TREE, virtual_size)),
12518                                    NULL_TREE, LOOKUP_NORMAL);
12519           else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12520             exprstmt = build_x_delete (ptr_type_node, current_class_ptr, 0,
12521                                        virtual_size);
12522           else
12523             exprstmt = NULL_TREE;
12524
12525           if (exprstmt)
12526             {
12527               cond = build (BIT_AND_EXPR, integer_type_node,
12528                             in_charge_node, integer_one_node);
12529               expand_start_cond (cond, 0);
12530               expand_expr_stmt (exprstmt);
12531               expand_end_cond ();
12532             }
12533
12534           /* End of destructor.  */
12535           expand_end_bindings (NULL_TREE, getdecls () != NULL_TREE, 0);
12536           poplevel (2, 0, 0);   /* XXX change to 1 */
12537
12538           /* Back to the top of destructor.  */
12539           /* Don't execute destructor code if `this' is NULL.  */
12540
12541           start_sequence ();
12542
12543           /* If the dtor is empty, and we know there is not possible way we
12544              could use any vtable entries, before they are possibly set by
12545              a base class dtor, we don't have to setup the vtables, as we
12546              know that any base class dtoring will set up any vtables it
12547              needs.  We avoid MI, because one base class dtor can do a
12548              virtual dispatch to an overridden function that would need to
12549              have a non-related vtable set up, we cannot avoid setting up
12550              vtables in that case.  We could change this to see if there is
12551              just one vtable.  */
12552           if (! empty_dtor || TYPE_USES_COMPLEX_INHERITANCE (current_class_type))
12553             {
12554               /* Make all virtual function table pointers in non-virtual base
12555                  classes point to CURRENT_CLASS_TYPE's virtual function
12556                  tables.  */
12557               expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_ptr);
12558
12559               if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12560                 expand_indirect_vtbls_init (binfo, current_class_ref, current_class_ptr);
12561             }
12562
12563           if (! ok_to_optimize_dtor)
12564             {
12565               cond = build_binary_op (NE_EXPR,
12566                                       current_class_ptr, integer_zero_node, 1);
12567               expand_start_cond (cond, 0);
12568             }
12569
12570           insns = get_insns ();
12571           end_sequence ();
12572
12573           last_parm_insn = get_first_nonparm_insn ();
12574           if (last_parm_insn == NULL_RTX)
12575             last_parm_insn = get_last_insn ();
12576           else
12577             last_parm_insn = previous_insn (last_parm_insn);
12578
12579           emit_insns_after (insns, last_parm_insn);
12580
12581           if (! ok_to_optimize_dtor)
12582             expand_end_cond ();
12583         }
12584       else if (current_function_assigns_this)
12585         {
12586           /* Does not need to call emit_base_init, because
12587              that is done (if needed) just after assignment to this
12588              is seen.  */
12589
12590           if (DECL_CONSTRUCTOR_P (current_function_decl))
12591             {
12592               end_protect_partials ();
12593               expand_label (ctor_label);
12594               ctor_label = NULL_TREE;
12595
12596               if (call_poplevel)
12597                 {
12598                   decls = getdecls ();
12599                   expand_end_bindings (decls, decls != NULL_TREE, 0);
12600                   poplevel (decls != NULL_TREE, 0, 0);
12601                 }
12602               c_expand_return (current_class_ptr);
12603             }
12604           else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl))) != VOID_TYPE
12605                    && return_label != NULL_RTX)
12606             no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12607
12608           current_function_assigns_this = 0;
12609           current_function_just_assigned_this = 0;
12610           base_init_expr = NULL_TREE;
12611         }
12612       else if (DECL_CONSTRUCTOR_P (fndecl))
12613         {
12614           tree cond = NULL_TREE, thenclause = NULL_TREE;
12615           /* Allow constructor for a type to get a new instance of the object
12616              using `build_new'.  */
12617           tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
12618           CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
12619
12620           DECL_RETURNS_FIRST_ARG (fndecl) = 1;
12621
12622           if (flag_this_is_variable > 0)
12623             {
12624               cond = build_binary_op (EQ_EXPR,
12625                                       current_class_ptr, integer_zero_node, 1);
12626               thenclause = build_modify_expr (current_class_ptr, NOP_EXPR,
12627                                               build_new (NULL_TREE, current_class_type, void_type_node, 0));
12628             }
12629
12630           CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
12631
12632           start_sequence ();
12633
12634           if (flag_this_is_variable > 0)
12635             {
12636               expand_start_cond (cond, 0);
12637               expand_expr_stmt (thenclause);
12638               expand_end_cond ();
12639             }
12640
12641           /* Emit insns from `emit_base_init' which sets up virtual
12642              function table pointer(s).  */
12643           if (base_init_expr)
12644             {
12645               expand_expr_stmt (base_init_expr);
12646               base_init_expr = NULL_TREE;
12647             }
12648
12649           insns = get_insns ();
12650           end_sequence ();
12651
12652           /* This is where the body of the constructor begins.  */
12653
12654           emit_insns_after (insns, last_parm_cleanup_insn);
12655
12656           end_protect_partials ();
12657
12658           /* This is where the body of the constructor ends.  */
12659           expand_label (ctor_label);
12660           ctor_label = NULL_TREE;
12661
12662           if (call_poplevel)
12663             {
12664               decls = getdecls ();
12665               expand_end_bindings (decls, decls != NULL_TREE, 0);
12666               poplevel (decls != NULL_TREE, 1, 0);
12667             }
12668
12669           c_expand_return (current_class_ptr);
12670
12671           current_function_assigns_this = 0;
12672           current_function_just_assigned_this = 0;
12673         }
12674       else if (DECL_MAIN_P (fndecl))
12675         {
12676           /* Make it so that `main' always returns 0 by default.  */
12677 #ifdef VMS
12678           c_expand_return (integer_one_node);
12679 #else
12680           c_expand_return (integer_zero_node);
12681 #endif
12682         }
12683       else if (return_label != NULL_RTX
12684                && current_function_return_value == NULL_TREE
12685                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
12686         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12687
12688       if (flag_exceptions)
12689         expand_exception_blocks ();
12690
12691       /* If this function is supposed to return a value, ensure that
12692          we do not fall into the cleanups by mistake.  The end of our
12693          function will look like this:
12694
12695          user code (may have return stmt somewhere)
12696          goto no_return_label
12697          cleanup_label:
12698          cleanups
12699          goto return_label
12700          no_return_label:
12701          NOTE_INSN_FUNCTION_END
12702          return_label:
12703          things for return
12704
12705          If the user omits a return stmt in the USER CODE section, we
12706          will have a control path which reaches NOTE_INSN_FUNCTION_END.
12707          Otherwise, we won't.  */
12708       if (no_return_label)
12709         {
12710           DECL_CONTEXT (no_return_label) = fndecl;
12711           DECL_INITIAL (no_return_label) = error_mark_node;
12712           DECL_SOURCE_FILE (no_return_label) = input_filename;
12713           DECL_SOURCE_LINE (no_return_label) = lineno;
12714           expand_goto (no_return_label);
12715         }
12716
12717       if (cleanup_label)
12718         {
12719           /* Remove the binding contour which is used
12720              to catch cleanup-generated temporaries.  */
12721           expand_end_bindings (0, 0, 0);
12722           poplevel (0, 0, 0);
12723
12724           /* Emit label at beginning of cleanup code for parameters.  */
12725           emit_label (cleanup_label);
12726         }
12727
12728       /* Get return value into register if that's where it's supposed to be.  */
12729       if (original_result_rtx)
12730         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
12731
12732       /* Finish building code that will trigger warnings if users forget
12733          to make their functions return values.  */
12734       if (no_return_label || cleanup_label)
12735         emit_jump (return_label);
12736       if (no_return_label)
12737         {
12738           /* We don't need to call `expand_*_return' here because we
12739              don't need any cleanups here--this path of code is only
12740              for error checking purposes.  */
12741           expand_label (no_return_label);
12742         }
12743
12744       /* Generate rtl for function exit.  */
12745       expand_function_end (input_filename, lineno, 1);
12746     }
12747
12748   /* This must come after expand_function_end because cleanups might
12749      have declarations (from inline functions) that need to go into
12750      this function's blocks.  */
12751   if (current_binding_level->parm_flag != 1)
12752     my_friendly_abort (122);
12753   poplevel (1, 0, 1);
12754
12755   /* Reset scope for C++: if we were in the scope of a class,
12756      then when we finish this function, we are not longer so.
12757      This cannot be done until we know for sure that no more
12758      class members will ever be referenced in this function
12759      (i.e., calls to destructors).  */
12760   if (current_class_name)
12761     {
12762       ctype = current_class_type;
12763       pop_nested_class (1);
12764     }
12765   else
12766     pop_memoized_context (1);
12767
12768   /* Must mark the RESULT_DECL as being in this function.  */
12769   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12770
12771   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12772      to the FUNCTION_DECL node itself.  */
12773   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12774
12775   if (! processing_template_decl)
12776     {
12777       int saved_flag_keep_inline_functions =
12778         flag_keep_inline_functions;
12779
12780       /* So we can tell if jump_optimize sets it to 1.  */
12781       can_reach_end = 0;
12782
12783       if (DECL_CONTEXT (fndecl) != NULL_TREE
12784           && hack_decl_function_context (fndecl))
12785         /* Trick rest_of_compilation into not deferring output of this
12786            function, even if it is inline, since the rtl_obstack for
12787            this function is the function_obstack of the enclosing
12788            function and will be deallocated when the enclosing
12789            function is gone.  See save_tree_status.  */
12790         flag_keep_inline_functions = 1;
12791
12792       /* Run the optimizers and output the assembler code for this
12793          function.  */
12794
12795       if (DECL_ARTIFICIAL (fndecl))
12796         {
12797           /* Do we really *want* to inline this synthesized method?  */
12798
12799           int save_fif = flag_inline_functions;
12800           flag_inline_functions = 1;
12801
12802           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
12803              will check our size.  */
12804           DECL_INLINE (fndecl) = 0;
12805
12806           rest_of_compilation (fndecl);
12807           flag_inline_functions = save_fif;
12808         }
12809       else
12810         rest_of_compilation (fndecl);
12811
12812       flag_keep_inline_functions = saved_flag_keep_inline_functions;
12813
12814       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
12815         {
12816           /* Set DECL_EXTERNAL so that assemble_external will be called as
12817              necessary.  We'll clear it again in finish_file.  */
12818           if (! DECL_EXTERNAL (fndecl))
12819             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
12820           DECL_EXTERNAL (fndecl) = 1;
12821           mark_inline_for_output (fndecl);
12822         }
12823
12824       if (ctype && TREE_ASM_WRITTEN (fndecl))
12825         note_debug_info_needed (ctype);
12826
12827       current_function_returns_null |= can_reach_end;
12828
12829       /* Since we don't normally go through c_expand_return for constructors,
12830          this normally gets the wrong value.
12831          Also, named return values have their return codes emitted after
12832          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
12833       if (DECL_CONSTRUCTOR_P (fndecl)
12834           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
12835         current_function_returns_null = 0;
12836
12837       if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
12838         cp_warning ("`noreturn' function `%D' does return", fndecl);
12839       else if ((warn_return_type || pedantic)
12840                && current_function_returns_null
12841                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
12842         {
12843           /* If this function returns non-void and control can drop through,
12844              complain.  */
12845           cp_warning ("control reaches end of non-void function `%D'", fndecl);
12846         }
12847       /* With just -W, complain only if function returns both with
12848          and without a value.  */
12849       else if (extra_warnings
12850                && current_function_returns_value && current_function_returns_null)
12851         warning ("this function may return with or without a value");
12852     }
12853
12854   --function_depth;
12855
12856   /* Free all the tree nodes making up this function.  */
12857   /* Switch back to allocating nodes permanently
12858      until we start another function.  */
12859   if (processing_template_decl)
12860     {
12861       --minimal_parse_mode;
12862       DECL_SAVED_TREE (fndecl) = TREE_CHAIN (DECL_SAVED_TREE (fndecl));
12863     }
12864
12865   if (! nested)
12866     permanent_allocation (1);
12867
12868   if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
12869     {
12870       tree t;
12871
12872       /* Stop pointing to the local nodes about to be freed.  */
12873       /* But DECL_INITIAL must remain nonzero so we know this
12874          was an actual function definition.  */
12875       DECL_INITIAL (fndecl) = error_mark_node;
12876       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
12877         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
12878     }
12879
12880   if (DECL_STATIC_CONSTRUCTOR (fndecl))
12881     static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
12882   if (DECL_STATIC_DESTRUCTOR (fndecl))
12883     static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
12884
12885   if (! nested)
12886     {
12887       /* Let the error reporting routines know that we're outside a
12888          function.  For a nested function, this value is used in
12889          pop_cp_function_context and then reset via pop_function_context.  */
12890       current_function_decl = NULL_TREE;
12891     }
12892
12893   named_label_uses = NULL;
12894   current_class_ptr = NULL_TREE;
12895   current_class_ref = NULL_TREE;
12896 }
12897 \f
12898 /* Create the FUNCTION_DECL for a function definition.
12899    LINE1 is the line number that the definition absolutely begins on.
12900    LINE2 is the line number that the name of the function appears on.
12901    DECLSPECS and DECLARATOR are the parts of the declaration;
12902    they describe the return type and the name of the function,
12903    but twisted together in a fashion that parallels the syntax of C.
12904
12905    This function creates a binding context for the function body
12906    as well as setting up the FUNCTION_DECL in current_function_decl.
12907
12908    Returns a FUNCTION_DECL on success.
12909
12910    If the DECLARATOR is not suitable for a function (it defines a datum
12911    instead), we return 0, which tells yyparse to report a parse error.
12912
12913    May return void_type_node indicating that this method is actually
12914    a friend.  See grokfield for more details.
12915
12916    Came here with a `.pushlevel' .
12917
12918    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12919    CHANGES TO CODE IN `grokfield'.  */
12920
12921 tree
12922 start_method (declspecs, declarator)
12923      tree declarator, declspecs;
12924 {
12925   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12926                                 NULL_TREE);
12927
12928   /* Something too ugly to handle.  */
12929   if (fndecl == NULL_TREE)
12930     return NULL_TREE;
12931
12932   /* Pass friends other than inline friend functions back.  */
12933   if (fndecl == void_type_node)
12934     return fndecl;
12935
12936   if (TREE_CODE (fndecl) != FUNCTION_DECL)
12937     /* Not a function, tell parser to report parse error.  */
12938     return NULL_TREE;
12939
12940   if (IS_SIGNATURE (current_class_type))
12941     IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
12942
12943   if (DECL_IN_AGGR_P (fndecl))
12944     {
12945       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
12946         {
12947           if (DECL_CONTEXT (fndecl)
12948               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12949             cp_error ("`%D' is already defined in class %s", fndecl,
12950                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
12951         }
12952       return void_type_node;
12953     }
12954
12955   DECL_THIS_INLINE (fndecl) = 1;
12956
12957   if (flag_default_inline)
12958     DECL_INLINE (fndecl) = 1;
12959
12960   if (processing_template_decl)
12961     fndecl = push_template_decl (fndecl);
12962
12963   /* We read in the parameters on the maybepermanent_obstack,
12964      but we won't be getting back to them until after we
12965      may have clobbered them.  So the call to preserve_data
12966      will keep them safe.  */
12967   preserve_data ();
12968
12969   if (! DECL_FRIEND_P (fndecl))
12970     {
12971       if (TREE_CHAIN (fndecl))
12972         {
12973           fndecl = copy_node (fndecl);
12974           TREE_CHAIN (fndecl) = NULL_TREE;
12975         }
12976
12977       if (DECL_CONSTRUCTOR_P (fndecl))
12978         {
12979           if (! grok_ctor_properties (current_class_type, fndecl))
12980             return void_type_node;
12981         }
12982       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
12983         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
12984     }
12985
12986   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
12987
12988   /* Make a place for the parms */
12989   pushlevel (0);
12990   current_binding_level->parm_flag = 1;
12991
12992   DECL_IN_AGGR_P (fndecl) = 1;
12993   return fndecl;
12994 }
12995
12996 /* Go through the motions of finishing a function definition.
12997    We don't compile this method until after the whole class has
12998    been processed.
12999
13000    FINISH_METHOD must return something that looks as though it
13001    came from GROKFIELD (since we are defining a method, after all).
13002
13003    This is called after parsing the body of the function definition.
13004    STMTS is the chain of statements that makes up the function body.
13005
13006    DECL is the ..._DECL that `start_method' provided.  */
13007
13008 tree
13009 finish_method (decl)
13010      tree decl;
13011 {
13012   register tree fndecl = decl;
13013   tree old_initial;
13014
13015   register tree link;
13016
13017   if (decl == void_type_node)
13018     return decl;
13019
13020   old_initial = DECL_INITIAL (fndecl);
13021
13022   /* Undo the level for the parms (from start_method).
13023      This is like poplevel, but it causes nothing to be
13024      saved.  Saving information here confuses symbol-table
13025      output routines.  Besides, this information will
13026      be correctly output when this method is actually
13027      compiled.  */
13028
13029   /* Clear out the meanings of the local variables of this level;
13030      also record in each decl which block it belongs to.  */
13031
13032   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
13033     {
13034       if (DECL_NAME (link) != NULL_TREE)
13035         IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
13036       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
13037       DECL_CONTEXT (link) = NULL_TREE;
13038     }
13039
13040   /* Restore all name-meanings of the outer levels
13041      that were shadowed by this level.  */
13042
13043   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
13044       IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
13045   for (link = current_binding_level->class_shadowed;
13046        link; link = TREE_CHAIN (link))
13047     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
13048   for (link = current_binding_level->type_shadowed;
13049        link; link = TREE_CHAIN (link))
13050     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
13051
13052   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
13053                       (HOST_WIDE_INT) current_binding_level->level_chain,
13054                       current_binding_level->parm_flag,
13055                       current_binding_level->keep);
13056
13057   poplevel (0, 0, 0);
13058
13059   DECL_INITIAL (fndecl) = old_initial;
13060
13061   /* We used to check if the context of FNDECL was different from
13062      current_class_type as another way to get inside here.  This didn't work
13063      for String.cc in libg++.  */
13064   if (DECL_FRIEND_P (fndecl))
13065     {
13066       CLASSTYPE_INLINE_FRIENDS (current_class_type)
13067         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
13068       decl = void_type_node;
13069     }
13070
13071   return decl;
13072 }
13073 \f
13074 /* Called when a new struct TYPE is defined.
13075    If this structure or union completes the type of any previous
13076    variable declaration, lay it out and output its rtl.  */
13077
13078 void
13079 hack_incomplete_structures (type)
13080      tree type;
13081 {
13082   tree *list;
13083
13084   if (current_binding_level->incomplete == NULL_TREE)
13085     return;
13086
13087   if (!type) /* Don't do this for class templates.  */
13088     return;
13089
13090   for (list = &current_binding_level->incomplete; *list; )
13091     {
13092       tree decl = TREE_VALUE (*list);
13093       if ((decl && TREE_TYPE (decl) == type)
13094           || (TREE_TYPE (decl)
13095               && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
13096               && TREE_TYPE (TREE_TYPE (decl)) == type))
13097         {
13098           int toplevel = toplevel_bindings_p ();
13099           if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
13100               && TREE_TYPE (TREE_TYPE (decl)) == type)
13101             layout_type (TREE_TYPE (decl));
13102           layout_decl (decl, 0);
13103           rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
13104           if (! toplevel)
13105             {
13106               tree cleanup;
13107               expand_decl (decl);
13108               cleanup = maybe_build_cleanup (decl);
13109               expand_decl_init (decl);
13110               if (! expand_decl_cleanup (decl, cleanup))
13111                 cp_error ("parser lost in parsing declaration of `%D'",
13112                           decl);
13113             }
13114           *list = TREE_CHAIN (*list);
13115         }
13116       else
13117         list = &TREE_CHAIN (*list);
13118     }
13119 }
13120
13121 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13122    See build_delete for information about AUTO_DELETE.
13123
13124    Don't build these on the momentary obstack; they must live
13125    the life of the binding contour.  */
13126
13127 static tree
13128 maybe_build_cleanup_1 (decl, auto_delete)
13129      tree decl, auto_delete;
13130 {
13131   tree type = TREE_TYPE (decl);
13132   if (TYPE_NEEDS_DESTRUCTOR (type))
13133     {
13134       int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13135       tree rval;
13136
13137       if (TREE_CODE (decl) != PARM_DECL)
13138         temp = suspend_momentary ();
13139
13140       if (TREE_CODE (type) == ARRAY_TYPE)
13141         rval = decl;
13142       else
13143         {
13144           mark_addressable (decl);
13145           rval = build_unary_op (ADDR_EXPR, decl, 0);
13146         }
13147
13148       /* Optimize for space over speed here.  */
13149       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
13150           || flag_expensive_optimizations)
13151         flags |= LOOKUP_NONVIRTUAL;
13152
13153       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
13154
13155       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
13156           && ! TYPE_HAS_DESTRUCTOR (type))
13157         rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
13158                                                build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
13159
13160       if (TREE_CODE (decl) != PARM_DECL)
13161         resume_momentary (temp);
13162
13163       return rval;
13164     }
13165   return 0;
13166 }
13167
13168 /* If DECL is of a type which needs a cleanup, build that cleanup
13169    here.  The cleanup does free the storage with a call to delete.  */
13170
13171 tree
13172 maybe_build_cleanup_and_delete (decl)
13173      tree decl;
13174 {
13175   return maybe_build_cleanup_1 (decl, integer_three_node);
13176 }
13177
13178 /* If DECL is of a type which needs a cleanup, build that cleanup
13179    here.  The cleanup does not free the storage with a call a delete.  */
13180
13181 tree
13182 maybe_build_cleanup (decl)
13183      tree decl;
13184 {
13185   return maybe_build_cleanup_1 (decl, integer_two_node);
13186 }
13187 \f
13188 /* Expand a C++ expression at the statement level.
13189    This is needed to ferret out nodes which have UNKNOWN_TYPE.
13190    The C++ type checker should get all of these out when
13191    expressions are combined with other, type-providing, expressions,
13192    leaving only orphan expressions, such as:
13193
13194    &class::bar;         / / takes its address, but does nothing with it.  */
13195
13196 void
13197 cplus_expand_expr_stmt (exp)
13198      tree exp;
13199 {
13200   if (processing_template_decl)
13201     {
13202       add_tree (build_min_nt (EXPR_STMT, exp));
13203       return;
13204     }
13205
13206   /* Arrange for all temps to disappear.  */
13207   expand_start_target_temps ();
13208
13209   if (TREE_TYPE (exp) == unknown_type_node)
13210     {
13211       if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
13212         error ("address of overloaded function with no contextual type information");
13213       else if (TREE_CODE (exp) == COMPONENT_REF)
13214         warning ("useless reference to a member function name, did you forget the ()?");
13215     }
13216   else
13217     {
13218       if (TREE_CODE (exp) == FUNCTION_DECL)
13219         {
13220           cp_warning ("reference, not call, to function `%D'", exp);
13221           warning ("at this point in file");
13222         }
13223
13224 #if 0
13225       /* We should do this eventually, but right now this causes regex.o from
13226          libg++ to miscompile, and tString to core dump.  */
13227       exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
13228 #endif
13229
13230       /* Strip unused implicit INDIRECT_REFs of references.  */
13231       if (TREE_CODE (exp) == INDIRECT_REF
13232           && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
13233         exp = TREE_OPERAND (exp, 0);
13234
13235       /* If we don't do this, we end up down inside expand_expr
13236          trying to do TYPE_MODE on the ERROR_MARK, and really
13237          go outside the bounds of the type.  */
13238       if (exp != error_mark_node)
13239         expand_expr_stmt (break_out_cleanups (exp));
13240     }
13241
13242   /* Clean up any pending cleanups.  This happens when a function call
13243      returns a cleanup-needing value that nobody uses.  */
13244   expand_end_target_temps ();
13245 }
13246
13247 /* When a stmt has been parsed, this function is called.
13248
13249    Currently, this function only does something within a
13250    constructor's scope: if a stmt has just assigned to this,
13251    and we are in a derived class, we call `emit_base_init'.  */
13252
13253 void
13254 finish_stmt ()
13255 {
13256   extern struct nesting *cond_stack, *loop_stack, *case_stack;
13257
13258
13259   if (current_function_assigns_this
13260       || ! current_function_just_assigned_this)
13261     return;
13262   if (DECL_CONSTRUCTOR_P (current_function_decl))
13263     {
13264       /* Constructors must wait until we are out of control
13265          zones before calling base constructors.  */
13266       if (cond_stack || loop_stack || case_stack)
13267         return;
13268       expand_expr_stmt (base_init_expr);
13269       check_base_init (current_class_type);
13270     }
13271   current_function_assigns_this = 1;
13272 }
13273
13274 /* Change a static member function definition into a FUNCTION_TYPE, instead
13275    of the METHOD_TYPE that we create when it's originally parsed.
13276
13277    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13278    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13279    other decls.  Either pass the addresses of local variables or NULL.  */
13280
13281 void
13282 revert_static_member_fn (decl, fn, argtypes)
13283      tree *decl, *fn, *argtypes;
13284 {
13285   tree tmp;
13286   tree function = fn ? *fn : TREE_TYPE (*decl);
13287   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
13288
13289   if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (args))))
13290     cp_error ("static member function `%#D' declared const", *decl);
13291   if (TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (args))))
13292     cp_error ("static member function `%#D' declared volatile", *decl);
13293
13294   args = TREE_CHAIN (args);
13295   tmp = build_function_type (TREE_TYPE (function), args);
13296   tmp = build_type_variant (tmp, TYPE_READONLY (function),
13297                             TYPE_VOLATILE (function));
13298   tmp = build_exception_variant (tmp,
13299                                  TYPE_RAISES_EXCEPTIONS (function));
13300   TREE_TYPE (*decl) = tmp;
13301   if (DECL_ARGUMENTS (*decl))
13302     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
13303   DECL_STATIC_FUNCTION_P (*decl) = 1;
13304   if (fn)
13305     *fn = tmp;
13306   if (argtypes)
13307     *argtypes = args;
13308 }
13309
13310 int
13311 id_in_current_class (id)
13312      tree id;
13313 {
13314   return !!purpose_member (id, class_binding_level->class_shadowed);
13315 }
13316
13317 struct cp_function
13318 {
13319   int returns_value;
13320   int returns_null;
13321   int warn_about_return_type;
13322   int assigns_this;
13323   int just_assigned_this;
13324   int parms_stored;
13325   int temp_name_counter;
13326   tree named_labels;
13327   tree shadowed_labels;
13328   tree ctor_label;
13329   tree dtor_label;
13330   rtx last_dtor_insn;
13331   rtx last_parm_cleanup_insn;
13332   tree base_init_list;
13333   tree member_init_list;
13334   tree base_init_expr;
13335   tree current_class_ptr;
13336   tree current_class_ref;
13337   rtx result_rtx;
13338   struct cp_function *next;
13339   struct binding_level *binding_level;
13340   int static_labelno;
13341 };
13342
13343 static struct cp_function *cp_function_chain;
13344
13345 extern int temp_name_counter;
13346
13347 /* Save and reinitialize the variables
13348    used during compilation of a C++ function.  */
13349
13350 void
13351 push_cp_function_context (context)
13352      tree context;
13353 {
13354   struct cp_function *p
13355     = (struct cp_function *) xmalloc (sizeof (struct cp_function));
13356
13357   push_function_context_to (context);
13358
13359   p->next = cp_function_chain;
13360   cp_function_chain = p;
13361
13362   p->named_labels = named_labels;
13363   p->shadowed_labels = shadowed_labels;
13364   p->returns_value = current_function_returns_value;
13365   p->returns_null = current_function_returns_null;
13366   p->warn_about_return_type = warn_about_return_type;
13367   p->binding_level = current_binding_level;
13368   p->ctor_label = ctor_label;
13369   p->dtor_label = dtor_label;
13370   p->last_dtor_insn = last_dtor_insn;
13371   p->last_parm_cleanup_insn = last_parm_cleanup_insn;
13372   p->assigns_this = current_function_assigns_this;
13373   p->just_assigned_this = current_function_just_assigned_this;
13374   p->parms_stored = current_function_parms_stored;
13375   p->result_rtx = original_result_rtx;
13376   p->base_init_expr = base_init_expr;
13377   p->temp_name_counter = temp_name_counter;
13378   p->base_init_list = current_base_init_list;
13379   p->member_init_list = current_member_init_list;
13380   p->current_class_ptr = current_class_ptr;
13381   p->current_class_ref = current_class_ref;
13382   p->static_labelno = static_labelno;
13383 }
13384
13385 /* Restore the variables used during compilation of a C++ function.  */
13386
13387 void
13388 pop_cp_function_context (context)
13389      tree context;
13390 {
13391   struct cp_function *p = cp_function_chain;
13392   tree link;
13393
13394   /* Bring back all the labels that were shadowed.  */
13395   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
13396     if (DECL_NAME (TREE_VALUE (link)) != 0)
13397       SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
13398                                   TREE_VALUE (link));
13399
13400   pop_function_context_from (context);
13401
13402   cp_function_chain = p->next;
13403
13404   named_labels = p->named_labels;
13405   shadowed_labels = p->shadowed_labels;
13406   current_function_returns_value = p->returns_value;
13407   current_function_returns_null = p->returns_null;
13408   warn_about_return_type = p->warn_about_return_type;
13409   current_binding_level = p->binding_level;
13410   ctor_label = p->ctor_label;
13411   dtor_label = p->dtor_label;
13412   last_dtor_insn = p->last_dtor_insn;
13413   last_parm_cleanup_insn = p->last_parm_cleanup_insn;
13414   current_function_assigns_this = p->assigns_this;
13415   current_function_just_assigned_this = p->just_assigned_this;
13416   current_function_parms_stored = p->parms_stored;
13417   original_result_rtx = p->result_rtx;
13418   base_init_expr = p->base_init_expr;
13419   temp_name_counter = p->temp_name_counter;
13420   current_base_init_list = p->base_init_list;
13421   current_member_init_list = p->member_init_list;
13422   current_class_ptr = p->current_class_ptr;
13423   current_class_ref = p->current_class_ref;
13424   static_labelno = p->static_labelno;
13425
13426   free (p);
13427 }
13428
13429 int
13430 in_function_p ()
13431 {
13432   return function_depth != 0;
13433 }