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     return value;
 393
 394   /* Store the VALUE in DECL_INITIAL.  If we're building a
 395      statement-tree we will actually expand the initialization later
 396      when we output this function.  */
 397   DECL_INITIAL (decl) = value;
 398   return NULL_TREE;
 399 }
 400
 401 \f
 402 /* Digest the parser output INIT as an initializer for type TYPE.
 403    Return a C expression of type TYPE to represent the initial value.
 404
 405    If TAIL is nonzero, it points to a variable holding a list of elements
 406    of which INIT is the first.  We update the list stored there by
 407    removing from the head all the elements that we use.
 408    Normally this is only one; we use more than one element only if
 409    TYPE is an aggregate and INIT is not a constructor.  */
 410
 411 tree
 412 digest_init (type, init, tail)
 413      tree type, init, *tail;
 414 {
 415   enum tree_code code = TREE_CODE (type);
 416   tree element = NULL_TREE;
 417   tree old_tail_contents = NULL_TREE;
 418   /* Nonzero if INIT is a braced grouping.  */
 419   int raw_constructor;
 420
 421   /* By default, assume we use one element from a list.
 422      We correct this later in the sole case where it is not true.  */
 423
 424   if (tail)
 425     {
 426       old_tail_contents = *tail;
 427       *tail = TREE_CHAIN (*tail);
 428     }
 429
 430   if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
 431                                   && TREE_VALUE (init) == error_mark_node))
 432     return error_mark_node;
 433
 434   if (TREE_CODE (init) == ERROR_MARK)
 435     /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
 436        a template function. This gets substituted during instantiation.  */
 437     return init;
 438
 439   /* We must strip the outermost array type when completing the type,
 440      because the its bounds might be incomplete at the moment.  */
 441   if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
 442                               ? TREE_TYPE (type) : type, NULL_TREE))
 443     return error_mark_node;
 444
 445   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 446   if (TREE_CODE (init) == NON_LVALUE_EXPR)
 447     init = TREE_OPERAND (init, 0);
 448
 449   raw_constructor = (TREE_CODE (init) == CONSTRUCTOR
 450                      && TREE_HAS_CONSTRUCTOR (init));
 451
 452   if (raw_constructor
 453       && CONSTRUCTOR_ELTS (init) != 0
 454       && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
 455     {
 456       element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
 457       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 458       if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
 459         element = TREE_OPERAND (element, 0);
 460       if (element == error_mark_node)
 461         return element;
 462     }
 463
 464   /* Initialization of an array of chars from a string constant
 465      optionally enclosed in braces.  */
 466
 467   if (code == ARRAY_TYPE)
 468     {
 469       tree typ1;
 470
 471       if (TREE_CODE (init) == TREE_LIST)
 472         {
 473           error ("initializing array with parameter list");
 474           return error_mark_node;
 475         }
 476
 477       typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 478       if (char_type_p (typ1)
 479           && ((init && TREE_CODE (init) == STRING_CST)
 480               || (element && TREE_CODE (element) == STRING_CST)))
 481         {
 482           tree string = element ? element : init;
 483
 484           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
 485                != char_type_node)
 486               && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
 487             {
 488               error ("char-array initialized from wide string");
 489               return error_mark_node;
 490             }
 491           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
 492                == char_type_node)
 493               && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
 494             {
 495               error ("int-array initialized from non-wide string");
 496               return error_mark_node;
 497             }
 498
 499           TREE_TYPE (string) = type;
 500           if (TYPE_DOMAIN (type) != 0
 501               && TREE_CONSTANT (TYPE_SIZE (type)))
 502             {
 503               register int size
 504                 = TREE_INT_CST_LOW (TYPE_SIZE (type));
 505               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 506               /* In C it is ok to subtract 1 from the length of the string
 507                  because it's ok to ignore the terminating null char that is
 508                  counted in the length of the constant, but in C++ this would
 509                  be invalid.  */
 510               if (size < TREE_STRING_LENGTH (string))
 511                 pedwarn ("initializer-string for array of chars is too long");
 512             }
 513           return string;
 514         }
 515     }
 516
 517   /* Handle scalar types, including conversions,
 518      and signature pointers and references.  */
 519
 520   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
 521       || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
 522       || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
 523       || TYPE_PTRMEMFUNC_P (type))
 524     {
 525       if (raw_constructor)
 526         {
 527           if (element == 0)
 528             {
 529               error ("initializer for scalar variable requires one element");
 530               return error_mark_node;
 531             }
 532           init = element;
 533         }
 534       while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
 535         {
 536           pedwarn ("braces around scalar initializer for `%T'", type);
 537           init = CONSTRUCTOR_ELTS (init);
 538           if (TREE_CHAIN (init))
 539             pedwarn ("ignoring extra initializers for `%T'", type);
 540           init = TREE_VALUE (init);
 541         }
 542
 543       return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
 544                                          "initialization", NULL_TREE, 0);
 545     }
 546
 547   /* Come here only for records and arrays (and unions with constructors).  */
 548
 549   if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
 550     {
 551       error ("variable-sized object of type `%T' may not be initialized",
 552                 type);
 553       return error_mark_node;
 554     }
 555
 556   if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
 557     {
 558       if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)
 559           && TREE_HAS_CONSTRUCTOR (init))
 560         {
 561           error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
 562                     type, init);
 563           return error_mark_node;
 564         }
 565       else if (raw_constructor)
 566         return process_init_constructor (type, init, (tree *)0);
 567       else if (can_convert_arg (type, TREE_TYPE (init), init)
 568                || TYPE_NON_AGGREGATE_CLASS (type))
 569         /* These are never initialized from multiple constructor elements.  */;
 570       else if (tail != 0)
 571         {
 572           *tail = old_tail_contents;
 573           return process_init_constructor (type, 0, tail);
 574         }
 575
 576       if (code != ARRAY_TYPE)
 577         {
 578           int flags = LOOKUP_NORMAL;
 579           /* Initialization from { } is copy-initialization.  */
 580           if (tail)
 581             flags |= LOOKUP_ONLYCONVERTING;
 582
 583           return convert_for_initialization (NULL_TREE, type, init, flags,
 584                                              "initialization", NULL_TREE, 0);
 585         }
 586     }
 587
 588   error ("invalid initializer");
 589   return error_mark_node;
 590 }
 591 \f
 592 /* Process a constructor for a variable of type TYPE.
 593    The constructor elements may be specified either with INIT or with ELTS,
 594    only one of which should be non-null.
 595
 596    If INIT is specified, it is a CONSTRUCTOR node which is specifically
 597    and solely for initializing this datum.
 598
 599    If ELTS is specified, it is the address of a variable containing
 600    a list of expressions.  We take as many elements as we need
 601    from the head of the list and update the list.
 602
 603    In the resulting constructor, TREE_CONSTANT is set if all elts are
 604    constant, and TREE_STATIC is set if, in addition, all elts are simple enough
 605    constants that the assembler and linker can compute them.  */
 606
 607 static tree
 608 process_init_constructor (type, init, elts)
 609      tree type, init, *elts;
 610 {
 611   register tree tail;
 612   /* List of the elements of the result constructor,
 613      in reverse order.  */
 614   register tree members = NULL;
 615   register tree next1;
 616   tree result;
 617   int allconstant = 1;
 618   int allsimple = 1;
 619   int erroneous = 0;
 620
 621   /* Make TAIL be the list of elements to use for the initialization,
 622      no matter how the data was given to us.  */
 623
 624   if (elts)
 625     {
 626       if (warn_missing_braces)
 627         warning ("aggregate has a partly bracketed initializer");
 628       tail = *elts;
 629     }
 630   else
 631     tail = CONSTRUCTOR_ELTS (init);
 632
 633   /* Gobble as many elements as needed, and make a constructor or initial value
 634      for each element of this aggregate.  Chain them together in result.
 635      If there are too few, use 0 for each scalar ultimate component.  */
 636
 637   if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
 638     {
 639       register long len;
 640       register int i;
 641
 642       if (TREE_CODE (type) == ARRAY_TYPE)
 643         {
 644           tree domain = TYPE_DOMAIN (type);
 645           if (domain)
 646             len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
 647                    - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
 648                    + 1);
 649           else
 650             len = -1;  /* Take as many as there are */
 651         }
 652       else
 653         {
 654           /* Vectors are like simple fixed-size arrays.  */
 655           len = TYPE_VECTOR_SUBPARTS (type);
 656         }
 657
 658       for (i = 0; len < 0 || i < len; i++)
 659         {
 660           if (tail)
 661             {
 662               if (TREE_PURPOSE (tail)
 663                   && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
 664                       || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
 665                 sorry ("non-trivial labeled initializers");
 666
 667               if (TREE_VALUE (tail) != 0)
 668                 {
 669                   tree tail1 = tail;
 670                   next1 = digest_init (TREE_TYPE (type),
 671                                        TREE_VALUE (tail), &tail1);
 672                   if (next1 == error_mark_node)
 673                     return next1;
 674                   my_friendly_assert
 675                     (same_type_ignoring_top_level_qualifiers_p
 676                      (TREE_TYPE (type), TREE_TYPE (next1)),
 677                      981123);
 678                   my_friendly_assert (tail1 == 0
 679                                       || TREE_CODE (tail1) == TREE_LIST, 319);
 680                   if (tail == tail1 && len < 0)
 681                     {
 682                       error ("non-empty initializer for array of empty elements");
 683                       /* Just ignore what we were supposed to use.  */
 684                       tail1 = NULL_TREE;
 685                     }
 686                   tail = tail1;
 687                 }
 688               else
 689                 {
 690                   next1 = error_mark_node;
 691                   tail = TREE_CHAIN (tail);
 692                 }
 693             }
 694           else if (len < 0)
 695             /* We're done.  */
 696             break;
 697           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
 698             {
 699               /* If this type needs constructors run for
 700                  default-initialization, we can't rely on the backend to do it
 701                  for us, so build up TARGET_EXPRs.  If the type in question is
 702                  a class, just build one up; if it's an array, recurse.  */
 703
 704               if (IS_AGGR_TYPE (TREE_TYPE (type)))
 705                 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
 706               else
 707                 next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, NULL_TREE);
 708               next1 = digest_init (TREE_TYPE (type), next1, 0);
 709             }
 710           else if (! zero_init_p (TREE_TYPE (type)))
 711             next1 = build_zero_init (TREE_TYPE (type),
 712                                      /*nelts=*/NULL_TREE,
 713                                      /*static_storage_p=*/false);
 714           else
 715             /* The default zero-initialization is fine for us; don't
 716                add anything to the CONSTRUCTOR.  */
 717             break;
 718
 719           if (next1 == error_mark_node)
 720             erroneous = 1;
 721           else if (!TREE_CONSTANT (next1))
 722             allconstant = 0;
 723           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 724             allsimple = 0;
 725           members = tree_cons (size_int (i), next1, members);
 726         }
 727     }
 728   else if (TREE_CODE (type) == RECORD_TYPE)
 729     {
 730       register tree field;
 731
 732       if (tail)
 733         {
 734           if (TYPE_USES_VIRTUAL_BASECLASSES (type))
 735             {
 736               sorry ("initializer list for object of class with virtual base classes");
 737               return error_mark_node;
 738             }
 739
 740           if (TYPE_BINFO_BASETYPES (type))
 741             {
 742               sorry ("initializer list for object of class with base classes");
 743               return error_mark_node;
 744             }
 745
 746           if (TYPE_POLYMORPHIC_P (type))
 747             {
 748               sorry ("initializer list for object using virtual functions");
 749               return error_mark_node;
 750             }
 751         }
 752
 753       for (field = TYPE_FIELDS (type); field;
 754            field = TREE_CHAIN (field))
 755         {
 756           if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
 757             {
 758               members = tree_cons (field, integer_zero_node, members);
 759               continue;
 760             }
 761
 762           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 763             continue;
 764
 765           if (tail)
 766             {
 767               if (TREE_PURPOSE (tail)
 768                   && TREE_PURPOSE (tail) != field
 769                   && TREE_PURPOSE (tail) != DECL_NAME (field))
 770                 sorry ("non-trivial labeled initializers");
 771
 772               if (TREE_VALUE (tail) != 0)
 773                 {
 774                   tree tail1 = tail;
 775
 776                   next1 = digest_init (TREE_TYPE (field),
 777                                        TREE_VALUE (tail), &tail1);
 778                   my_friendly_assert (tail1 == 0
 779                                       || TREE_CODE (tail1) == TREE_LIST, 320);
 780                   tail = tail1;
 781                 }
 782               else
 783                 {
 784                   next1 = error_mark_node;
 785                   tail = TREE_CHAIN (tail);
 786                 }
 787             }
 788           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
 789             {
 790               /* If this type needs constructors run for
 791                  default-initialization, we can't rely on the backend to do it
 792                  for us, so build up TARGET_EXPRs.  If the type in question is
 793                  a class, just build one up; if it's an array, recurse.  */
 794
 795               if (IS_AGGR_TYPE (TREE_TYPE (field)))
 796                 next1 = build_functional_cast (TREE_TYPE (field),
 797                                                NULL_TREE);
 798               else
 799                 {
 800                   next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE,
 801                                  NULL_TREE);
 802                   if (init)
 803                     TREE_HAS_CONSTRUCTOR (next1)
 804                        = TREE_HAS_CONSTRUCTOR (init);
 805                 }
 806               next1 = digest_init (TREE_TYPE (field), next1, 0);
 807
 808               /* Warn when some struct elements are implicitly initialized.  */
 809               if (extra_warnings
 810                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 811                 warning ("missing initializer for member `%D'", field);
 812             }
 813           else
 814             {
 815               if (TREE_READONLY (field))
 816                 error ("uninitialized const member `%D'", field);
 817               else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
 818                 error ("member `%D' with uninitialized const fields",
 819                           field);
 820               else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 821                 error ("member `%D' is uninitialized reference", field);
 822
 823               /* Warn when some struct elements are implicitly initialized
 824                  to zero.  */
 825               if (extra_warnings
 826                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 827                 warning ("missing initializer for member `%D'", field);
 828
 829               if (! zero_init_p (TREE_TYPE (field)))
 830                 next1 = build_zero_init (TREE_TYPE (field),
 831                                          /*nelts=*/NULL_TREE,
 832                                          /*static_storage_p=*/false);
 833               else
 834                 /* The default zero-initialization is fine for us; don't
 835                    add anything to the CONSTRUCTOR.  */
 836                 continue;
 837             }
 838
 839           if (next1 == error_mark_node)
 840             erroneous = 1;
 841           else if (!TREE_CONSTANT (next1))
 842             allconstant = 0;
 843           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 844             allsimple = 0;
 845           members = tree_cons (field, next1, members);
 846         }
 847     }
 848   else if (TREE_CODE (type) == UNION_TYPE
 849            /* If the initializer was empty, use default zero initialization.  */
 850            && tail)
 851     {
 852       register tree field = TYPE_FIELDS (type);
 853
 854       /* Find the first named field.  ANSI decided in September 1990
 855          that only named fields count here.  */
 856       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
 857         field = TREE_CHAIN (field);
 858
 859       /* If this element specifies a field, initialize via that field.  */
 860       if (TREE_PURPOSE (tail) != NULL_TREE)
 861         {
 862           int win = 0;
 863
 864           if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
 865             /* Handle the case of a call by build_c_cast.  */
 866             field = TREE_PURPOSE (tail), win = 1;
 867           else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
 868             error ("index value instead of field name in union initializer");
 869           else
 870             {
 871               tree temp;
 872               for (temp = TYPE_FIELDS (type);
 873                    temp;
 874                    temp = TREE_CHAIN (temp))
 875                 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
 876                   break;
 877               if (temp)
 878                 field = temp, win = 1;
 879               else
 880                 error ("no field `%D' in union being initialized",
 881                           TREE_PURPOSE (tail));
 882             }
 883           if (!win)
 884             TREE_VALUE (tail) = error_mark_node;
 885         }
 886       else if (field == 0)
 887         {
 888           error ("union `%T' with no named members cannot be initialized",
 889                     type);
 890           TREE_VALUE (tail) = error_mark_node;
 891         }
 892
 893       if (TREE_VALUE (tail) != 0)
 894         {
 895           tree tail1 = tail;
 896
 897           next1 = digest_init (TREE_TYPE (field),
 898                                TREE_VALUE (tail), &tail1);
 899           if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
 900             abort ();
 901           tail = tail1;
 902         }
 903       else
 904         {
 905           next1 = error_mark_node;
 906           tail = TREE_CHAIN (tail);
 907         }
 908
 909       if (next1 == error_mark_node)
 910         erroneous = 1;
 911       else if (!TREE_CONSTANT (next1))
 912         allconstant = 0;
 913       else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
 914         allsimple = 0;
 915       members = tree_cons (field, next1, members);
 916     }
 917
 918   /* If arguments were specified as a list, just remove the ones we used.  */
 919   if (elts)
 920     *elts = tail;
 921   /* If arguments were specified as a constructor,
 922      complain unless we used all the elements of the constructor.  */
 923   else if (tail)
 924     pedwarn ("excess elements in aggregate initializer");
 925
 926   if (erroneous)
 927     return error_mark_node;
 928
 929   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
 930   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
 931     complete_array_type (type, result, /*do_default=*/0);
 932   if (init)
 933     TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
 934   if (allconstant) TREE_CONSTANT (result) = 1;
 935   if (allconstant && allsimple) TREE_STATIC (result) = 1;
 936   return result;
 937 }
 938 \f
 939 /* Given a structure or union value DATUM, construct and return
 940    the structure or union component which results from narrowing
 941    that value to the base specified in BASETYPE.  For example, given the
 942    hierarchy
 943
 944    class L { int ii; };
 945    class A : L { ... };
 946    class B : L { ... };
 947    class C : A, B { ... };
 948
 949    and the declaration
 950
 951    C x;
 952
 953    then the expression
 954
 955    x.A::ii refers to the ii member of the L part of
 956    the A part of the C object named by X.  In this case,
 957    DATUM would be x, and BASETYPE would be A.
 958
 959    I used to think that this was nonconformant, that the standard specified
 960    that first we look up ii in A, then convert x to an L& and pull out the
 961    ii part.  But in fact, it does say that we convert x to an A&; A here
 962    is known as the "naming class".  (jason 2000-12-19)
 963
 964    BINFO_P points to a variable initialized either to NULL_TREE or to the
 965    binfo for the specific base subobject we want to convert to.  */
 966
 967 tree
 968 build_scoped_ref (datum, basetype, binfo_p)
 969      tree datum;
 970      tree basetype;
 971      tree *binfo_p;
 972 {
 973   tree binfo;
 974
 975   if (datum == error_mark_node)
 976     return error_mark_node;
 977   if (*binfo_p)
 978     binfo = *binfo_p;
 979   else
 980     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
 981
 982   if (!binfo || binfo == error_mark_node)
 983     {
 984       *binfo_p = NULL_TREE;
 985       if (!binfo)
 986         error_not_base_type (basetype, TREE_TYPE (datum));
 987       return error_mark_node;
 988     }
 989
 990   *binfo_p = binfo;
 991   return build_base_path (PLUS_EXPR, datum, binfo, 1);
 992 }
 993
 994 /* Build a reference to an object specified by the C++ `->' operator.
 995    Usually this just involves dereferencing the object, but if the
 996    `->' operator is overloaded, then such overloads must be
 997    performed until an object which does not have the `->' operator
 998    overloaded is found.  An error is reported when circular pointer
 999    delegation is detected.  */
