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