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_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);
 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                   if (init)
 802                     TREE_HAS_CONSTRUCTOR (next1)
 803                        = TREE_HAS_CONSTRUCTOR (init);
 804                 }
 805               next1 = digest_init (TREE_TYPE (field), next1, 0);
 806
 807               /* Warn when some struct elements are implicitly initialized.  */
 808               if (extra_warnings
 809                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 810                 warning ("missing initializer for member `%D'", field);
 811             }
 812           else
 813             {
 814               if (TREE_READONLY (field))
 815                 error ("uninitialized const member `%D'", field);
 816               else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
 817                 error ("member `%D' with uninitialized const fields",
 818                           field);
 819               else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 820                 error ("member `%D' is uninitialized reference", field);
 821
 822               /* Warn when some struct elements are implicitly initialized
 823                  to zero.  */
 824               if (extra_warnings
 825                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 826                 warning ("missing initializer for member `%D'", field);
 827
 828               if (! zero_init_p (TREE_TYPE (field)))
 829                 next1 = build_zero_init (TREE_TYPE (field),
 830                                          /*nelts=*/NULL_TREE,
 831                                          /*static_storage_p=*/false);
 832               else
 833                 /* The default zero-initialization is fine for us; don't
 834                    add anything to the CONSTRUCTOR.  */
 835                 continue;
 836             }
 837
 838           if (next1 == error_mark_node)
 839             erroneous = 1;
 840           else if (!TREE_CONSTANT (next1))
 841             allconstant = 0;
 842           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 843             allsimple = 0;
 844           members = tree_cons (field, next1, members);
 845         }
 846     }
 847   else if (TREE_CODE (type) == UNION_TYPE
 848            /* If the initializer was empty, use default zero initialization.  */
 849            && tail)
 850     {
 851       register tree field = TYPE_FIELDS (type);
 852
 853       /* Find the first named field.  ANSI decided in September 1990
 854          that only named fields count here.  */
 855       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
 856         field = TREE_CHAIN (field);
 857
 858       /* If this element specifies a field, initialize via that field.  */
 859       if (TREE_PURPOSE (tail) != NULL_TREE)
 860         {
 861           int win = 0;
 862
 863           if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
 864             /* Handle the case of a call by build_c_cast.  */
 865             field = TREE_PURPOSE (tail), win = 1;
 866           else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
 867             error ("index value instead of field name in union initializer");
 868           else
 869             {
 870               tree temp;
 871               for (temp = TYPE_FIELDS (type);
 872                    temp;
 873                    temp = TREE_CHAIN (temp))
 874                 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
 875                   break;
 876               if (temp)
 877                 field = temp, win = 1;
 878               else
 879                 error ("no field `%D' in union being initialized",
 880                           TREE_PURPOSE (tail));
 881             }
 882           if (!win)
 883             TREE_VALUE (tail) = error_mark_node;
 884         }
 885       else if (field == 0)
 886         {
 887           error ("union `%T' with no named members cannot be initialized",
 888                     type);
 889           TREE_VALUE (tail) = error_mark_node;
 890         }
 891
 892       if (TREE_VALUE (tail) != 0)
 893         {
 894           tree tail1 = tail;
 895
 896           next1 = digest_init (TREE_TYPE (field),
 897                                TREE_VALUE (tail), &tail1);
 898           if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
 899             abort ();
 900           tail = tail1;
 901         }
 902       else
 903         {
 904           next1 = error_mark_node;
 905           tail = TREE_CHAIN (tail);
 906         }
 907
 908       if (next1 == error_mark_node)
 909         erroneous = 1;
 910       else if (!TREE_CONSTANT (next1))
 911         allconstant = 0;
 912       else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
 913         allsimple = 0;
 914       members = tree_cons (field, next1, members);
 915     }
 916
 917   /* If arguments were specified as a list, just remove the ones we used.  */
 918   if (elts)
 919     *elts = tail;
 920   /* If arguments were specified as a constructor,
 921      complain unless we used all the elements of the constructor.  */
 922   else if (tail)
 923     pedwarn ("excess elements in aggregate initializer");
 924
 925   if (erroneous)
 926     return error_mark_node;
 927
 928   result = build_constructor (type, nreverse (members));
 929   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
 930     complete_array_type (type, result, /*do_default=*/0);
 931   if (init)
 932     TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
 933   if (allconstant) TREE_CONSTANT (result) = 1;
 934   if (allconstant && allsimple) TREE_STATIC (result) = 1;
 935   return result;
 936 }
 937 \f
 938 /* Given a structure or union value DATUM, construct and return
 939    the structure or union component which results from narrowing
 940    that value to the base specified in BASETYPE.  For example, given the
 941    hierarchy
 942
 943    class L { int ii; };
 944    class A : L { ... };
 945    class B : L { ... };
 946    class C : A, B { ... };
 947
 948    and the declaration
 949
 950    C x;
 951
 952    then the expression
 953
 954    x.A::ii refers to the ii member of the L part of
 955    the A part of the C object named by X.  In this case,
 956    DATUM would be x, and BASETYPE would be A.
 957
 958    I used to think that this was nonconformant, that the standard specified
 959    that first we look up ii in A, then convert x to an L& and pull out the
 960    ii part.  But in fact, it does say that we convert x to an A&; A here
 961    is known as the "naming class".  (jason 2000-12-19)
 962
 963    BINFO_P points to a variable initialized either to NULL_TREE or to the
 964    binfo for the specific base subobject we want to convert to.  */
 965
 966 tree
 967 build_scoped_ref (datum, basetype, binfo_p)
 968      tree datum;
 969      tree basetype;
 970      tree *binfo_p;
 971 {
 972   tree binfo;
 973
 974   if (datum == error_mark_node)
 975     return error_mark_node;
 976   if (*binfo_p)
 977     binfo = *binfo_p;
 978   else
 979     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
 980
 981   if (!binfo || binfo == error_mark_node)
 982     {
 983       *binfo_p = NULL_TREE;
 984       if (!binfo)
 985         error_not_base_type (basetype, TREE_TYPE (datum));
 986       return error_mark_node;
 987     }
 988
 989   *binfo_p = binfo;
 990   return build_base_path (PLUS_EXPR, datum, binfo, 1);
 991 }
 992
 993 /* Build a reference to an object specified by the C++ `->' operator.
 994    Usually this just involves dereferencing the object, but if the
 995    `->' operator is overloaded, then such overloads must be
 996    performed until an object which does not have the `->' operator
 997    overloaded is found.  An error is reported when circular pointer
 998    delegation is detected.  */
 999
