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