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