1000 tree
1001 build_x_arrow (datum)
1002      tree datum;
1003 {
1004   tree types_memoized = NULL_TREE;
1005   register tree rval = datum;
1006   tree type = TREE_TYPE (rval);
1007   tree last_rval = NULL_TREE;
1008
1009   if (type == error_mark_node)
1010     return error_mark_node;
1011
1012   if (processing_template_decl)
1013     return build_min_nt (ARROW_EXPR, rval);
1014
1015   if (TREE_CODE (rval) == OFFSET_REF)
1016     {
1017       rval = resolve_offset_ref (datum);
1018       type = TREE_TYPE (rval);
1019     }
1020
1021   if (TREE_CODE (type) == REFERENCE_TYPE)
1022     {
1023       rval = convert_from_reference (rval);
1024       type = TREE_TYPE (rval);
1025     }
1026
1027   if (IS_AGGR_TYPE (type))
1028     {
1029       while ((rval = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, rval,
1030                                    NULL_TREE, NULL_TREE)))
1031         {
1032           if (rval == error_mark_node)
1033             return error_mark_node;
1034
1035           if (value_member (TREE_TYPE (rval), types_memoized))
1036             {
1037               error ("circular pointer delegation detected");
1038               return error_mark_node;
1039             }
1040           else
1041             {
1042               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1043                                           types_memoized);
1044             }
1045           last_rval = rval;
1046         }
1047
1048       if (last_rval == NULL_TREE)
1049         {
1050           error ("base operand of `->' has non-pointer type `%T'", type);
1051           return error_mark_node;
1052         }
1053
1054       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1055         last_rval = convert_from_reference (last_rval);
1056     }
1057   else
1058     last_rval = default_conversion (rval);
1059
1060   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1061     return build_indirect_ref (last_rval, NULL);
1062
1063   if (types_memoized)
1064     error ("result of `operator->()' yields non-pointer result");
1065   else
1066     error ("base operand of `->' is not a pointer");
1067   return error_mark_node;
1068 }
1069
1070 /* Make an expression to refer to the COMPONENT field of
1071    structure or union value DATUM.  COMPONENT is an arbitrary
1072    expression.  DATUM has not already been checked out to be of
1073    aggregate type.
1074
1075    For C++, COMPONENT may be a TREE_LIST.  This happens when we must
1076    return an object of member type to a method of the current class,
1077    but there is not yet enough typing information to know which one.
1078    As a special case, if there is only one method by that name,
1079    it is returned.  Otherwise we return an expression which other
1080    routines will have to know how to deal with later.  */
1081
1082 tree
1083 build_m_component_ref (datum, component)
1084      tree datum, component;
1085 {
1086   tree type;
1087   tree objtype;
1088   tree field_type;
1089   int type_quals;
1090   tree binfo;
1091
1092   if (processing_template_decl)
1093     return build_min_nt (DOTSTAR_EXPR, datum, component);
1094
1095   datum = decay_conversion (datum);
1096
1097   if (datum == error_mark_node || component == error_mark_node)
1098     return error_mark_node;
1099
1100   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1101
1102   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1103     {
1104       type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1105       field_type = type;
1106     }
1107   else if (TYPE_PTRMEM_P (TREE_TYPE (component)))
1108     {
1109       type = TREE_TYPE (TREE_TYPE (component));
1110       field_type = TREE_TYPE (type);
1111
1112       /* Compute the type of the field, as described in [expr.ref].  */
1113       type_quals = TYPE_UNQUALIFIED;
1114       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1115         /* The standard says that the type of the result should be the
1116            type referred to by the reference.  But for now, at least,
1117            we do the conversion from reference type later.  */
1118         ;
1119       else
1120         {
1121           type_quals = (cp_type_quals (field_type)
1122                         | cp_type_quals (TREE_TYPE (datum)));
1123
1124           /* There's no such thing as a mutable pointer-to-member, so
1125              things are not as complex as they are for references to
1126              non-static data members.  */
1127           field_type = cp_build_qualified_type (field_type, type_quals);
1128         }
1129     }
1130   else
1131     {
1132       error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1133                 component, TREE_TYPE (component));
1134       return error_mark_node;
1135     }
1136
1137   if (! IS_AGGR_TYPE (objtype))
1138     {
1139       error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1140                 component, datum, objtype);
1141       return error_mark_node;
1142     }
1143
1144   binfo = lookup_base (objtype, TYPE_METHOD_BASETYPE (type),
1145                        ba_check, NULL);
1146   if (!binfo)
1147     {
1148       error ("member type `%T::' incompatible with object type `%T'",
1149                 TYPE_METHOD_BASETYPE (type), objtype);
1150       return error_mark_node;
1151     }
1152   else if (binfo == error_mark_node)
1153     return error_mark_node;
1154
1155   component = build (OFFSET_REF, field_type, datum, component);
1156   if (TREE_CODE (type) == OFFSET_TYPE)
1157     component = resolve_offset_ref (component);
1158   return component;
1159 }
1160
1161 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1162
1163 tree
1164 build_functional_cast (exp, parms)
1165      tree exp;
1166      tree parms;
1167 {
1168   /* This is either a call to a constructor,
1169      or a C cast in C++'s `functional' notation.  */
1170   tree type;
1171
1172   if (exp == error_mark_node || parms == error_mark_node)
1173     return error_mark_node;
1174
1175   if (TREE_CODE (exp) == IDENTIFIER_NODE)
1176     {
1177       if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1178         /* Either an enum or an aggregate type.  */
1179         type = IDENTIFIER_TYPE_VALUE (exp);
1180       else
1181         {
1182           type = lookup_name (exp, 1);
1183           if (!type || TREE_CODE (type) != TYPE_DECL)
1184             {
1185               error ("`%T' fails to be a typedef or built-in type", exp);
1186               return error_mark_node;
1187             }
1188           type = TREE_TYPE (type);
1189         }
1190     }
1191   else if (TREE_CODE (exp) == TYPE_DECL)
1192     type = TREE_TYPE (exp);
1193   else
1194     type = exp;
1195
1196   if (processing_template_decl)
1197     return build_min (CAST_EXPR, type, parms);
1198
1199   if (! IS_AGGR_TYPE (type))
1200     {
1201       /* this must build a C cast */
1202       if (parms == NULL_TREE)
1203         parms = integer_zero_node;
1204       else
1205         {
1206           if (TREE_CHAIN (parms) != NULL_TREE)
1207             pedwarn ("initializer list being treated as compound expression");
1208           parms = build_compound_expr (parms);
1209         }
1210
1211       return build_c_cast (type, parms);
1212     }
1213
1214   /* Prepare to evaluate as a call to a constructor.  If this expression
1215      is actually used, for example,
1216
1217      return X (arg1, arg2, ...);
1218
1219      then the slot being initialized will be filled in.  */
1220
1221   if (!complete_type_or_else (type, NULL_TREE))
1222     return error_mark_node;
1223   if (abstract_virtuals_error (NULL_TREE, type))
1224     return error_mark_node;
1225
1226   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1227     return build_c_cast (type, TREE_VALUE (parms));
1228
1229   /* We need to zero-initialize POD types.  Let's do that for everything
1230      that doesn't need a constructor.  */
1231   if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1232       && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1233     {
1234       exp = build_constructor (type, NULL_TREE);
1235       return get_target_expr (exp);
1236     }
1237
1238   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1239                                    TYPE_BINFO (type), LOOKUP_NORMAL);
1240
1241   if (exp == error_mark_node)
1242     return error_mark_node;
1243
1244   return build_cplus_new (type, exp);
1245 }
1246 \f
1247
1248 /* Add new exception specifier SPEC, to the LIST we currently have.
1249    If it's already in LIST then do nothing.
1250    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1251    know what we're doing.  */
1252
1253 tree
1254 add_exception_specifier (list, spec, complain)
1255      tree list, spec;
1256      int complain;
1257 {
1258   int ok;
1259   tree core = spec;
1260   int is_ptr;
1261   int diag_type = -1; /* none */
1262
1263   if (spec == error_mark_node)
1264     return list;
1265
1266   my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1267
1268   /* [except.spec] 1, type in an exception specifier shall not be
1269      incomplete, or pointer or ref to incomplete other than pointer
1270      to cv void.  */
1271   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1272   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1273     core = TREE_TYPE (core);
1274   if (complain < 0)
1275     ok = 1;
1276   else if (VOID_TYPE_P (core))
1277     ok = is_ptr;
1278   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1279     ok = 1;
1280   else if (processing_template_decl)
1281     ok = 1;
1282   else
1283     {
1284       ok = 1;
1285       /* 15.4/1 says that types in an exception specifier must be complete,
1286          but it seems more reasonable to only require this on definitions
1287          and calls.  So just give a pedwarn at this point; we will give an
1288          error later if we hit one of those two cases.  */
1289       if (!COMPLETE_TYPE_P (complete_type (core)))
1290         diag_type = 2; /* pedwarn */
1291     }
1292
1293   if (ok)
1294     {
1295       tree probe;
1296
1297       for (probe = list; probe; probe = TREE_CHAIN (probe))
1298         if (same_type_p (TREE_VALUE (probe), spec))
1299           break;
1300       if (!probe)
1301         list = tree_cons (NULL_TREE, spec, list);
1302     }
1303   else
1304     diag_type = 0; /* error */
1305
1306   if (diag_type >= 0 && complain)
1307     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1308
1309   return list;
1310 }
1311
1312 /* Combine the two exceptions specifier lists LIST and ADD, and return
1313    their union.  */
1314
1315 tree
1316 merge_exception_specifiers (list, add)
1317      tree list, add;
1318 {
1319   if (!list || !add)
1320     return NULL_TREE;
1321   else if (!TREE_VALUE (list))
1322     return add;
1323   else if (!TREE_VALUE (add))
1324     return list;
1325   else
1326     {
1327       tree orig_list = list;
1328
1329       for (; add; add = TREE_CHAIN (add))
1330         {
1331           tree spec = TREE_VALUE (add);
1332           tree probe;
1333
1334           for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1335             if (same_type_p (TREE_VALUE (probe), spec))
1336               break;
1337           if (!probe)
1338             {
1339               spec = build_tree_list (NULL_TREE, spec);
1340               TREE_CHAIN (spec) = list;
1341               list = spec;
1342             }
1343         }
1344     }
1345   return list;
1346 }
1347
1348 /* Subroutine of build_call.  Ensure that each of the types in the
1349    exception specification is complete.  Technically, 15.4/1 says that
1350    they need to be complete when we see a declaration of the function,
1351    but we should be able to get away with only requiring this when the
1352    function is defined or called.  See also add_exception_specifier.  */
1353
1354 void
1355 require_complete_eh_spec_types (fntype, decl)
1356      tree fntype, decl;
1357 {
1358   tree raises;
1359   /* Don't complain about calls to op new.  */
1360   if (decl && DECL_ARTIFICIAL (decl))
1361     return;
1362   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1363        raises = TREE_CHAIN (raises))
1364     {
1365       tree type = TREE_VALUE (raises);
1366       if (type && !COMPLETE_TYPE_P (type))
1367         {
1368           if (decl)
1369             error
1370               ("call to function `%D' which throws incomplete type `%#T'",
1371                decl, type);
1372           else
1373             error ("call to function which throws incomplete type `%#T'",
1374                    decl);
1375         }
1376     }
1377 }