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