gcc/cp/typeck2.c

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