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