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 || code == VECTOR_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 || 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)
 663     {
 664       tree domain = TYPE_DOMAIN (type);
 665       register long len;
 666       register int i;
 667
 668       if (domain)
 669         len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
 670                - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
 671                + 1);
 672       else
 673         len = -1;  /* Take as many as there are */
 674
 675       for (i = 0; len < 0 || i < len; i++)
 676         {
 677           if (tail)
 678             {
 679               if (TREE_PURPOSE (tail)
 680                   && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
 681                       || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
 682                 sorry ("non-trivial labeled initializers");
 683
 684               if (TREE_VALUE (tail) != 0)
 685                 {
 686                   tree tail1 = tail;
 687                   next1 = digest_init (TREE_TYPE (type),
 688                                        TREE_VALUE (tail), &tail1);
 689                   if (next1 == error_mark_node)
 690                     return next1;
 691                   my_friendly_assert
 692                     (same_type_ignoring_top_level_qualifiers_p
 693                      (TREE_TYPE (type), TREE_TYPE (next1)),
 694                      981123);
 695                   my_friendly_assert (tail1 == 0
 696                                       || TREE_CODE (tail1) == TREE_LIST, 319);
 697                   if (tail == tail1 && len < 0)
 698                     {
 699                       error ("non-empty initializer for array of empty elements");
 700                       /* Just ignore what we were supposed to use.  */
 701                       tail1 = NULL_TREE;
 702                     }
 703                   tail = tail1;
 704                 }
 705               else
 706                 {
 707                   next1 = error_mark_node;
 708                   tail = TREE_CHAIN (tail);
 709                 }
 710             }
 711           else if (len < 0)
 712             /* We're done.  */
 713             break;
 714           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
 715             {
 716               /* If this type needs constructors run for
 717                  default-initialization, we can't rely on the backend to do it
 718                  for us, so build up TARGET_EXPRs.  If the type in question is
 719                  a class, just build one up; if it's an array, recurse.  */
 720
 721               if (IS_AGGR_TYPE (TREE_TYPE (type)))
 722                 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
 723               else
 724                 next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, NULL_TREE);
 725               next1 = digest_init (TREE_TYPE (type), next1, 0);
 726             }
 727           else
 728             /* The default zero-initialization is fine for us; don't
 729                add anything to the CONSTRUCTOR.  */
 730             break;
 731
 732           if (next1 == error_mark_node)
 733             erroneous = 1;
 734           else if (!TREE_CONSTANT (next1))
 735             allconstant = 0;
 736           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 737             allsimple = 0;
 738           members = tree_cons (size_int (i), next1, members);
 739         }
 740     }
 741   else if (TREE_CODE (type) == RECORD_TYPE)
 742     {
 743       register tree field;
 744
 745       if (tail)
 746         {
 747           if (TYPE_USES_VIRTUAL_BASECLASSES (type))
 748             {
 749               sorry ("initializer list for object of class with virtual base classes");
 750               return error_mark_node;
 751             }
 752
 753           if (TYPE_BINFO_BASETYPES (type))
 754             {
 755               sorry ("initializer list for object of class with base classes");
 756               return error_mark_node;
 757             }
 758
 759           if (TYPE_POLYMORPHIC_P (type))
 760             {
 761               sorry ("initializer list for object using virtual functions");
 762               return error_mark_node;
 763             }
 764         }
 765
 766       for (field = TYPE_FIELDS (type); field;
 767            field = TREE_CHAIN (field))
 768         {
 769           if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
 770             {
 771               members = tree_cons (field, integer_zero_node, members);
 772               continue;
 773             }
 774
 775           if (TREE_CODE (field) != FIELD_DECL)
 776             continue;
 777
 778           if (tail)
 779             {
 780               if (TREE_PURPOSE (tail)
 781                   && TREE_PURPOSE (tail) != field
 782                   && TREE_PURPOSE (tail) != DECL_NAME (field))
 783                 sorry ("non-trivial labeled initializers");
 784
 785               if (TREE_VALUE (tail) != 0)
 786                 {
 787                   tree tail1 = tail;
 788
 789                   next1 = digest_init (TREE_TYPE (field),
 790                                        TREE_VALUE (tail), &tail1);
 791                   my_friendly_assert (tail1 == 0
 792                                       || TREE_CODE (tail1) == TREE_LIST, 320);
 793                   tail = tail1;
 794                 }
 795               else
 796                 {
 797                   next1 = error_mark_node;
 798                   tail = TREE_CHAIN (tail);
 799                 }
 800             }
 801           else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
 802             {
 803               /* If this type needs constructors run for
 804                  default-initialization, we can't rely on the backend to do it
 805                  for us, so build up TARGET_EXPRs.  If the type in question is
 806                  a class, just build one up; if it's an array, recurse.  */
 807
 808               if (IS_AGGR_TYPE (TREE_TYPE (field)))
 809                 next1 = build_functional_cast (TREE_TYPE (field),
 810                                                NULL_TREE);
 811               else
 812                 {
 813                   next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE,
 814                                  NULL_TREE);
 815                   if (init)
 816                     TREE_HAS_CONSTRUCTOR (next1)
 817                        = TREE_HAS_CONSTRUCTOR (init);
 818                 }
 819               next1 = digest_init (TREE_TYPE (field), next1, 0);
 820
 821               /* Warn when some struct elements are implicitly initialized.  */
 822               if (extra_warnings
 823                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 824                 warning ("missing initializer for member `%D'", field);
 825             }
 826           else
 827             {
 828               if (TREE_READONLY (field))
 829                 error ("uninitialized const member `%D'", field);
 830               else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
 831                        && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
 832                 error ("member `%D' with uninitialized const fields",
 833                           field);
 834               else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 835                 error ("member `%D' is uninitialized reference", field);
 836
 837               /* Warn when some struct elements are implicitly initialized
 838                  to zero.  */
 839               if (extra_warnings
 840                   && (!init || TREE_HAS_CONSTRUCTOR (init)))
 841                 warning ("missing initializer for member `%D'", field);
 842
 843               /* The default zero-initialization is fine for us; don't
 844                  add anything to the CONSTRUCTOR.  */
 845               continue;
 846             }
 847
 848           if (next1 == error_mark_node)
 849             erroneous = 1;
 850           else if (!TREE_CONSTANT (next1))
 851             allconstant = 0;
 852           else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 853             allsimple = 0;
 854           members = tree_cons (field, next1, members);
 855         }
 856     }
 857   else if (TREE_CODE (type) == UNION_TYPE
 858            /* If the initializer was empty, use default zero initialization.  */
 859            && tail)
 860     {
 861       register tree field = TYPE_FIELDS (type);
 862
 863       /* Find the first named field.  ANSI decided in September 1990
 864          that only named fields count here.  */
 865       while (field && (DECL_NAME (field) == 0
 866                        || TREE_CODE (field) != FIELD_DECL))
 867         field = TREE_CHAIN (field);
 868
 869       /* If this element specifies a field, initialize via that field.  */
 870       if (TREE_PURPOSE (tail) != NULL_TREE)
 871         {
 872           int win = 0;
 873
 874           if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
 875             /* Handle the case of a call by build_c_cast.  */
 876             field = TREE_PURPOSE (tail), win = 1;
 877           else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
 878             error ("index value instead of field name in union initializer");
 879           else
 880             {
 881               tree temp;
 882               for (temp = TYPE_FIELDS (type);
 883                    temp;
 884                    temp = TREE_CHAIN (temp))
 885                 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
 886                   break;
 887               if (temp)
 888                 field = temp, win = 1;
 889               else
 890                 error ("no field `%D' in union being initialized",
 891                           TREE_PURPOSE (tail));
 892             }
 893           if (!win)
 894             TREE_VALUE (tail) = error_mark_node;
 895         }
 896       else if (field == 0)
 897         {
 898           error ("union `%T' with no named members cannot be initialized",
 899                     type);
 900           TREE_VALUE (tail) = error_mark_node;
 901         }
 902
 903       if (TREE_VALUE (tail) != 0)
 904         {
 905           tree tail1 = tail;
 906
 907           next1 = digest_init (TREE_TYPE (field),
 908                                TREE_VALUE (tail), &tail1);
 909           if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
 910             abort ();
 911           tail = tail1;
 912         }
 913       else
 914         {
 915           next1 = error_mark_node;
 916           tail = TREE_CHAIN (tail);
 917         }
 918
 919       if (next1 == error_mark_node)
 920         erroneous = 1;
 921       else if (!TREE_CONSTANT (next1))
 922         allconstant = 0;
 923       else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
 924         allsimple = 0;
 925       members = tree_cons (field, next1, members);
 926     }
 927
 928   /* If arguments were specified as a list, just remove the ones we used.  */
 929   if (elts)
 930     *elts = tail;
 931   /* If arguments were specified as a constructor,
 932      complain unless we used all the elements of the constructor.  */
 933   else if (tail)
 934     pedwarn ("excess elements in aggregate initializer");
 935
 936   if (erroneous)
 937     return error_mark_node;
 938
 939   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
 940   if (init)
 941     TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
 942   if (allconstant) TREE_CONSTANT (result) = 1;
 943   if (allconstant && allsimple) TREE_STATIC (result) = 1;
 944   return result;
 945 }
 946 \f
 947 /* Given a structure or union value DATUM, construct and return
 948    the structure or union component which results from narrowing
 949    that value by the type specified in BASETYPE.  For example, given the
 950    hierarchy
 951
 952    class L { int ii; };
 953    class A : L { ... };
 954    class B : L { ... };
 955    class C : A, B { ... };
 956
 957    and the declaration
 958
 959    C x;
 960
 961    then the expression
 962
 963    x.A::ii refers to the ii member of the L part of
 964    the A part of the C object named by X.  In this case,
 965    DATUM would be x, and BASETYPE would be A.
 966
 967    I used to think that this was nonconformant, that the standard specified
 968    that first we look up ii in A, then convert x to an L& and pull out the
 969    ii part.  But in fact, it does say that we convert x to an A&; A here
 970    is known as the "naming class".  (jason 2000-12-19) */
 971
 972 tree
 973 build_scoped_ref (datum, basetype)
 974      tree datum;
 975      tree basetype;
 976 {
 977   tree ref;
 978   tree binfo;
 979
 980   if (datum == error_mark_node)
 981     return error_mark_node;
 982   binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
 983
 984   if (binfo == error_mark_node)
 985     return error_mark_node;
 986   if (!binfo)
 987     return error_not_base_type (TREE_TYPE (datum), basetype);
 988
 989   ref = build_unary_op (ADDR_EXPR, datum, 0);
 990   ref = build_base_path (PLUS_EXPR, ref, binfo, 1);
 991
 992   return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
 993 }
 994
 995 /* Build a reference to an object specified by the C++ `->' operator.
 996    Usually this just involves dereferencing the object, but if the
 997    `->' operator is overloaded, then such overloads must be
 998    performed until an object which does not have the `->' operator
 999    overloaded is found.  An error is reported when circular pointer
1000    delegation is detected.  */
1001
1002 tree
1003 build_x_arrow (datum)
1004      tree datum;
1005 {
1006   tree types_memoized = NULL_TREE;
1007   register tree rval = datum;
1008   tree type = TREE_TYPE (rval);
1009   tree last_rval = NULL_TREE;
1010
1011   if (type == error_mark_node)
1012     return error_mark_node;
1013
1014   if (processing_template_decl)
1015     return build_min_nt (ARROW_EXPR, rval);
1016
1017   if (TREE_CODE (rval) == OFFSET_REF)
1018     {
1019       rval = resolve_offset_ref (datum);
1020       type = TREE_TYPE (rval);
1021     }
1022
1023   if (TREE_CODE (type) == REFERENCE_TYPE)
1024     {
1025       rval = convert_from_reference (rval);
1026       type = TREE_TYPE (rval);
1027     }
1028
1029   if (IS_AGGR_TYPE (type))
1030     {
1031       while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval,
1032                                      NULL_TREE, NULL_TREE)))
1033         {
1034           if (rval == error_mark_node)
1035             return error_mark_node;
1036
1037           if (value_member (TREE_TYPE (rval), types_memoized))
1038             {
1039               error ("circular pointer delegation detected");
1040               return error_mark_node;
1041             }
1042           else
1043             {
1044               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1045                                           types_memoized);
1046             }
1047           last_rval = rval;
1048         }
1049
1050       if (last_rval == NULL_TREE)
1051         {
1052           error ("base operand of `->' has non-pointer type `%T'", type);
1053           return error_mark_node;
1054         }
1055
1056       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1057         last_rval = convert_from_reference (last_rval);
1058     }
1059   else
1060     last_rval = default_conversion (rval);
1061
1062   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1063     return build_indirect_ref (last_rval, NULL);
1064
1065   if (types_memoized)
1066     error ("result of `operator->()' yields non-pointer result");
1067   else
1068     error ("base operand of `->' is not a pointer");
1069   return error_mark_node;
1070 }
1071
1072 /* Make an expression to refer to the COMPONENT field of
1073    structure or union value DATUM.  COMPONENT is an arbitrary
1074    expression.  DATUM has not already been checked out to be of
1075    aggregate type.
1076
1077    For C++, COMPONENT may be a TREE_LIST.  This happens when we must
1078    return an object of member type to a method of the current class,
1079    but there is not yet enough typing information to know which one.
1080    As a special case, if there is only one method by that name,
1081    it is returned.  Otherwise we return an expression which other
1082    routines will have to know how to deal with later.  */
1083
1084 tree
1085 build_m_component_ref (datum, component)
1086      tree datum, component;
1087 {
1088   tree type;
1089   tree objtype;
1090   tree field_type;
1091   int type_quals;
1092   tree binfo;
1093
1094   if (processing_template_decl)
1095     return build_min_nt (DOTSTAR_EXPR, datum, component);
1096
1097   datum = decay_conversion (datum);
1098
1099   if (datum == error_mark_node || component == error_mark_node)
1100     return error_mark_node;
1101
1102   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1103
1104   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1105     {
1106       type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1107       field_type = type;
1108     }
1109   else if (TYPE_PTRMEM_P (TREE_TYPE (component)))
1110     {
1111       type = TREE_TYPE (TREE_TYPE (component));
1112       field_type = TREE_TYPE (type);
1113
1114       /* Compute the type of the field, as described in [expr.ref].  */
1115       type_quals = TYPE_UNQUALIFIED;
1116       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1117         /* The standard says that the type of the result should be the
1118            type referred to by the reference.  But for now, at least,
1119            we do the conversion from reference type later.  */
1120         ;
1121       else
1122         {
1123           type_quals = (cp_type_quals (field_type)
1124                         | cp_type_quals (TREE_TYPE (datum)));
1125
1126           /* There's no such thing as a mutable pointer-to-member, so
1127              we don't need to deal with that here like we do in
1128              build_component_ref.  */
1129           field_type = cp_build_qualified_type (field_type, type_quals);
1130         }
1131     }
1132   else
1133     {
1134       error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1135                 component, TREE_TYPE (component));
1136       return error_mark_node;
1137     }
1138
1139   if (! IS_AGGR_TYPE (objtype))
1140     {
1141       error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1142                 component, datum, objtype);
1143       return error_mark_node;
1144     }
1145
1146   binfo = lookup_base (objtype, TYPE_METHOD_BASETYPE (type),
1147                        ba_check, NULL);
1148   if (!binfo)
1149     {
1150       error ("member type `%T::' incompatible with object type `%T'",
1151                 TYPE_METHOD_BASETYPE (type), objtype);
1152       return error_mark_node;
1153     }
1154   else if (binfo == error_mark_node)
1155     return error_mark_node;
1156
1157   component = build (OFFSET_REF, field_type, datum, component);
1158   if (TREE_CODE (type) == OFFSET_TYPE)
1159     component = resolve_offset_ref (component);
1160   return component;
1161 }
1162
1163 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1164
1165 tree
1166 build_functional_cast (exp, parms)
1167      tree exp;
1168      tree parms;
1169 {
1170   /* This is either a call to a constructor,
1171      or a C cast in C++'s `functional' notation.  */
1172   tree type;
1173
1174   if (exp == error_mark_node || parms == error_mark_node)
1175     return error_mark_node;
1176
1177   if (TREE_CODE (exp) == IDENTIFIER_NODE)
1178     {
1179       if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1180         /* Either an enum or an aggregate type.  */
1181         type = IDENTIFIER_TYPE_VALUE (exp);
1182       else
1183         {
1184           type = lookup_name (exp, 1);
1185           if (!type || TREE_CODE (type) != TYPE_DECL)
1186             {
1187               error ("`%T' fails to be a typedef or built-in type", exp);
1188               return error_mark_node;
1189             }
1190           type = TREE_TYPE (type);
1191         }
1192     }
1193   else if (TREE_CODE (exp) == TYPE_DECL)
1194     type = TREE_TYPE (exp);
1195   else
1196     type = exp;
1197
1198   if (processing_template_decl)
1199     return build_min (CAST_EXPR, type, parms);
1200
1201   if (! IS_AGGR_TYPE (type))
1202     {
1203       /* this must build a C cast */
1204       if (parms == NULL_TREE)
1205         parms = integer_zero_node;
1206       else
1207         {
1208           if (TREE_CHAIN (parms) != NULL_TREE)
1209             pedwarn ("initializer list being treated as compound expression");
1210           parms = build_compound_expr (parms);
1211         }
1212
1213       return build_c_cast (type, parms);
1214     }
1215
1216   /* Prepare to evaluate as a call to a constructor.  If this expression
1217      is actually used, for example,
1218
1219      return X (arg1, arg2, ...);
1220
1221      then the slot being initialized will be filled in.  */
1222
1223   if (!complete_type_or_else (type, NULL_TREE))
1224     return error_mark_node;
1225   if (abstract_virtuals_error (NULL_TREE, type))
1226     return error_mark_node;
1227
1228   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1229     return build_c_cast (type, TREE_VALUE (parms));
1230
1231   /* We need to zero-initialize POD types.  Let's do that for everything
1232      that doesn't need a constructor.  */
1233   if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1234       && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1235     {
1236       exp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
1237       return get_target_expr (exp);
1238     }
1239
1240   exp = build_method_call (NULL_TREE, complete_ctor_identifier, parms,
1241                            TYPE_BINFO (type), LOOKUP_NORMAL);
1242
1243   if (exp == error_mark_node)
1244     return error_mark_node;
1245
1246   return build_cplus_new (type, exp);
1247 }
1248 \f
1249
1250 /* Complain about defining new types in inappropriate places.  We give an
1251    exception for C-style casts, to accommodate GNU C stylings.  */
1252
1253 void
1254 check_for_new_type (string, inptree)
1255      const char *string;
1256      flagged_type_tree inptree;
1257 {
1258   if (inptree.new_type_flag
1259       && (pedantic || strcmp (string, "cast") != 0))
1260     pedwarn ("ISO C++ forbids defining types within %s", string);
1261 }
1262
1263 /* Add new exception specifier SPEC, to the LIST we currently have.
1264    If it's already in LIST then do nothing.
1265    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1266    know what we're doing.  */
1267
1268 tree
1269 add_exception_specifier (list, spec, complain)
1270      tree list, spec;
1271      int complain;
1272 {
1273   int ok;
1274   tree core = spec;
1275   int is_ptr;
1276
1277   if (spec == error_mark_node)
1278     return list;
1279
1280   my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1281
1282   /* [except.spec] 1, type in an exception specifier shall not be
1283      incomplete, or pointer or ref to incomplete other than pointer
1284      to cv void.  */
1285   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1286   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1287     core = TREE_TYPE (core);
1288   if (complain < 0)
1289     ok = 1;
1290   else if (VOID_TYPE_P (core))
1291     ok = is_ptr;
1292   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1293     ok = 1;
1294   else if (processing_template_decl)
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 }