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