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