gcc/cp/typeck2.c

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