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)
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
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.
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). */
41 #include "diagnostic.h"
43 static tree process_init_constructor
PARAMS ((tree
, tree
, tree
*));
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
49 error_not_base_type (basetype
, type
)
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
;
59 binfo_or_else (base
, type
)
62 tree binfo
= lookup_base (type
, base
, ba_ignore
, NULL
);
64 if (binfo
== error_mark_node
)
67 error_not_base_type (base
, type
);
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.) */
77 readonly_error (arg
, string
, soft
)
83 void (*fn
) PARAMS ((const char *, ...));
90 if (TREE_CODE (arg
) == COMPONENT_REF
)
92 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
93 fmt
= "%s of data-member `%D' in read-only structure";
95 fmt
= "%s of read-only data-member `%D'";
96 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
98 else if (TREE_CODE (arg
) == VAR_DECL
)
100 if (DECL_LANG_SPECIFIC (arg
)
101 && DECL_IN_AGGR_P (arg
)
102 && !TREE_STATIC (arg
))
103 fmt
= "%s of constant field `%D'";
105 fmt
= "%s of read-only variable `%D'";
106 (*fn
) (fmt
, string
, arg
);
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
);
120 (*fn
) ("%s of read-only location", string
);
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. */
129 abstract_virtuals_error (decl
, type
)
136 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
139 if (!TYPE_SIZE (type
))
140 /* TYPE is being defined, and during that time
141 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
144 u
= CLASSTYPE_PURE_VIRTUALS (type
);
147 if (TREE_CODE (decl
) == RESULT_DECL
)
150 if (TREE_CODE (decl
) == VAR_DECL
)
151 error ("cannot declare variable `%D' to be of type `%T'",
153 else if (TREE_CODE (decl
) == PARM_DECL
)
154 error ("cannot declare parameter `%D' to be of type `%T'",
156 else if (TREE_CODE (decl
) == FIELD_DECL
)
157 error ("cannot declare field `%D' to be of type `%T'",
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
);
166 error ("cannot allocate an object of type `%T'", type
);
168 /* Only go through this once. */
169 if (TREE_PURPOSE (u
) == NULL_TREE
)
171 TREE_PURPOSE (u
) = error_mark_node
;
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
));
178 error (" since type `%T' has abstract virtual functions", type
);
183 /* Print an error message for invalid use of an incomplete type.
184 VALUE is the expression that was used (or 0 if that isn't known)
185 and TYPE is the type that was invalid. If WARN_ONLY is nonzero, a
186 warning is printed, otherwise an error is printed. */
189 cxx_incomplete_type_diagnostic (value
, type
, warn_only
)
195 void (*p_msg
) PARAMS ((const char *, ...));
196 void (*p_msg_at
) PARAMS ((const char *, ...));
201 p_msg_at
= cp_warning_at
;
206 p_msg_at
= cp_error_at
;
209 /* Avoid duplicate error message. */
210 if (TREE_CODE (type
) == ERROR_MARK
)
213 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
214 || TREE_CODE (value
) == PARM_DECL
))
216 (*p_msg_at
) ("`%D' has incomplete type", value
);
220 /* We must print an error message. Be clever about what it says. */
222 switch (TREE_CODE (type
))
228 (*p_msg
) ("invalid use of undefined type `%#T'", type
);
229 (*p_msg_at
) ("forward declaration of `%#T'", type
);
233 (*p_msg
) ("invalid use of `%T'", type
);
237 if (TYPE_DOMAIN (type
))
239 type
= TREE_TYPE (type
);
242 (*p_msg
) ("invalid use of array with unspecified bounds");
247 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
250 case TEMPLATE_TYPE_PARM
:
251 (*p_msg
) ("invalid use of template type parameter");
255 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
257 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
258 (*p_msg
) ("address of overloaded function with no contextual type information");
259 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
260 (*p_msg
) ("overloaded function with no contextual type information");
262 (*p_msg
) ("insufficient contextual information to determine type");
270 /* Backward-compatibility interface to incomplete_type_diagnostic;
271 required by ../tree.c. */
272 #undef cxx_incomplete_type_error
274 cxx_incomplete_type_error (value
, type
)
278 cxx_incomplete_type_diagnostic (value
, type
, 0);
282 /* Perform appropriate conversions on the initial value of a variable,
283 store it in the declaration DECL,
284 and print any error messages that are appropriate.
285 If the init is invalid, store an ERROR_MARK.
287 C++: Note that INIT might be a TREE_LIST, which would mean that it is
288 a base class initializer for some aggregate type, hopefully compatible
289 with DECL. If INIT is a single element, and DECL is an aggregate
290 type, we silently convert INIT into a TREE_LIST, allowing a constructor
293 If INIT is a TREE_LIST and there is no constructor, turn INIT
294 into a CONSTRUCTOR and use standard initialization techniques.
295 Perhaps a warning should be generated?
297 Returns value of initializer if initialization could not be
298 performed for static variable. In that case, caller must do
302 store_init_value (decl
, init
)
305 register tree value
, type
;
307 /* If variable's type was invalidly declared, just ignore it. */
309 type
= TREE_TYPE (decl
);
310 if (TREE_CODE (type
) == ERROR_MARK
)
314 /* This breaks arrays, and should not have any effect for other decls. */
315 /* Take care of C++ business up here. */
316 type
= TYPE_MAIN_VARIANT (type
);
319 if (IS_AGGR_TYPE (type
))
321 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
322 && TREE_CODE (init
) != CONSTRUCTOR
)
325 if (TREE_CODE (init
) == TREE_LIST
)
327 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
328 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
331 if (TREE_CODE (init
) == CONSTRUCTOR
)
335 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
336 if (CLASSTYPE_N_BASECLASSES (type
))
337 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl
);
338 if (CLASSTYPE_VTBL_PTR (type
))
339 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl
);
340 if (TYPE_NEEDS_CONSTRUCTING (type
))
342 cp_error_at ("initializer list construction invalid for `%D'", decl
);
343 error ("due to the presence of a constructor");
345 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
346 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
348 cp_error_at ("initializer list construction invalid for `%D'", decl
);
349 cp_error_at ("due to non-public access of member `%D'", field
);
351 for (field
= TYPE_METHODS (type
); field
; field
= TREE_CHAIN (field
))
352 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
354 cp_error_at ("initializer list construction invalid for `%D'", decl
);
355 cp_error_at ("due to non-public access of member `%D'", field
);
360 else if (TREE_CODE (init
) == TREE_LIST
361 && TREE_TYPE (init
) != unknown_type_node
)
363 if (TREE_CODE (decl
) == RESULT_DECL
)
365 if (TREE_CHAIN (init
))
367 warning ("comma expression used to initialize return value");
368 init
= build_compound_expr (init
);
371 init
= TREE_VALUE (init
);
373 else if (TREE_CODE (init
) == TREE_LIST
374 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
376 error ("cannot initialize arrays using this syntax");
381 /* We get here with code like `int a (2);' */
383 if (TREE_CHAIN (init
) != NULL_TREE
)
385 pedwarn ("initializer list being treated as compound expression");
386 init
= build_compound_expr (init
);
389 init
= TREE_VALUE (init
);
393 /* End of special C++ code. */
395 /* We might have already run this bracketed initializer through
396 digest_init. Don't do so again. */
397 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
)
399 && TYPE_MAIN_VARIANT (TREE_TYPE (init
)) == TYPE_MAIN_VARIANT (type
))
402 /* Digest the specified initializer into an expression. */
403 value
= digest_init (type
, init
, (tree
*) 0);
405 /* Store the expression if valid; else report error. */
407 if (TREE_CODE (value
) == ERROR_MARK
)
409 /* Other code expects that initializers for objects of types that need
410 constructing never make it into DECL_INITIAL, and passes 'init' to
411 build_aggr_init without checking DECL_INITIAL. So just return. */
412 else if (TYPE_NEEDS_CONSTRUCTING (type
))
414 else if (TREE_STATIC (decl
)
415 && (! TREE_CONSTANT (value
)
416 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
418 /* A STATIC PUBLIC int variable doesn't have to be
419 run time inited when doing pic. (mrs) */
420 /* Since ctors and dtors are the only things that can
421 reference vtables, and they are always written down
422 the vtable definition, we can leave the
423 vtables in initialized data space.
424 However, other initialized data cannot be initialized
425 this way. Instead a global file-level initializer
427 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
432 #if 0 /* No, that's C. jason 9/19/94 */
435 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
437 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
438 pedwarn ("ISO C++ forbids non-constant aggregate initializer expressions");
443 /* Store the VALUE in DECL_INITIAL. If we're building a
444 statement-tree we will actually expand the initialization later
445 when we output this function. */
446 DECL_INITIAL (decl
) = value
;
450 /* Same as store_init_value, but used for known-to-be-valid static
451 initializers. Used to introduce a static initializer even in data
452 structures that may require dynamic initialization. */
455 force_store_init_value (decl
, init
)
458 tree type
= TREE_TYPE (decl
);
459 int needs_constructing
= TYPE_NEEDS_CONSTRUCTING (type
);
461 TYPE_NEEDS_CONSTRUCTING (type
) = 0;
463 init
= store_init_value (decl
, init
);
467 TYPE_NEEDS_CONSTRUCTING (type
) = needs_constructing
;
472 /* Digest the parser output INIT as an initializer for type TYPE.
473 Return a C expression of type TYPE to represent the initial value.
475 If TAIL is nonzero, it points to a variable holding a list of elements
476 of which INIT is the first. We update the list stored there by
477 removing from the head all the elements that we use.
478 Normally this is only one; we use more than one element only if
479 TYPE is an aggregate and INIT is not a constructor. */
482 digest_init (type
, init
, tail
)
483 tree type
, init
, *tail
;
485 enum tree_code code
= TREE_CODE (type
);
486 tree element
= NULL_TREE
;
487 tree old_tail_contents
= NULL_TREE
;
488 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
489 tree node which has no TREE_TYPE. */
492 /* By default, assume we use one element from a list.
493 We correct this later in the sole case where it is not true. */
497 old_tail_contents
= *tail
;
498 *tail
= TREE_CHAIN (*tail
);
501 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
502 && TREE_VALUE (init
) == error_mark_node
))
503 return error_mark_node
;
505 if (TREE_CODE (init
) == ERROR_MARK
)
506 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
507 a template function. This gets substituted during instantiation. */
510 /* We must strip the outermost array type when completing the type,
511 because the its bounds might be incomplete at the moment. */
512 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
513 ? TREE_TYPE (type
) : type
, NULL_TREE
))
514 return error_mark_node
;
516 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
517 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
518 init
= TREE_OPERAND (init
, 0);
520 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == type
)
523 raw_constructor
= TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == 0;
526 && CONSTRUCTOR_ELTS (init
) != 0
527 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
529 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
530 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
531 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
532 element
= TREE_OPERAND (element
, 0);
533 if (element
== error_mark_node
)
537 /* Initialization of an array of chars from a string constant
538 optionally enclosed in braces. */
540 if (code
== ARRAY_TYPE
)
544 if (TREE_CODE (init
) == TREE_LIST
)
546 error ("initializing array with parameter list");
547 return error_mark_node
;
550 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
551 if (char_type_p (typ1
)
552 && ((init
&& TREE_CODE (init
) == STRING_CST
)
553 || (element
&& TREE_CODE (element
) == STRING_CST
)))
555 tree string
= element
? element
: init
;
557 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
559 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
561 error ("char-array initialized from wide string");
562 return error_mark_node
;
564 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
566 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
568 error ("int-array initialized from non-wide string");
569 return error_mark_node
;
572 TREE_TYPE (string
) = type
;
573 if (TYPE_DOMAIN (type
) != 0
574 && TREE_CONSTANT (TYPE_SIZE (type
)))
577 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
578 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
579 /* In C it is ok to subtract 1 from the length of the string
580 because it's ok to ignore the terminating null char that is
581 counted in the length of the constant, but in C++ this would
583 if (size
< TREE_STRING_LENGTH (string
))
584 pedwarn ("initializer-string for array of chars is too long");
590 /* Handle scalar types, including conversions,
591 and signature pointers and references. */
593 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
594 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
595 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
596 || TYPE_PTRMEMFUNC_P (type
))
602 error ("initializer for scalar variable requires one element");
603 return error_mark_node
;
607 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
609 pedwarn ("braces around scalar initializer for `%T'", type
);
610 init
= CONSTRUCTOR_ELTS (init
);
611 if (TREE_CHAIN (init
))
612 pedwarn ("ignoring extra initializers for `%T'", type
);
613 init
= TREE_VALUE (init
);
616 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
617 "initialization", NULL_TREE
, 0);
620 /* Come here only for records and arrays (and unions with constructors). */
622 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
624 error ("variable-sized object of type `%T' may not be initialized",
626 return error_mark_node
;
629 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
631 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
632 && TREE_HAS_CONSTRUCTOR (init
))
634 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
636 return error_mark_node
;
638 else if (raw_constructor
)
639 return process_init_constructor (type
, init
, (tree
*)0);
640 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
641 || TYPE_NON_AGGREGATE_CLASS (type
))
642 /* These are never initialized from multiple constructor elements. */;
645 *tail
= old_tail_contents
;
646 return process_init_constructor (type
, 0, tail
);
649 if (code
!= ARRAY_TYPE
)
651 int flags
= LOOKUP_NORMAL
;
652 /* Initialization from { } is copy-initialization. */
654 flags
|= LOOKUP_ONLYCONVERTING
;
656 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
657 "initialization", NULL_TREE
, 0);
661 error ("invalid initializer");
662 return error_mark_node
;
665 /* Process a constructor for a variable of type TYPE.
666 The constructor elements may be specified either with INIT or with ELTS,
667 only one of which should be non-null.
669 If INIT is specified, it is a CONSTRUCTOR node which is specifically
670 and solely for initializing this datum.
672 If ELTS is specified, it is the address of a variable containing
673 a list of expressions. We take as many elements as we need
674 from the head of the list and update the list.
676 In the resulting constructor, TREE_CONSTANT is set if all elts are
677 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
678 constants that the assembler and linker can compute them. */
681 process_init_constructor (type
, init
, elts
)
682 tree type
, init
, *elts
;
685 /* List of the elements of the result constructor,
687 register tree members
= NULL
;
694 /* Make TAIL be the list of elements to use for the initialization,
695 no matter how the data was given to us. */
699 if (warn_missing_braces
)
700 warning ("aggregate has a partly bracketed initializer");
704 tail
= CONSTRUCTOR_ELTS (init
);
706 /* Gobble as many elements as needed, and make a constructor or initial value
707 for each element of this aggregate. Chain them together in result.
708 If there are too few, use 0 for each scalar ultimate component. */
710 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
715 if (TREE_CODE (type
) == ARRAY_TYPE
)
717 tree domain
= TYPE_DOMAIN (type
);
719 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
720 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
723 len
= -1; /* Take as many as there are */
727 /* Vectors are like simple fixed-size arrays. */
728 len
= TYPE_VECTOR_SUBPARTS (type
);
731 for (i
= 0; len
< 0 || i
< len
; i
++)
735 if (TREE_PURPOSE (tail
)
736 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
737 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
738 sorry ("non-trivial labeled initializers");
740 if (TREE_VALUE (tail
) != 0)
743 next1
= digest_init (TREE_TYPE (type
),
744 TREE_VALUE (tail
), &tail1
);
745 if (next1
== error_mark_node
)
748 (same_type_ignoring_top_level_qualifiers_p
749 (TREE_TYPE (type
), TREE_TYPE (next1
)),
751 my_friendly_assert (tail1
== 0
752 || TREE_CODE (tail1
) == TREE_LIST
, 319);
753 if (tail
== tail1
&& len
< 0)
755 error ("non-empty initializer for array of empty elements");
756 /* Just ignore what we were supposed to use. */
763 next1
= error_mark_node
;
764 tail
= TREE_CHAIN (tail
);
770 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
772 /* If this type needs constructors run for
773 default-initialization, we can't rely on the backend to do it
774 for us, so build up TARGET_EXPRs. If the type in question is
775 a class, just build one up; if it's an array, recurse. */
777 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
778 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
780 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
781 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
783 else if (! zero_init_p (TREE_TYPE (type
)))
784 next1
= build_forced_zero_init (TREE_TYPE (type
));
786 /* The default zero-initialization is fine for us; don't
787 add anything to the CONSTRUCTOR. */
790 if (next1
== error_mark_node
)
792 else if (!TREE_CONSTANT (next1
))
794 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
796 members
= tree_cons (size_int (i
), next1
, members
);
799 else if (TREE_CODE (type
) == RECORD_TYPE
)
805 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
807 sorry ("initializer list for object of class with virtual base classes");
808 return error_mark_node
;
811 if (TYPE_BINFO_BASETYPES (type
))
813 sorry ("initializer list for object of class with base classes");
814 return error_mark_node
;
817 if (TYPE_POLYMORPHIC_P (type
))
819 sorry ("initializer list for object using virtual functions");
820 return error_mark_node
;
824 for (field
= TYPE_FIELDS (type
); field
;
825 field
= TREE_CHAIN (field
))
827 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
829 members
= tree_cons (field
, integer_zero_node
, members
);
833 if (TREE_CODE (field
) != FIELD_DECL
)
838 if (TREE_PURPOSE (tail
)
839 && TREE_PURPOSE (tail
) != field
840 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
841 sorry ("non-trivial labeled initializers");
843 if (TREE_VALUE (tail
) != 0)
847 next1
= digest_init (TREE_TYPE (field
),
848 TREE_VALUE (tail
), &tail1
);
849 my_friendly_assert (tail1
== 0
850 || TREE_CODE (tail1
) == TREE_LIST
, 320);
855 next1
= error_mark_node
;
856 tail
= TREE_CHAIN (tail
);
859 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
861 /* If this type needs constructors run for
862 default-initialization, we can't rely on the backend to do it
863 for us, so build up TARGET_EXPRs. If the type in question is
864 a class, just build one up; if it's an array, recurse. */
866 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
867 next1
= build_functional_cast (TREE_TYPE (field
),
871 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
874 TREE_HAS_CONSTRUCTOR (next1
)
875 = TREE_HAS_CONSTRUCTOR (init
);
877 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
879 /* Warn when some struct elements are implicitly initialized. */
881 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
882 warning ("missing initializer for member `%D'", field
);
886 if (TREE_READONLY (field
))
887 error ("uninitialized const member `%D'", field
);
888 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field
))
889 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
890 error ("member `%D' with uninitialized const fields",
892 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
893 error ("member `%D' is uninitialized reference", field
);
895 /* Warn when some struct elements are implicitly initialized
898 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
899 warning ("missing initializer for member `%D'", field
);
901 if (! zero_init_p (TREE_TYPE (field
)))
902 next1
= build_forced_zero_init (TREE_TYPE (field
));
904 /* The default zero-initialization is fine for us; don't
905 add anything to the CONSTRUCTOR. */
909 if (next1
== error_mark_node
)
911 else if (!TREE_CONSTANT (next1
))
913 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
915 members
= tree_cons (field
, next1
, members
);
918 else if (TREE_CODE (type
) == UNION_TYPE
919 /* If the initializer was empty, use default zero initialization. */
922 register tree field
= TYPE_FIELDS (type
);
924 /* Find the first named field. ANSI decided in September 1990
925 that only named fields count here. */
926 while (field
&& (DECL_NAME (field
) == 0
927 || TREE_CODE (field
) != FIELD_DECL
))
928 field
= TREE_CHAIN (field
);
930 /* If this element specifies a field, initialize via that field. */
931 if (TREE_PURPOSE (tail
) != NULL_TREE
)
935 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
936 /* Handle the case of a call by build_c_cast. */
937 field
= TREE_PURPOSE (tail
), win
= 1;
938 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
939 error ("index value instead of field name in union initializer");
943 for (temp
= TYPE_FIELDS (type
);
945 temp
= TREE_CHAIN (temp
))
946 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
949 field
= temp
, win
= 1;
951 error ("no field `%D' in union being initialized",
952 TREE_PURPOSE (tail
));
955 TREE_VALUE (tail
) = error_mark_node
;
959 error ("union `%T' with no named members cannot be initialized",
961 TREE_VALUE (tail
) = error_mark_node
;
964 if (TREE_VALUE (tail
) != 0)
968 next1
= digest_init (TREE_TYPE (field
),
969 TREE_VALUE (tail
), &tail1
);
970 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
976 next1
= error_mark_node
;
977 tail
= TREE_CHAIN (tail
);
980 if (next1
== error_mark_node
)
982 else if (!TREE_CONSTANT (next1
))
984 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
986 members
= tree_cons (field
, next1
, members
);
989 /* If arguments were specified as a list, just remove the ones we used. */
992 /* If arguments were specified as a constructor,
993 complain unless we used all the elements of the constructor. */
995 pedwarn ("excess elements in aggregate initializer");
998 return error_mark_node
;
1000 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
1002 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
1003 if (allconstant
) TREE_CONSTANT (result
) = 1;
1004 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
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
1013 class L { int ii; };
1014 class A : L { ... };
1015 class B : L { ... };
1016 class C : A, B { ... };
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.
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)
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. */
1037 build_scoped_ref (datum
, basetype
, binfo_p
)
1044 if (datum
== error_mark_node
)
1045 return error_mark_node
;
1049 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1051 if (!binfo
|| binfo
== error_mark_node
)
1053 *binfo_p
= NULL_TREE
;
1055 error_not_base_type (basetype
, TREE_TYPE (datum
));
1056 return error_mark_node
;
1060 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1063 /* Build a reference to an object specified by the C++ `->' operator.
1064 Usually this just involves dereferencing the object, but if the
1065 `->' operator is overloaded, then such overloads must be
1066 performed until an object which does not have the `->' operator
1067 overloaded is found. An error is reported when circular pointer
1068 delegation is detected. */
1071 build_x_arrow (datum
)
1074 tree types_memoized
= NULL_TREE
;
1075 register tree rval
= datum
;
1076 tree type
= TREE_TYPE (rval
);
1077 tree last_rval
= NULL_TREE
;
1079 if (type
== error_mark_node
)
1080 return error_mark_node
;
1082 if (processing_template_decl
)
1083 return build_min_nt (ARROW_EXPR
, rval
);
1085 if (TREE_CODE (rval
) == OFFSET_REF
)
1087 rval
= resolve_offset_ref (datum
);
1088 type
= TREE_TYPE (rval
);
1091 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1093 rval
= convert_from_reference (rval
);
1094 type
= TREE_TYPE (rval
);
1097 if (IS_AGGR_TYPE (type
))
1099 while ((rval
= build_opfncall (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1100 NULL_TREE
, NULL_TREE
)))
1102 if (rval
== error_mark_node
)
1103 return error_mark_node
;
1105 if (value_member (TREE_TYPE (rval
), types_memoized
))
1107 error ("circular pointer delegation detected");
1108 return error_mark_node
;
1112 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1118 if (last_rval
== NULL_TREE
)
1120 error ("base operand of `->' has non-pointer type `%T'", type
);
1121 return error_mark_node
;
1124 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1125 last_rval
= convert_from_reference (last_rval
);
1128 last_rval
= default_conversion (rval
);
1130 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1131 return build_indirect_ref (last_rval
, NULL
);
1134 error ("result of `operator->()' yields non-pointer result");
1136 error ("base operand of `->' is not a pointer");
1137 return error_mark_node
;
1140 /* Make an expression to refer to the COMPONENT field of
1141 structure or union value DATUM. COMPONENT is an arbitrary
1142 expression. DATUM has not already been checked out to be of
1145 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1146 return an object of member type to a method of the current class,
1147 but there is not yet enough typing information to know which one.
1148 As a special case, if there is only one method by that name,
1149 it is returned. Otherwise we return an expression which other
1150 routines will have to know how to deal with later. */
1153 build_m_component_ref (datum
, component
)
1154 tree datum
, component
;
1162 if (processing_template_decl
)
1163 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1165 datum
= decay_conversion (datum
);
1167 if (datum
== error_mark_node
|| component
== error_mark_node
)
1168 return error_mark_node
;
1170 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1172 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1174 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1177 else if (TYPE_PTRMEM_P (TREE_TYPE (component
)))
1179 type
= TREE_TYPE (TREE_TYPE (component
));
1180 field_type
= TREE_TYPE (type
);
1182 /* Compute the type of the field, as described in [expr.ref]. */
1183 type_quals
= TYPE_UNQUALIFIED
;
1184 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1185 /* The standard says that the type of the result should be the
1186 type referred to by the reference. But for now, at least,
1187 we do the conversion from reference type later. */
1191 type_quals
= (cp_type_quals (field_type
)
1192 | cp_type_quals (TREE_TYPE (datum
)));
1194 /* There's no such thing as a mutable pointer-to-member, so
1195 we don't need to deal with that here like we do in
1196 build_component_ref. */
1197 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1202 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1203 component
, TREE_TYPE (component
));
1204 return error_mark_node
;
1207 if (! IS_AGGR_TYPE (objtype
))
1209 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1210 component
, datum
, objtype
);
1211 return error_mark_node
;
1214 binfo
= lookup_base (objtype
, TYPE_METHOD_BASETYPE (type
),
1218 error ("member type `%T::' incompatible with object type `%T'",
1219 TYPE_METHOD_BASETYPE (type
), objtype
);
1220 return error_mark_node
;
1222 else if (binfo
== error_mark_node
)
1223 return error_mark_node
;
1225 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1226 if (TREE_CODE (type
) == OFFSET_TYPE
)
1227 component
= resolve_offset_ref (component
);
1231 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1234 build_functional_cast (exp
, parms
)
1238 /* This is either a call to a constructor,
1239 or a C cast in C++'s `functional' notation. */
1242 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1243 return error_mark_node
;
1245 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1247 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1248 /* Either an enum or an aggregate type. */
1249 type
= IDENTIFIER_TYPE_VALUE (exp
);
1252 type
= lookup_name (exp
, 1);
1253 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1255 error ("`%T' fails to be a typedef or built-in type", exp
);
1256 return error_mark_node
;
1258 type
= TREE_TYPE (type
);
1261 else if (TREE_CODE (exp
) == TYPE_DECL
)
1262 type
= TREE_TYPE (exp
);
1266 if (processing_template_decl
)
1267 return build_min (CAST_EXPR
, type
, parms
);
1269 if (! IS_AGGR_TYPE (type
))
1271 /* this must build a C cast */
1272 if (parms
== NULL_TREE
)
1273 parms
= integer_zero_node
;
1276 if (TREE_CHAIN (parms
) != NULL_TREE
)
1277 pedwarn ("initializer list being treated as compound expression");
1278 parms
= build_compound_expr (parms
);
1281 return build_c_cast (type
, parms
);
1284 /* Prepare to evaluate as a call to a constructor. If this expression
1285 is actually used, for example,
1287 return X (arg1, arg2, ...);
1289 then the slot being initialized will be filled in. */
1291 if (!complete_type_or_else (type
, NULL_TREE
))
1292 return error_mark_node
;
1293 if (abstract_virtuals_error (NULL_TREE
, type
))
1294 return error_mark_node
;
1296 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1297 return build_c_cast (type
, TREE_VALUE (parms
));
1299 /* We need to zero-initialize POD types. Let's do that for everything
1300 that doesn't need a constructor. */
1301 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1302 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1304 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1305 return get_target_expr (exp
);
1308 exp
= build_method_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1309 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1311 if (exp
== error_mark_node
)
1312 return error_mark_node
;
1314 return build_cplus_new (type
, exp
);
1318 /* Complain about defining new types in inappropriate places. We give an
1319 exception for C-style casts, to accommodate GNU C stylings. */
1322 check_for_new_type (string
, inptree
)
1324 flagged_type_tree inptree
;
1326 if (inptree
.new_type_flag
1327 && (pedantic
|| strcmp (string
, "cast") != 0))
1328 pedwarn ("ISO C++ forbids defining types within %s", string
);
1331 /* Add new exception specifier SPEC, to the LIST we currently have.
1332 If it's already in LIST then do nothing.
1333 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1334 know what we're doing. */
1337 add_exception_specifier (list
, spec
, complain
)
1345 if (spec
== error_mark_node
)
1348 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1350 /* [except.spec] 1, type in an exception specifier shall not be
1351 incomplete, or pointer or ref to incomplete other than pointer
1353 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1354 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1355 core
= TREE_TYPE (core
);
1358 else if (VOID_TYPE_P (core
))
1360 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1362 else if (processing_template_decl
)
1365 ok
= COMPLETE_TYPE_P (complete_type (core
));
1371 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1372 if (same_type_p (TREE_VALUE (probe
), spec
))
1375 list
= tree_cons (NULL_TREE
, spec
, list
);
1378 cxx_incomplete_type_error (NULL_TREE
, core
);
1382 /* Combine the two exceptions specifier lists LIST and ADD, and return
1386 merge_exception_specifiers (list
, add
)
1391 else if (!TREE_VALUE (list
))
1393 else if (!TREE_VALUE (add
))
1397 tree orig_list
= list
;
1399 for (; add
; add
= TREE_CHAIN (add
))
1401 tree spec
= TREE_VALUE (add
);
1404 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1405 if (same_type_p (TREE_VALUE (probe
), spec
))
1409 spec
= build_tree_list (NULL_TREE
, spec
);
1410 TREE_CHAIN (spec
) = list
;