1000
1001 tree
1002 build_x_arrow (datum)
1003      tree datum;
1004 {
1005   tree types_memoized = NULL_TREE;
1006   register tree rval = datum;
1007   tree type = TREE_TYPE (rval);
1008   tree last_rval = NULL_TREE;
1009
1010   if (type == error_mark_node)
1011     return error_mark_node;
1012
1013   if (processing_template_decl)
1014     return build_min_nt (ARROW_EXPR, rval);
1015
1016   if (TREE_CODE (rval) == OFFSET_REF)
1017     {
1018       rval = resolve_offset_ref (datum);
1019       type = TREE_TYPE (rval);
1020     }
1021
1022   if (TREE_CODE (type) == REFERENCE_TYPE)
1023     {
1024       rval = convert_from_reference (rval);
1025       type = TREE_TYPE (rval);
1026     }
1027
1028   if (IS_AGGR_TYPE (type))
1029     {
1030       while ((rval = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, rval,
1031                                    NULL_TREE, NULL_TREE)))
1032         {
1033           if (rval == error_mark_node)
1034             return error_mark_node;
1035
1036           if (value_member (TREE_TYPE (rval), types_memoized))
1037             {
1038               error ("circular pointer delegation detected");
1039               return error_mark_node;
1040             }
1041           else
1042             {
1043               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1044                                           types_memoized);
1045             }
1046           last_rval = rval;
1047         }
1048
1049       if (last_rval == NULL_TREE)
1050         {
1051           error ("base operand of `->' has non-pointer type `%T'", type);
1052           return error_mark_node;
1053         }
1054
1055       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1056         last_rval = convert_from_reference (last_rval);
1057     }
1058   else
1059     last_rval = default_conversion (rval);
1060
1061   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1062     return build_indirect_ref (last_rval, NULL);
1063
1064   if (types_memoized)
1065     error ("result of `operator->()' yields non-pointer result");
1066   else
1067     error ("base operand of `->' is not a pointer");
1068   return error_mark_node;
1069 }
1070
1071 /* Make an expression to refer to the COMPONENT field of
1072    structure or union value DATUM.  COMPONENT is an arbitrary
1073    expression.  DATUM has not already been checked out to be of
1074    aggregate type.
1075
1076    For C++, COMPONENT may be a TREE_LIST.  This happens when we must
1077    return an object of member type to a method of the current class,
1078    but there is not yet enough typing information to know which one.
1079    As a special case, if there is only one method by that name,
1080    it is returned.  Otherwise we return an expression which other
1081    routines will have to know how to deal with later.  */
1082
1083 tree
1084 build_m_component_ref (datum, component)
1085      tree datum, component;
1086 {
1087   tree type;
1088   tree objtype;
1089   tree field_type;
1090   int type_quals;
1091   tree binfo;
1092
1093   if (processing_template_decl)
1094     return build_min_nt (DOTSTAR_EXPR, datum, component);
1095
1096   datum = decay_conversion (datum);
1097
1098   if (datum == error_mark_node || component == error_mark_node)
1099     return error_mark_node;
1100
1101   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1102
1103   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1104     {
1105       type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1106       field_type = type;
1107     }
1108   else if (TYPE_PTRMEM_P (TREE_TYPE (component)))
1109     {
1110       type = TREE_TYPE (TREE_TYPE (component));
1111       field_type = TREE_TYPE (type);
1112
1113       /* Compute the type of the field, as described in [expr.ref].  */
1114       type_quals = TYPE_UNQUALIFIED;
1115       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1116         /* The standard says that the type of the result should be the
1117            type referred to by the reference.  But for now, at least,
1118            we do the conversion from reference type later.  */
1119         ;
1120       else
1121         {
1122           type_quals = (cp_type_quals (field_type)
1123                         | cp_type_quals (TREE_TYPE (datum)));
1124
1125           /* There's no such thing as a mutable pointer-to-member, so
1126              things are not as complex as they are for references to
1127              non-static data members.  */
1128           field_type = cp_build_qualified_type (field_type, type_quals);
1129         }
1130     }
1131   else
1132     {
1133       error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1134                 component, TREE_TYPE (component));
1135       return error_mark_node;
1136     }
1137
1138   if (! IS_AGGR_TYPE (objtype))
1139     {
1140       error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1141                 component, datum, objtype);
1142       return error_mark_node;
1143     }
1144
1145   binfo = lookup_base (objtype, TYPE_METHOD_BASETYPE (type),
1146                        ba_check, NULL);
1147   if (!binfo)
1148     {
1149       error ("member type `%T::' incompatible with object type `%T'",
1150                 TYPE_METHOD_BASETYPE (type), objtype);
1151       return error_mark_node;
1152     }
1153   else if (binfo == error_mark_node)
1154     return error_mark_node;
1155
1156   component = build (OFFSET_REF, field_type, datum, component);
1157   if (TREE_CODE (type) == OFFSET_TYPE)
1158     component = resolve_offset_ref (component);
1159   return component;
1160 }
1161
1162 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1163
1164 tree
1165 build_functional_cast (exp, parms)
1166      tree exp;
1167      tree parms;
1168 {
1169   /* This is either a call to a constructor,
1170      or a C cast in C++'s `functional' notation.  */
1171   tree type;
1172
1173   if (exp == error_mark_node || parms == error_mark_node)
1174     return error_mark_node;
1175
1176   if (TREE_CODE (exp) == IDENTIFIER_NODE)
1177     {
1178       if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1179         /* Either an enum or an aggregate type.  */
1180         type = IDENTIFIER_TYPE_VALUE (exp);
1181       else
1182         {
1183           type = lookup_name (exp, 1);
1184           if (!type || TREE_CODE (type) != TYPE_DECL)
1185             {
1186               error ("`%T' fails to be a typedef or built-in type", exp);
1187               return error_mark_node;
1188             }
1189           type = TREE_TYPE (type);
1190         }
1191     }
1192   else if (TREE_CODE (exp) == TYPE_DECL)
1193     type = TREE_TYPE (exp);
1194   else
1195     type = exp;
1196
1197   if (processing_template_decl)
1198     return build_min (CAST_EXPR, type, parms);
1199
1200   if (! IS_AGGR_TYPE (type))
1201     {
1202       /* this must build a C cast */
1203       if (parms == NULL_TREE)
1204         parms = integer_zero_node;
1205       else
1206         {
1207           if (TREE_CHAIN (parms) != NULL_TREE)
1208             pedwarn ("initializer list being treated as compound expression");
1209           parms = build_compound_expr (parms);
1210         }
1211
1212       return build_c_cast (type, parms);
1213     }
1214
1215   /* Prepare to evaluate as a call to a constructor.  If this expression
1216      is actually used, for example,
1217
1218      return X (arg1, arg2, ...);
1219
1220      then the slot being initialized will be filled in.  */
1221
1222   if (!complete_type_or_else (type, NULL_TREE))
1223     return error_mark_node;
1224   if (abstract_virtuals_error (NULL_TREE, type))
1225     return error_mark_node;
1226
1227   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1228     return build_c_cast (type, TREE_VALUE (parms));
1229
1230   /* We need to zero-initialize POD types.  Let's do that for everything
1231      that doesn't need a constructor.  */
1232   if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1233       && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1234     {
1235       exp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
1236       return get_target_expr (exp);
1237     }
1238
1239   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1240                                    TYPE_BINFO (type), LOOKUP_NORMAL);
1241
1242   if (exp == error_mark_node)
1243     return error_mark_node;
1244
1245   return build_cplus_new (type, exp);
1246 }
1247 \f
1248
1249 /* Add new exception specifier SPEC, to the LIST we currently have.
1250    If it's already in LIST then do nothing.
1251    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1252    know what we're doing.  */
1253
1254 tree
1255 add_exception_specifier (list, spec, complain)
1256      tree list, spec;
1257      int complain;
1258 {
1259   int ok;
1260   tree core = spec;
1261   int is_ptr;
1262   int diag_type = -1; /* none */
1263
1264   if (spec == error_mark_node)
1265     return list;
1266
1267   my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1268
1269   /* [except.spec] 1, type in an exception specifier shall not be
1270      incomplete, or pointer or ref to incomplete other than pointer
1271      to cv void.  */
1272   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1273   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1274     core = TREE_TYPE (core);
1275   if (complain < 0)
1276     ok = 1;
1277   else if (VOID_TYPE_P (core))
1278     ok = is_ptr;
1279   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1280     ok = 1;
1281   else if (processing_template_decl)
1282     ok = 1;
1283   else
1284     {
1285       ok = 1;
1286       /* 15.4/1 says that types in an exception specifier must be complete,
1287          but it seems more reasonable to only require this on definitions
1288          and calls.  So just give a pedwarn at this point; we will give an
1289          error later if we hit one of those two cases.  */
1290       if (!COMPLETE_TYPE_P (complete_type (core)))
1291         diag_type = 2; /* pedwarn */
1292     }
1293
1294   if (ok)
1295     {
1296       tree probe;
1297
1298       for (probe = list; probe; probe = TREE_CHAIN (probe))
1299         if (same_type_p (TREE_VALUE (probe), spec))
1300           break;
1301       if (!probe)
1302         list = tree_cons (NULL_TREE, spec, list);
1303     }
1304   else
1305     diag_type = 0; /* error */
1306
1307   if (diag_type >= 0 && complain)
1308     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1309
1310   return list;
1311 }
1312
1313 /* Combine the two exceptions specifier lists LIST and ADD, and return
1314    their union.  */
1315
1316 tree
1317 merge_exception_specifiers (list, add)
1318      tree list, add;
1319 {
1320   if (!list || !add)
1321     return NULL_TREE;
1322   else if (!TREE_VALUE (list))
1323     return add;
1324   else if (!TREE_VALUE (add))
1325     return list;
1326   else
1327     {
1328       tree orig_list = list;
1329
1330       for (; add; add = TREE_CHAIN (add))
1331         {
1332           tree spec = TREE_VALUE (add);
1333           tree probe;
1334
1335           for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1336             if (same_type_p (TREE_VALUE (probe), spec))
1337               break;
1338           if (!probe)
1339             {
1340               spec = build_tree_list (NULL_TREE, spec);
1341               TREE_CHAIN (spec) = list;
1342               list = spec;
1343             }
1344         }
1345     }
1346   return list;
1347 }
1348
1349 /* Subroutine of build_call.  Ensure that each of the types in the
1350    exception specification is complete.  Technically, 15.4/1 says that
1351    they need to be complete when we see a declaration of the function,
1352    but we should be able to get away with only requiring this when the
1353    function is defined or called.  See also add_exception_specifier.  */
1354
1355 void
1356 require_complete_eh_spec_types (fntype, decl)
1357      tree fntype, decl;
1358 {
1359   tree raises;
1360   /* Don't complain about calls to op new.  */
1361   if (decl && DECL_ARTIFICIAL (decl))
1362     return;
1363   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1364        raises = TREE_CHAIN (raises))
1365     {
1366       tree type = TREE_VALUE (raises);
1367       if (type && !COMPLETE_TYPE_P (type))
1368         {
1369           if (decl)
1370             error
1371               ("call to function `%D' which throws incomplete type `%#T'",
1372                decl, type);
1373           else
1374             error ("call to function which throws incomplete type `%#T'",
1375                    decl);
1376         }
1377     }
1378 }