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