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