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