gcc/cp/typeck2.c

   1 /* Report error messages, build initializers, and perform
   2    some front-end optimizations for C++ compiler.
   3    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5    Hacked by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* This file is part of the C++ front end.
  26    It contains routines to build C++ expressions given their operands,
  27    including computing the types of the result, C and C++ specific error
  28    checks, and some optimization.
  29
  30    There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
  31    and to process initializations in declarations (since they work
  32    like a strange sort of assignment).  */
  33
  34 #include "config.h"
  35 #include "system.h"
  36 #include "coretypes.h"
  37 #include "tm.h"
  38 #include "tree.h"
  39 #include "cp-tree.h"
  40 #include "flags.h"
  41 #include "toplev.h"
  42 #include "output.h"
  43 #include "diagnostic.h"
  44
  45 static tree process_init_constructor PARAMS ((tree, tree, tree *));
  46
  47 /* Print an error message stemming from an attempt to use
  48    BASETYPE as a base class for TYPE.  */
  49
  50 tree
  51 error_not_base_type (basetype, type)
  52      tree basetype, type;
  53 {
  54   if (TREE_CODE (basetype) == FUNCTION_DECL)
  55     basetype = DECL_CONTEXT (basetype);
  56   error ("type `%T' is not a base type for type `%T'", basetype, type);
  57   return error_mark_node;
  58 }
  59
  60 tree
  61 binfo_or_else (base, type)
  62      tree base, type;
  63 {
  64   tree binfo = lookup_base (type, base, ba_ignore, NULL);
  65
  66   if (binfo == error_mark_node)
  67     return NULL_TREE;
  68   else if (!binfo)
  69     error_not_base_type (base, type);
  70   return binfo;
  71 }
  72
  73 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
  74    value may not be changed thereafter.  Thus, we emit hard errors for these,
  75    rather than just pedwarns.  If `SOFT' is 1, then we just pedwarn.  (For
  76    example, conversions to references.)  */
  77
  78 void
  79 readonly_error (arg, string, soft)
  80      tree arg;
  81      const char *string;
  82      int soft;
  83 {
  84   const char *fmt;
  85   void (*fn) PARAMS ((const char *, ...));
  86
  87   if (soft)
  88     fn = pedwarn;
  89   else
  90     fn = error;
  91
  92   if (TREE_CODE (arg) == COMPONENT_REF)
  93     {
  94       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
  95         fmt = "%s of data-member `%D' in read-only structure";
  96       else
  97         fmt = "%s of read-only data-member `%D'";
  98       (*fn) (fmt, string, TREE_OPERAND (arg, 1));
  99     }
 100   else if (TREE_CODE (arg) == VAR_DECL)
 101     {
 102       if (DECL_LANG_SPECIFIC (arg)
 103           && DECL_IN_AGGR_P (arg)
 104           && !TREE_STATIC (arg))
 105         fmt = "%s of constant field `%D'";
 106       else
 107         fmt = "%s of read-only variable `%D'";
 108       (*fn) (fmt, string, arg);
 109     }
 110   else if (TREE_CODE (arg) == PARM_DECL)
 111     (*fn) ("%s of read-only parameter `%D'", string, arg);
 112   else if (TREE_CODE (arg) == INDIRECT_REF
 113            && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
 114            && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
 115                || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
 116     (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0));
 117   else if (TREE_CODE (arg) == RESULT_DECL)
 118     (*fn) ("%s of read-only named return value `%D'", string, arg);
 119   else if (TREE_CODE (arg) == FUNCTION_DECL)
 120     (*fn) ("%s of function `%D'", string, arg);
 121   else
 122     (*fn) ("%s of read-only location", string);
 123 }
 124
 125 /* If TYPE has abstract virtual functions, issue an error about trying
 126    to create an object of that type.  DECL is the object declared, or
 127    NULL_TREE if the declaration is unavailable.  Returns 1 if an error
 128    occurred; zero if all was well.  */
 129
 130 int
 131 abstract_virtuals_error (decl, type)
 132      tree decl;
 133      tree type;
 134 {
 135   tree u;
 136   tree tu;
 137
 138   if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type))
 139     return 0;
 140
 141   if (!TYPE_SIZE (type))
 142     /* TYPE is being defined, and during that time
 143        CLASSTYPE_PURE_VIRTUALS holds the inline friends.  */
 144     return 0;
 145
 146   if (dependent_type_p (type))
 147     /* For a dependent type, we do not yet know which functions are pure
 148        virtuals.  */
 149     return 0;
 150
 151   u = CLASSTYPE_PURE_VIRTUALS (type);
 152   if (decl)
 153     {
 154       if (TREE_CODE (decl) == RESULT_DECL)
 155         return 0;
 156
 157       if (TREE_CODE (decl) == VAR_DECL)
 158         error ("cannot declare variable `%D' to be of type `%T'",
 159                     decl, type);
 160       else if (TREE_CODE (decl) == PARM_DECL)
 161         error ("cannot declare parameter `%D' to be of type `%T'",
 162                     decl, type);
 163       else if (TREE_CODE (decl) == FIELD_DECL)
 164         error ("cannot declare field `%D' to be of type `%T'",
 165                     decl, type);
 166       else if (TREE_CODE (decl) == FUNCTION_DECL
 167                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
 168         error ("invalid return type for member function `%#D'", decl);
 169       else if (TREE_CODE (decl) == FUNCTION_DECL)
 170         error ("invalid return type for function `%#D'", decl);
 171     }
 172   else
 173     error ("cannot allocate an object of type `%T'", type);
 174
 175   /* Only go through this once.  */
 176   if (TREE_PURPOSE (u) == NULL_TREE)
 177     {
 178       TREE_PURPOSE (u) = error_mark_node;
 179
 180       error ("  because the following virtual functions are abstract:");
 181       for (tu = u; tu; tu = TREE_CHAIN (tu))
 182         cp_error_at ("\t%#D", TREE_VALUE (tu));
 183     }
 184   else
 185     error ("  since type `%T' has abstract virtual functions", type);
 186
 187   return 1;
 188 }
 189
 190 /* Print an error message for invalid use of an incomplete type.
 191    VALUE is the expression that was used (or 0 if that isn't known)
 192    and TYPE is the type that was invalid.  DIAG_TYPE indicates the
 193    type of diagnostic:  0 for an error, 1 for a warning, 2 for a
 194    pedwarn.  */
 195
 196 void
 197 cxx_incomplete_type_diagnostic (value, type, diag_type)
 198      tree value;
 199      tree type;
 200      int diag_type;
 201 {
 202   int decl = 0;
 203   void (*p_msg) PARAMS ((const char *, ...));
 204   void (*p_msg_at) PARAMS ((const char *, ...));
 205
 206   if (diag_type == 1)
 207     {
 208       p_msg = warning;
 209       p_msg_at = cp_warning_at;
 210     }
 211   else if (diag_type == 2)
 212     {
 213       p_msg = pedwarn;
 214       p_msg_at = cp_pedwarn_at;
 215     }
 216   else
 217     {
 218       p_msg = error;
 219       p_msg_at = cp_error_at;
 220     }
 221
 222   /* Avoid duplicate error message.  */
 223   if (TREE_CODE (type) == ERROR_MARK)
 224     return;
 225
 226   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 227                      || TREE_CODE (value) == PARM_DECL
 228                      || TREE_CODE (value) == FIELD_DECL))
 229     {
 230       (*p_msg_at) ("`%D' has incomplete type", value);
 231       decl = 1;
 232     }
 233 retry:
 234   /* We must print an error message.  Be clever about what it says.  */
 235
 236   switch (TREE_CODE (type))
 237     {
 238     case RECORD_TYPE:
 239     case UNION_TYPE:
 240     case ENUMERAL_TYPE:
 241       if (!decl)
 242         (*p_msg) ("invalid use of undefined type `%#T'", type);
 243       if (!TYPE_TEMPLATE_INFO (type))
 244         (*p_msg_at) ("forward declaration of `%#T'", type);
 245       else
 246         (*p_msg_at) ("declaration of `%#T'", type);
 247       break;
 248
 249     case VOID_TYPE:
 250       (*p_msg) ("invalid use of `%T'", type);
 251       break;
 252
 253     case ARRAY_TYPE:
 254       if (TYPE_DOMAIN (type))
 255         {
 256           type = TREE_TYPE (type);
 257           goto retry;
 258         }
 259       (*p_msg) ("invalid use of array with unspecified bounds");
 260       break;
 261
 262     case OFFSET_TYPE:
 263     bad_member:
 264       (*p_msg) ("invalid use of member (did you forget the `&' ?)");
 265       break;
 266
 267     case TEMPLATE_TYPE_PARM:
 268       (*p_msg) ("invalid use of template type parameter");
 269       break;
 270
 271     case UNKNOWN_TYPE:
 272       if (value && TREE_CODE (value) == COMPONENT_REF)
 273         goto bad_member;
 274       else if (value && TREE_CODE (value) == ADDR_EXPR)
 275         (*p_msg) ("address of overloaded function with no contextual type information");
 276       else if (value && TREE_CODE (value) == OVERLOAD)
 277         (*p_msg) ("overloaded function with no contextual type information");
 278       else
 279         (*p_msg) ("insufficient contextual information to determine type");
 280       break;
 281
 282     default:
 283       abort ();
 284     }
 285 }
 286
 287 /* Backward-compatibility interface to incomplete_type_diagnostic;
 288    required by ../tree.c.  */
 289 #undef cxx_incomplete_type_error
 290 void
 291 cxx_incomplete_type_error (value, type)
 292      tree value;
 293      tree type;
 294 {
 295   cxx_incomplete_type_diagnostic (value, type, 0);
 296 }
 297
 298 \f
 299 /* Perform appropriate conversions on the initial value of a variable,
 300    store it in the declaration DECL,
 301    and print any error messages that are appropriate.
 302    If the init is invalid, store an ERROR_MARK.
 303
 304    C++: Note that INIT might be a TREE_LIST, which would mean that it is
 305    a base class initializer for some aggregate type, hopefully compatible
 306    with DECL.  If INIT is a single element, and DECL is an aggregate
 307    type, we silently convert INIT into a TREE_LIST, allowing a constructor
 308    to be called.
 309
 310    If INIT is a TREE_LIST and there is no constructor, turn INIT
 311    into a CONSTRUCTOR and use standard initialization techniques.
 312    Perhaps a warning should be generated?
 313
 314    Returns value of initializer if initialization could not be
 315    performed for static variable.  In that case, caller must do
 316    the storing.  */
 317
 318 tree
 319 store_init_value (decl, init)
 320      tree decl, init;
 321 {
 322   register tree value, type;
 323
 324   /* If variable's type was invalidly declared, just ignore it.  */
 325
 326   type = TREE_TYPE (decl);
 327   if (TREE_CODE (type) == ERROR_MARK)
 328     return NULL_TREE;
 329
 330   if (IS_AGGR_TYPE (type))
 331     {
 332       if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
 333           && TREE_CODE (init) != CONSTRUCTOR)
 334         abort ();
 335
 336       if (TREE_CODE (init) == TREE_LIST)
 337         {
 338           error ("constructor syntax used, but no constructor declared for type `%T'", type);
 339           init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
 340         }
 341     }
 342   else if (TREE_CODE (init) == TREE_LIST
 343            && TREE_TYPE (init) != unknown_type_node)
 344     {
 345       if (TREE_CODE (decl) == RESULT_DECL)
 346         {
 347           if (TREE_CHAIN (init))
 348             {
 349               warning ("comma expression used to initialize return value");
 350               init = build_compound_expr (init);
 351             }
 352           else
 353             init = TREE_VALUE (init);
 354         }
 355       else if (TREE_CODE (init) == TREE_LIST
 356                && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
 357         {
 358           error ("cannot initialize arrays using this syntax");
 359           return NULL_TREE;
 360         }
 361       else
 362         {
 363           /* We get here with code like `int a (2);' */
 364
 365           if (TREE_CHAIN (init) != NULL_TREE)
 366             {
 367               pedwarn ("initializer list being treated as compound expression");
 368               init = build_compound_expr (init);
 369             }
 370           else
 371             init = TREE_VALUE (init);
 372         }
 373     }
 374
 375   /* End of special C++ code.  */
 376
 377   /* Digest the specified initializer into an expression.  */
 378   value = digest_init (type, init, (tree *) 0);
 379
 380   /* Store the expression if valid; else report error.  */
 381
 382   if (TREE_CODE (value) == ERROR_MARK)
 383     ;
 384   /* Other code expects that initializers for objects of types that need
 385      constructing never make it into DECL_INITIAL, and passes 'init' to
 386      build_aggr_init without checking DECL_INITIAL.  So just return.  */
 387   else if (TYPE_NEEDS_CONSTRUCTING (type))
 388     return value;
 389   else if (TREE_STATIC (decl)
 390            && (! TREE_CONSTANT (value)
 391                || ! initializer_constant_valid_p (value, TREE_TYPE (value))
 392 #if 0
 393                /* A STATIC PUBLIC int variable doesn't have to be
 394                   run time inited when doing pic.  (mrs) */
 395                /* Since ctors and dtors are the only things that can
 396                   reference vtables, and they are always written down
 397                   the vtable definition, we can leave the
 398                   vtables in initialized data space.
 399                   However, other initialized data cannot be initialized
 400                   this way.  Instead a global file-level initializer
 401                   must do the job.  */
 402                || (flag_pic && !DECL_VIRTUAL_P (decl) && TREE_PUBLIC (decl))
 403 #endif
 404                ))
 405
 406     return value;
 407 #if 0 /* No, that's C.  jason 9/19/94 */
 408   else
 409     {
 410       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
 411         {
 412           if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
 413             pedwarn ("ISO C++ forbids non-constant aggregate initializer expressions");
 414         }
 415     }
 416 #endif
 417
 418   /* Store the VALUE in DECL_INITIAL.  If we're building a
 419      statement-tree we will actually expand the initialization later
 420      when we output this function.  */
 421   DECL_INITIAL (decl) = value;
 422   return NULL_TREE;
 423 }
 424
 425 \f
 426 /* Digest the parser output INIT as an initializer for type TYPE.
 427    Return a C expression of type TYPE to represent the initial value.
 428
 429    If TAIL is nonzero, it points to a variable holding a list of elements
 430    of which INIT is the first.  We update the list stored there by
 431    removing from the head all the elements that we use.
 432    Normally this is only one; we use more than one element only if
 433    TYPE is an aggregate and INIT is not a constructor.  */
 434
 435 tree
 436 digest_init (type, init, tail)
 437      tree type, init, *tail;
 438 {
 439   enum tree_code code = TREE_CODE (type);
 440   tree element = NULL_TREE;
 441   tree old_tail_contents = NULL_TREE;
 442   /* Nonzero if INIT is a braced grouping.  */
 443   int raw_constructor;
 444
 445   /* By default, assume we use one element from a list.
 446      We correct this later in the sole case where it is not true.  */
 447
 448   if (tail)
 449     {
 450       old_tail_contents = *tail;
 451       *tail = TREE_CHAIN (*tail);
 452     }
 453
 454   if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
 455                                   && TREE_VALUE (init) == error_mark_node))
 456     return error_mark_node;
 457
 458   if (TREE_CODE (init) == ERROR_MARK)
 459     /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
 460        a template function. This gets substituted during instantiation.  */
 461     return init;
 462
 463   /* We must strip the outermost array type when completing the type,
 464      because the its bounds might be incomplete at the moment.  */
 465   if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
 466                               ? TREE_TYPE (type) : type, NULL_TREE))
 467     return error_mark_node;
 468
 469   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 470   if (TREE_CODE (init) == NON_LVALUE_EXPR)
 471     init = TREE_OPERAND (init, 0);
 472
 473   raw_constructor = (TREE_CODE (init) == CONSTRUCTOR
 474                      && TREE_HAS_CONSTRUCTOR (init));
 475
 476   if (raw_constructor
 477       && CONSTRUCTOR_ELTS (init) != 0
 478       && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
 479     {
 480       element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
 481       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 482       if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
 483         element = TREE_OPERAND (element, 0);
 484       if (element == error_mark_node)
 485         return element;
 486     }
 487
 488   /* Initialization of an array of chars from a string constant
 489      optionally enclosed in braces.  */
 490
 491   if (code == ARRAY_TYPE)
 492     {
 493       tree typ1;
 494
 495       if (TREE_CODE (init) == TREE_LIST)
 496         {
 497           error ("initializing array with parameter list");
 498           return error_mark_node;
 499         }
 500
 501       typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 502       if (char_type_p (typ1)
 503           && ((init && TREE_CODE (init) == STRING_CST)
 504               || (element && TREE_CODE (element) == STRING_CST)))
 505         {
 506           tree string = element ? element : init;
 507
 508           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
 509                != char_type_node)
 510               && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
 511             {
 512               error ("char-array initialized from wide string");
 513               return error_mark_node;
 514             }
 515           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
 516                == char_type_node)
 517               && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
 518             {
 519               error ("int-array initialized from non-wide string");
 520               return error_mark_node;
 521             }
 522
 523           TREE_TYPE (string) = type;
 524           if (TYPE_DOMAIN (type) != 0
 525               && TREE_CONSTANT (TYPE_SIZE (type)))
 526             {
 527               register int size
 528                 = TREE_INT_CST_LOW (TYPE_SIZE (type));
 529               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 530               /* In C it is ok to subtract 1 from the length of the string
 531                  because it's ok to ignore the terminating null char that is
 532                  counted in the length of the constant, but in C++ this would
 533                  be invalid.  */
 534               if (size < TREE_STRING_LENGTH (string))
 535                 pedwarn ("initializer-string for array of chars is too long");
 536             }
 537           return string;
 538         }
 539     }
 540
 541   /* Handle scalar types, including conversions,
 542      and signature pointers and references.  */
 543
 544   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
 545       || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
 546       || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
 547       || TYPE_PTRMEMFUNC_P (type))
 548     {
 549       if (raw_constructor)
 550         {
 551           if (element == 0)
 552             {
 553               error ("initializer for scalar variable requires one element");
 554               return error_mark_node;
 555             }
 556           init = element;
 557         }
 558       while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
 559         {
 560           pedwarn ("braces around scalar initializer for `%T'", type);
 561           init = CONSTRUCTOR_ELTS (init);
 562           if (TREE_CHAIN (init))
 563             pedwarn ("ignoring extra initializers for `%T'", type);
 564           init = TREE_VALUE (init);
 565         }
 566
 567       return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
 568                                          "initialization", NULL_TREE, 0);
 569     }
 570
 571   /* Come here only for records and arrays (and unions with constructors).  */
 572
 573   if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
 574     {
 575       error ("variable-sized object of type `%T' may not be initialized",
 576                 type);
 577       return error_mark_node;
 578     }
 579
 580   if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
 581     {
 582       if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)
 583           && TREE_HAS_CONSTRUCTOR (init))
 584         {
 585           error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
 586                     type, init);
 587           return error_mark_node;
 588         }
 589       else if (raw_constructor)
 590         return process_init_constructor (type, init, (tree *)0);
 591       else if (can_convert_arg (type, TREE_TYPE (init), init)
 592                || TYPE_NON_AGGREGATE_CLASS (type))
 593         /* These are never initialized from multiple constructor elements.  */;
 594       else if (tail != 0)
 595         {
 596           *tail = old_tail_contents;
 597           return process_init_constructor (type, 0, tail);
 598         }
 599
 600       if (code != ARRAY_TYPE)
 601         {
 602           int flags = LOOKUP_NORMAL;
 603           /* Initialization from { } is copy-initialization.  */
 604           if (tail)
 605             flags |= LOOKUP_ONLYCONVERTING;
 606
 607           return convert_for_initialization (NULL_TREE, type, init, flags,
 608                                              "initialization", NULL_TREE, 0);
 609         }
 610     }
 611
 612   error ("invalid initializer");
 613   return error_mark_node;
 614 }
 615 \f
 616 /* Process a constructor for a variable of type TYPE.
 617    The constructor elements may be specified either with INIT or with ELTS,
 618    only one of which should be non-null.
 619
 620    If INIT is specified, it is a CONSTRUCTOR node which is specifically
 621    and solely for initializing this datum.
 622
 623    If ELTS is specified, it is the address of a variable containing
 624    a list of expressions.  We take as many elements as we need
 625    from the head of the list and update the list.
 626
 627    In the resulting constructor, TREE_CONSTANT is set if all elts are
 628    constant, and TREE_STATIC is set if, in addition, all elts are simple enough
 629    constants that the assembler and linker can compute them.  */
 630
 631 static tree
 632 process_init_constructor (type, init, elts)
 633      tree type, init, *elts;
 634 {
 635   register tree tail;
 636   /* List of the elements of the result constructor,
 637      in reverse order.  */
 638   register tree members = NULL;
 639   register tree next1;
 640   tree result;
 641   int allconstant = 1;
 642   int allsimple = 1;
 643   int erroneous = 0;
 644
 645   /* Make TAIL be the list of elements to use for the initialization,
 646      no matter how the data was given to us.  */
 647
 648   if (elts)
 649     {
 650       if (warn_missing_braces)
 651         warning ("aggregate has a partly bracketed initializer");
 652       tail = *elts;
 653     }
 654   else
 655     tail = CONSTRUCTOR_ELTS (init);
 656
 657   /* Gobble as many elements as needed, and make a constructor or initial value
 658      for each element of this aggregate.  Chain them together in result.
 659      If there are too few, use 0 for each scalar ultimate component.  */
 660
 661   if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
 662     {
 663       register long len;
 664       register int i;
 665
 666       if (TREE_CODE (type) == ARRAY_TYPE)
 667         {
 668           tree domain = TYPE_DOMAIN (type);
 669           if (domain)
 670             len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
 671                    - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
 672                    + 1);
 673           else
 674             len = -1;  /* Take as many as there are */
 675         }
 676       else
 677         {
 678           /* Vectors are like simple fixed-size arrays.  */
 679           len = TYPE_VECTOR_SUBPARTS (type);
 680         }
 681
 682       for (i = 0; len < 0 || i < len; i++)
 683         {
 684           if (tail)
 685             {
 686               if (TREE_PURPOSE (tail)
 687                   && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
 688                       || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
 689                 sorry ("non-trivial labeled initializers");
 690
 691               if (TREE_VALUE (tail) != 0)
 692                 {
 693                   tree tail1 = tail;
 694                   next1 = digest_init (TREE_TYPE (type),
 695                                        TREE_VALUE (tail), &tail1);
 696                   if (next1 == error_mark_node)
 697                     return next1;
 698                   my_friendly_assert
 699                     (same_type_ignoring_top_level_qualifiers_p
 700                      (TREE_TYPE (type), TREE_TYPE (next1)),
 701                      981123);
 702                   my_friendly_assert (tail1 == 0
 703                                       || TREE_CODE (tail1) == TREE_LIST, 319);
 704                   if (tail == tail1 && len < 0)
 705                     {
 706                       error ("non-empty initializer for array of empty elements");
 707                       /* Just ignore what we were supposed to use.  */
 708                       tail1 = NULL_TREE;
 709                     }
 710                   tail = tail1;
 711                 }
 712               else
 713                 {
 714                   next1 = error_mark_node;
 715                   tail = TREE_CHAIN (tail);
 716                 }
 717             }
 718           else if (len < 0)
 719             /* We're done.  */
 720             break;
 721           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
 722             {
 723               /* If this type needs constructors run for
 724                  default-initialization, we can't rely on the backend to do it
 725                  for us, so build up TARGET_EXPRs.  If the type in question is
 726                  a class, just build one up; if it's an array, recurse.  */
 727
 728               if (IS_AGGR_TYPE (TREE_TYPE (type)))
 729                 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
 730               else
 731                 next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, NULL_TREE);
 732               next1 = digest_init (TREE_TYPE (type), next1, 0);
 733             }
 734           else if (! zero_init_p (TREE_TYPE (type)))
 735             next1 = build_zero_init (TREE_TYPE (type),
 736                                      /*nelts=*/NULL_TREE,
 737                                      /*static_storage_p=*/false);
 738           else
 739             /* The default zero-initialization is fine for us; don't
 740                add anything to the CONSTRUCTOR.  */
 741             break;
 742
 743           if (next1 == error_mark_node)
 744             erroneous = 1;
 745           else if (!TREE_CONSTANT (next1))
 746             allconstant = 0;
 747           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 748             allsimple = 0;
 749           members = tree_cons (size_int (i), next1, members);
 750         }
 751     }
 752   else if (TREE_CODE (type) == RECORD_TYPE)
 753     {
 754       register tree field;
 755
 756       if (tail)
 757         {
 758           if (TYPE_USES_VIRTUAL_BASECLASSES (type))
 759             {
 760               sorry ("initializer list for object of class with virtual base classes");
 761               return error_mark_node;
 762             }
 763
 764           if (TYPE_BINFO_BASETYPES (type))
 765             {
 766               sorry ("initializer list for object of class with base classes");
 767               return error_mark_node;
 768             }
 769
 770           if (TYPE_POLYMORPHIC_P (type))
 771             {
 772               sorry ("initializer list for object using virtual functions");
 773               return error_mark_node;
 774             }
 775         }
 776
 777       for (field = TYPE_FIELDS (type); field;
 778            field = TREE_CHAIN (field))
 779         {
 780           if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
 781             {
 782               members = tree_cons (field, integer_zero_node, members);
 783               continue;
 784             }
 785
 786           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 787             continue;
 788
 789           if (tail)
 790             {
 791               if (TREE_PURPOSE (tail)
 792                   && TREE_PURPOSE (tail) != field
 793                   && TREE_PURPOSE (tail) != DECL_NAME (field))
 794                 sorry ("non-trivial labeled initializers");
 795
 796               if (TREE_VALUE (tail) != 0)
 797                 {
 798                   tree tail1 = tail;
 799
 800                   next1 = digest_init (TREE_TYPE (field),
 801                                        TREE_VALUE (tail), &tail1);
 802                   my_friendly_assert (tail1 == 0
 803                                       || TREE_CODE (tail1) == TREE_LIST, 320);
 804                   tail = tail1;
 805                 }
 806               else
 807                 {
 808                   next1 = error_mark_node;
 809                   tail = TREE_CHAIN (tail);
 810                 }
 811             }
 812           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
 813             {
 814               /* If this type needs constructors run for
 815                  default-initialization, we can't rely on the backend to do it
 816                  for us, so build up TARGET_EXPRs.  If the type in question is
 817                  a class, just build one up; if it's an array, recurse.  */
 818
 819               if (IS_AGGR_TYPE (TREE_TYPE (field)))
 820                 next1 = build_functional_cast (TREE_TYPE (field),
 821                                                NULL_TREE);
 822               else
 823                 {
 824                   next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE,
 825                                  NULL_TREE);
 826                   if (init)
 827                     TREE_HAS_CONSTRUCTOR (next1)
 828                        = TREE_HAS_CONSTRUCTOR (init);
 829                 }
 830               next1 = digest_init (TREE_TYPE (field), next1, 0);
 831
 832               /* Warn when some struct elements are implicitly initialized.  */
 833               if (extra_warnings
 834                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 835                 warning ("missing initializer for member `%D'", field);
 836             }
 837           else
 838             {
 839               if (TREE_READONLY (field))
 840                 error ("uninitialized const member `%D'", field);
 841               else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
 842                 error ("member `%D' with uninitialized const fields",
 843                           field);
 844               else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 845                 error ("member `%D' is uninitialized reference", field);
 846
 847               /* Warn when some struct elements are implicitly initialized
 848                  to zero.  */
 849               if (extra_warnings
 850                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 851                 warning ("missing initializer for member `%D'", field);
 852
 853               if (! zero_init_p (TREE_TYPE (field)))
 854                 next1 = build_zero_init (TREE_TYPE (field),
 855                                          /*nelts=*/NULL_TREE,
 856                                          /*static_storage_p=*/false);
 857               else
 858                 /* The default zero-initialization is fine for us; don't
 859                    add anything to the CONSTRUCTOR.  */
 860                 continue;
 861             }
 862
 863           if (next1 == error_mark_node)
 864             erroneous = 1;
 865           else if (!TREE_CONSTANT (next1))
 866             allconstant = 0;
 867           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 868             allsimple = 0;
 869           members = tree_cons (field, next1, members);
 870         }
 871     }
 872   else if (TREE_CODE (type) == UNION_TYPE
 873            /* If the initializer was empty, use default zero initialization.  */
 874            && tail)
 875     {
 876       register tree field = TYPE_FIELDS (type);
 877
 878       /* Find the first named field.  ANSI decided in September 1990
 879          that only named fields count here.  */
 880       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
 881         field = TREE_CHAIN (field);
 882
 883       /* If this element specifies a field, initialize via that field.  */
 884       if (TREE_PURPOSE (tail) != NULL_TREE)
 885         {
 886           int win = 0;
 887
 888           if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
 889             /* Handle the case of a call by build_c_cast.  */
 890             field = TREE_PURPOSE (tail), win = 1;
 891           else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
 892             error ("index value instead of field name in union initializer");
 893           else
 894             {
 895               tree temp;
 896               for (temp = TYPE_FIELDS (type);
 897                    temp;
 898                    temp = TREE_CHAIN (temp))
 899                 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
 900                   break;
 901               if (temp)
 902                 field = temp, win = 1;
 903               else
 904                 error ("no field `%D' in union being initialized",
 905                           TREE_PURPOSE (tail));
 906             }
 907           if (!win)
 908             TREE_VALUE (tail) = error_mark_node;
 909         }
 910       else if (field == 0)
 911         {
 912           error ("union `%T' with no named members cannot be initialized",
 913                     type);
 914           TREE_VALUE (tail) = error_mark_node;
 915         }
 916
 917       if (TREE_VALUE (tail) != 0)
 918         {
 919           tree tail1 = tail;
 920
 921           next1 = digest_init (TREE_TYPE (field),
 922                                TREE_VALUE (tail), &tail1);
 923           if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
 924             abort ();
 925           tail = tail1;
 926         }
 927       else
 928         {
 929           next1 = error_mark_node;
 930           tail = TREE_CHAIN (tail);
 931         }
 932
 933       if (next1 == error_mark_node)
 934         erroneous = 1;
 935       else if (!TREE_CONSTANT (next1))
 936         allconstant = 0;
 937       else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
 938         allsimple = 0;
 939       members = tree_cons (field, next1, members);
 940     }
 941
 942   /* If arguments were specified as a list, just remove the ones we used.  */
 943   if (elts)
 944     *elts = tail;
 945   /* If arguments were specified as a constructor,
 946      complain unless we used all the elements of the constructor.  */
 947   else if (tail)
 948     pedwarn ("excess elements in aggregate initializer");
 949
 950   if (erroneous)
 951     return error_mark_node;
 952
 953   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
 954   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
 955     complete_array_type (type, result, /*do_default=*/0);
 956   if (init)
 957     TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
 958   if (allconstant) TREE_CONSTANT (result) = 1;
 959   if (allconstant && allsimple) TREE_STATIC (result) = 1;
 960   return result;
 961 }
 962 \f
 963 /* Given a structure or union value DATUM, construct and return
 964    the structure or union component which results from narrowing
 965    that value to the base specified in BASETYPE.  For example, given the
 966    hierarchy
 967
 968    class L { int ii; };
 969    class A : L { ... };
 970    class B : L { ... };
 971    class C : A, B { ... };
 972
 973    and the declaration
 974
 975    C x;
 976
 977    then the expression
 978
 979    x.A::ii refers to the ii member of the L part of
 980    the A part of the C object named by X.  In this case,
 981    DATUM would be x, and BASETYPE would be A.
 982
 983    I used to think that this was nonconformant, that the standard specified
 984    that first we look up ii in A, then convert x to an L& and pull out the
 985    ii part.  But in fact, it does say that we convert x to an A&; A here
 986    is known as the "naming class".  (jason 2000-12-19)
 987
 988    BINFO_P points to a variable initialized either to NULL_TREE or to the
 989    binfo for the specific base subobject we want to convert to.  */
 990
 991 tree
 992 build_scoped_ref (datum, basetype, binfo_p)
 993      tree datum;
 994      tree basetype;
 995      tree *binfo_p;
 996 {
 997   tree binfo;
 998
 999   if (datum == error_mark_node)
1000     return error_mark_node;
1001   if (*binfo_p)
1002     binfo = *binfo_p;
1003   else
1004     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1005
1006   if (!binfo || binfo == error_mark_node)
1007     {
1008       *binfo_p = NULL_TREE;
1009       if (!binfo)
1010         error_not_base_type (basetype, TREE_TYPE (datum));
1011       return error_mark_node;
1012     }
1013
1014   *binfo_p = binfo;
1015   return build_base_path (PLUS_EXPR, datum, binfo, 1);
1016 }
1017
1018 /* Build a reference to an object specified by the C++ `->' operator.
1019    Usually this just involves dereferencing the object, but if the
1020    `->' operator is overloaded, then such overloads must be
1021    performed until an object which does not have the `->' operator
1022    overloaded is found.  An error is reported when circular pointer
1023    delegation is detected.  */
1024
1025 tree
1026 build_x_arrow (datum)
1027      tree datum;
1028 {
1029   tree types_memoized = NULL_TREE;
1030   register tree rval = datum;
1031   tree type = TREE_TYPE (rval);
1032   tree last_rval = NULL_TREE;
1033
1034   if (type == error_mark_node)
1035     return error_mark_node;
1036
1037   if (processing_template_decl)
1038     return build_min_nt (ARROW_EXPR, rval);
1039
1040   if (TREE_CODE (rval) == OFFSET_REF)
1041     {
1042       rval = resolve_offset_ref (datum);
1043       type = TREE_TYPE (rval);
1044     }
1045
1046   if (TREE_CODE (type) == REFERENCE_TYPE)
1047     {
1048       rval = convert_from_reference (rval);
1049       type = TREE_TYPE (rval);
1050     }
1051
1052   if (IS_AGGR_TYPE (type))
1053     {
1054       while ((rval = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, rval,
1055                                    NULL_TREE, NULL_TREE)))
1056         {
1057           if (rval == error_mark_node)
1058             return error_mark_node;
1059
1060           if (value_member (TREE_TYPE (rval), types_memoized))
1061             {
1062               error ("circular pointer delegation detected");
1063               return error_mark_node;
1064             }
1065           else
1066             {
1067               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1068                                           types_memoized);
1069             }
1070           last_rval = rval;
1071         }
1072
1073       if (last_rval == NULL_TREE)
1074         {
1075           error ("base operand of `->' has non-pointer type `%T'", type);
1076           return error_mark_node;
1077         }
1078
1079       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1080         last_rval = convert_from_reference (last_rval);
1081     }
1082   else
1083     last_rval = default_conversion (rval);
1084
1085   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1086     return build_indirect_ref (last_rval, NULL);
1087
1088   if (types_memoized)
1089     error ("result of `operator->()' yields non-pointer result");
1090   else
1091     error ("base operand of `->' is not a pointer");
1092   return error_mark_node;
1093 }
1094
1095 /* Make an expression to refer to the COMPONENT field of
1096    structure or union value DATUM.  COMPONENT is an arbitrary
1097    expression.  DATUM has not already been checked out to be of
1098    aggregate type.
1099
1100    For C++, COMPONENT may be a TREE_LIST.  This happens when we must
1101    return an object of member type to a method of the current class,
1102    but there is not yet enough typing information to know which one.
1103    As a special case, if there is only one method by that name,
1104    it is returned.  Otherwise we return an expression which other
1105    routines will have to know how to deal with later.  */
1106
1107 tree
1108 build_m_component_ref (datum, component)
1109      tree datum, component;
1110 {
1111   tree type;
1112   tree objtype;
1113   tree field_type;
1114   int type_quals;
1115   tree binfo;
1116
1117   if (processing_template_decl)
1118     return build_min_nt (DOTSTAR_EXPR, datum, component);
1119
1120   datum = decay_conversion (datum);
1121
1122   if (datum == error_mark_node || component == error_mark_node)
1123     return error_mark_node;
1124
1125   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1126
1127   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1128     {
1129       type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1130       field_type = type;
1131     }
1132   else if (TYPE_PTRMEM_P (TREE_TYPE (component)))
1133     {
1134       type = TREE_TYPE (TREE_TYPE (component));
1135       field_type = TREE_TYPE (type);
1136
1137       /* Compute the type of the field, as described in [expr.ref].  */
1138       type_quals = TYPE_UNQUALIFIED;
1139       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1140         /* The standard says that the type of the result should be the
1141            type referred to by the reference.  But for now, at least,
1142            we do the conversion from reference type later.  */
1143         ;
1144       else
1145         {
1146           type_quals = (cp_type_quals (field_type)
1147                         | cp_type_quals (TREE_TYPE (datum)));
1148
1149           /* There's no such thing as a mutable pointer-to-member, so
1150              things are not as complex as they are for references to
1151              non-static data members.  */
1152           field_type = cp_build_qualified_type (field_type, type_quals);
1153         }
1154     }
1155   else
1156     {
1157       error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1158                 component, TREE_TYPE (component));
1159       return error_mark_node;
1160     }
1161
1162   if (! IS_AGGR_TYPE (objtype))
1163     {
1164       error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1165                 component, datum, objtype);
1166       return error_mark_node;
1167     }
1168
1169   binfo = lookup_base (objtype, TYPE_METHOD_BASETYPE (type),
1170                        ba_check, NULL);
1171   if (!binfo)
1172     {
1173       error ("member type `%T::' incompatible with object type `%T'",
1174                 TYPE_METHOD_BASETYPE (type), objtype);
1175       return error_mark_node;
1176     }
1177   else if (binfo == error_mark_node)
1178     return error_mark_node;
1179
1180   component = build (OFFSET_REF, field_type, datum, component);
1181   if (TREE_CODE (type) == OFFSET_TYPE)
1182     component = resolve_offset_ref (component);
1183   return component;
1184 }
1185
1186 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1187
1188 tree
1189 build_functional_cast (exp, parms)
1190      tree exp;
1191      tree parms;
1192 {
1193   /* This is either a call to a constructor,
1194      or a C cast in C++'s `functional' notation.  */
1195   tree type;
1196
1197   if (exp == error_mark_node || parms == error_mark_node)
1198     return error_mark_node;
1199
1200   if (TREE_CODE (exp) == IDENTIFIER_NODE)
1201     {
1202       if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1203         /* Either an enum or an aggregate type.  */
1204         type = IDENTIFIER_TYPE_VALUE (exp);
1205       else
1206         {
1207           type = lookup_name (exp, 1);
1208           if (!type || TREE_CODE (type) != TYPE_DECL)
1209             {
1210               error ("`%T' fails to be a typedef or built-in type", exp);
1211               return error_mark_node;
1212             }
1213           type = TREE_TYPE (type);
1214         }
1215     }
1216   else if (TREE_CODE (exp) == TYPE_DECL)
1217     type = TREE_TYPE (exp);
1218   else
1219     type = exp;
1220
1221   if (processing_template_decl)
1222     return build_min (CAST_EXPR, type, parms);
1223
1224   if (! IS_AGGR_TYPE (type))
1225     {
1226       /* this must build a C cast */
1227       if (parms == NULL_TREE)
1228         parms = integer_zero_node;
1229       else
1230         {
1231           if (TREE_CHAIN (parms) != NULL_TREE)
1232             pedwarn ("initializer list being treated as compound expression");
1233           parms = build_compound_expr (parms);
1234         }
1235
1236       return build_c_cast (type, parms);
1237     }
1238
1239   /* Prepare to evaluate as a call to a constructor.  If this expression
1240      is actually used, for example,
1241
1242      return X (arg1, arg2, ...);
1243
1244      then the slot being initialized will be filled in.  */
1245
1246   if (!complete_type_or_else (type, NULL_TREE))
1247     return error_mark_node;
1248   if (abstract_virtuals_error (NULL_TREE, type))
1249     return error_mark_node;
1250
1251   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1252     return build_c_cast (type, TREE_VALUE (parms));
1253
1254   /* We need to zero-initialize POD types.  Let's do that for everything
1255      that doesn't need a constructor.  */
1256   if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1257       && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1258     {
1259       exp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
1260       return get_target_expr (exp);
1261     }
1262
1263   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1264                                    TYPE_BINFO (type), LOOKUP_NORMAL);
1265
1266   if (exp == error_mark_node)
1267     return error_mark_node;
1268
1269   return build_cplus_new (type, exp);
1270 }
1271 \f
1272
1273 /* Add new exception specifier SPEC, to the LIST we currently have.
1274    If it's already in LIST then do nothing.
1275    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1276    know what we're doing.  */
1277
1278 tree
1279 add_exception_specifier (list, spec, complain)
1280      tree list, spec;
1281      int complain;
1282 {
1283   int ok;
1284   tree core = spec;
1285   int is_ptr;
1286   int diag_type = -1; /* none */
1287
1288   if (spec == error_mark_node)
1289     return list;
1290
1291   my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1292
1293   /* [except.spec] 1, type in an exception specifier shall not be
1294      incomplete, or pointer or ref to incomplete other than pointer
1295      to cv void.  */
1296   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1297   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1298     core = TREE_TYPE (core);
1299   if (complain < 0)
1300     ok = 1;
1301   else if (VOID_TYPE_P (core))
1302     ok = is_ptr;
1303   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1304     ok = 1;
1305   else if (processing_template_decl)
1306     ok = 1;
1307   else
1308     {
1309       ok = 1;
1310       /* 15.4/1 says that types in an exception specifier must be complete,
1311          but it seems more reasonable to only require this on definitions
1312          and calls.  So just give a pedwarn at this point; we will give an
1313          error later if we hit one of those two cases.  */
1314       if (!COMPLETE_TYPE_P (complete_type (core)))
1315         diag_type = 2; /* pedwarn */
1316     }
1317
1318   if (ok)
1319     {
1320       tree probe;
1321
1322       for (probe = list; probe; probe = TREE_CHAIN (probe))
1323         if (same_type_p (TREE_VALUE (probe), spec))
1324           break;
1325       if (!probe)
1326         list = tree_cons (NULL_TREE, spec, list);
1327     }
1328   else
1329     diag_type = 0; /* error */
1330
1331   if (diag_type >= 0 && complain)
1332     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1333
1334   return list;
1335 }
1336
1337 /* Combine the two exceptions specifier lists LIST and ADD, and return
1338    their union.  */
1339
1340 tree
1341 merge_exception_specifiers (list, add)
1342      tree list, add;
1343 {
1344   if (!list || !add)
1345     return NULL_TREE;
1346   else if (!TREE_VALUE (list))
1347     return add;
1348   else if (!TREE_VALUE (add))
1349     return list;
1350   else
1351     {
1352       tree orig_list = list;
1353
1354       for (; add; add = TREE_CHAIN (add))
1355         {
1356           tree spec = TREE_VALUE (add);
1357           tree probe;
1358
1359           for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1360             if (same_type_p (TREE_VALUE (probe), spec))
1361               break;
1362           if (!probe)
1363             {
1364               spec = build_tree_list (NULL_TREE, spec);
1365               TREE_CHAIN (spec) = list;
1366               list = spec;
1367             }
1368         }
1369     }
1370   return list;
1371 }
1372
1373 /* Subroutine of build_call.  Ensure that each of the types in the
1374    exception specification is complete.  Technically, 15.4/1 says that
1375    they need to be complete when we see a declaration of the function,
1376    but we should be able to get away with only requiring this when the
1377    function is defined or called.  See also add_exception_specifier.  */
1378
1379 void
1380 require_complete_eh_spec_types (fntype, decl)
1381      tree fntype, decl;
1382 {
1383   tree raises;
1384   /* Don't complain about calls to op new.  */
1385   if (decl && DECL_ARTIFICIAL (decl))
1386     return;
1387   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1388        raises = TREE_CHAIN (raises))
1389     {
1390       tree type = TREE_VALUE (raises);
1391       if (type && !COMPLETE_TYPE_P (type))
1392         {
1393           if (decl)
1394             error
1395               ("call to function `%D' which throws incomplete type `%#T'",
1396                decl, type);
1397           else
1398             error ("call to function which throws incomplete type `%#T'",
1399                    decl);
1400         }
1401     }
1402 }