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 GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
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). */
36 #include "coretypes.h"
43 #include "diagnostic.h"
45 static tree
process_init_constructor (tree
, tree
, tree
*);
47 /* Print an error message stemming from an attempt to use
48 BASETYPE as a base class for TYPE. */
51 error_not_base_type (tree basetype
, tree type
)
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
;
60 binfo_or_else (tree base
, tree 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 (tree arg
, const char* string
, int soft
)
80 void (*fn
) (const char *, ...);
87 if (TREE_CODE (arg
) == COMPONENT_REF
)
89 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
90 fmt
= "%s of data-member `%D' in read-only structure";
92 fmt
= "%s of read-only data-member `%D'";
93 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
95 else if (TREE_CODE (arg
) == VAR_DECL
)
97 if (DECL_LANG_SPECIFIC (arg
)
98 && DECL_IN_AGGR_P (arg
)
99 && !TREE_STATIC (arg
))
100 fmt
= "%s of constant field `%D'";
102 fmt
= "%s of read-only variable `%D'";
103 (*fn
) (fmt
, string
, arg
);
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
);
117 (*fn
) ("%s of read-only location", string
);
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. */
126 abstract_virtuals_error (tree decl
, tree type
)
131 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
134 if (!TYPE_SIZE (type
))
135 /* TYPE is being defined, and during that time
136 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
139 if (dependent_type_p (type
))
140 /* For a dependent type, we do not yet know which functions are pure
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. DIAG_TYPE indicates the
186 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
190 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
193 void (*p_msg
) (const char *, ...);
194 void (*p_msg_at
) (const char *, ...);
199 p_msg_at
= cp_warning_at
;
201 else if (diag_type
== 2)
204 p_msg_at
= cp_pedwarn_at
;
209 p_msg_at
= cp_error_at
;
212 /* Avoid duplicate error message. */
213 if (TREE_CODE (type
) == ERROR_MARK
)
216 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
217 || TREE_CODE (value
) == PARM_DECL
218 || TREE_CODE (value
) == FIELD_DECL
))
220 (*p_msg_at
) ("`%D' has incomplete type", value
);
224 /* We must print an error message. Be clever about what it says. */
226 switch (TREE_CODE (type
))
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
);
236 (*p_msg_at
) ("declaration of `%#T'", type
);
240 (*p_msg
) ("invalid use of `%T'", type
);
244 if (TYPE_DOMAIN (type
))
246 type
= TREE_TYPE (type
);
249 (*p_msg
) ("invalid use of array with unspecified bounds");
254 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
257 case TEMPLATE_TYPE_PARM
:
258 (*p_msg
) ("invalid use of template type parameter");
262 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
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");
269 (*p_msg
) ("insufficient contextual information to determine type");
277 /* Backward-compatibility interface to incomplete_type_diagnostic;
278 required by ../tree.c. */
279 #undef cxx_incomplete_type_error
281 cxx_incomplete_type_error (tree value
, tree type
)
283 cxx_incomplete_type_diagnostic (value
, type
, 0);
287 /* Perform appropriate conversions on the initial value of a variable,
288 store it in the declaration DECL,
289 and print any error messages that are appropriate.
290 If the init is invalid, store an ERROR_MARK.
292 C++: Note that INIT might be a TREE_LIST, which would mean that it is
293 a base class initializer for some aggregate type, hopefully compatible
294 with DECL. If INIT is a single element, and DECL is an aggregate
295 type, we silently convert INIT into a TREE_LIST, allowing a constructor
298 If INIT is a TREE_LIST and there is no constructor, turn INIT
299 into a CONSTRUCTOR and use standard initialization techniques.
300 Perhaps a warning should be generated?
302 Returns value of initializer if initialization could not be
303 performed for static variable. In that case, caller must do
307 store_init_value (tree decl
, tree init
)
309 register tree value
, type
;
311 /* If variable's type was invalidly declared, just ignore it. */
313 type
= TREE_TYPE (decl
);
314 if (TREE_CODE (type
) == ERROR_MARK
)
317 if (IS_AGGR_TYPE (type
))
319 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
320 && TREE_CODE (init
) != CONSTRUCTOR
)
323 if (TREE_CODE (init
) == TREE_LIST
)
325 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
326 init
= build_constructor (NULL_TREE
, nreverse (init
));
329 else if (TREE_CODE (init
) == TREE_LIST
330 && TREE_TYPE (init
) != unknown_type_node
)
332 if (TREE_CODE (decl
) == RESULT_DECL
)
334 if (TREE_CHAIN (init
))
336 warning ("comma expression used to initialize return value");
337 init
= build_compound_expr (init
);
340 init
= TREE_VALUE (init
);
342 else if (TREE_CODE (init
) == TREE_LIST
343 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
345 error ("cannot initialize arrays using this syntax");
350 /* We get here with code like `int a (2);' */
352 if (TREE_CHAIN (init
) != NULL_TREE
)
354 pedwarn ("initializer list being treated as compound expression");
355 init
= build_compound_expr (init
);
358 init
= TREE_VALUE (init
);
362 /* End of special C++ code. */
364 /* Digest the specified initializer into an expression. */
365 value
= digest_init (type
, init
, (tree
*) 0);
367 /* Store the expression if valid; else report error. */
369 if (TREE_CODE (value
) == ERROR_MARK
)
371 /* Other code expects that initializers for objects of types that need
372 constructing never make it into DECL_INITIAL, and passes 'init' to
373 build_aggr_init without checking DECL_INITIAL. So just return. */
374 else if (TYPE_NEEDS_CONSTRUCTING (type
))
376 else if (TREE_STATIC (decl
)
377 && (! TREE_CONSTANT (value
)
378 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
381 /* Store the VALUE in DECL_INITIAL. If we're building a
382 statement-tree we will actually expand the initialization later
383 when we output this function. */
384 DECL_INITIAL (decl
) = value
;
389 /* Digest the parser output INIT as an initializer for type TYPE.
390 Return a C expression of type TYPE to represent the initial value.
392 If TAIL is nonzero, it points to a variable holding a list of elements
393 of which INIT is the first. We update the list stored there by
394 removing from the head all the elements that we use.
395 Normally this is only one; we use more than one element only if
396 TYPE is an aggregate and INIT is not a constructor. */
399 digest_init (tree type
, tree init
, tree
* tail
)
401 enum tree_code code
= TREE_CODE (type
);
402 tree element
= NULL_TREE
;
403 tree old_tail_contents
= NULL_TREE
;
404 /* Nonzero if INIT is a braced grouping. */
407 /* By default, assume we use one element from a list.
408 We correct this later in the sole case where it is not true. */
412 old_tail_contents
= *tail
;
413 *tail
= TREE_CHAIN (*tail
);
416 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
417 && TREE_VALUE (init
) == error_mark_node
))
418 return error_mark_node
;
420 if (TREE_CODE (init
) == ERROR_MARK
)
421 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
422 a template function. This gets substituted during instantiation. */
425 /* We must strip the outermost array type when completing the type,
426 because the its bounds might be incomplete at the moment. */
427 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
428 ? TREE_TYPE (type
) : type
, NULL_TREE
))
429 return error_mark_node
;
431 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
432 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
433 init
= TREE_OPERAND (init
, 0);
435 raw_constructor
= (TREE_CODE (init
) == CONSTRUCTOR
436 && TREE_HAS_CONSTRUCTOR (init
));
439 && CONSTRUCTOR_ELTS (init
) != 0
440 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
442 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
443 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
444 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
445 element
= TREE_OPERAND (element
, 0);
446 if (element
== error_mark_node
)
450 /* Initialization of an array of chars from a string constant
451 optionally enclosed in braces. */
453 if (code
== ARRAY_TYPE
)
457 if (TREE_CODE (init
) == TREE_LIST
)
459 error ("initializing array with parameter list");
460 return error_mark_node
;
463 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
464 if (char_type_p (typ1
)
465 && ((init
&& TREE_CODE (init
) == STRING_CST
)
466 || (element
&& TREE_CODE (element
) == STRING_CST
)))
468 tree string
= element
? element
: init
;
470 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
472 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
474 error ("char-array initialized from wide string");
475 return error_mark_node
;
477 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
479 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
481 error ("int-array initialized from non-wide string");
482 return error_mark_node
;
485 TREE_TYPE (string
) = type
;
486 if (TYPE_DOMAIN (type
) != 0
487 && TREE_CONSTANT (TYPE_SIZE (type
)))
490 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
491 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
492 /* In C it is ok to subtract 1 from the length of the string
493 because it's ok to ignore the terminating null char that is
494 counted in the length of the constant, but in C++ this would
496 if (size
< TREE_STRING_LENGTH (string
))
497 pedwarn ("initializer-string for array of chars is too long");
503 /* Handle scalar types, including conversions,
504 and signature pointers and references. */
506 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
507 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
508 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
509 || TYPE_PTRMEMFUNC_P (type
))
515 error ("initializer for scalar variable requires one element");
516 return error_mark_node
;
520 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
522 pedwarn ("braces around scalar initializer for `%T'", type
);
523 init
= CONSTRUCTOR_ELTS (init
);
524 if (TREE_CHAIN (init
))
525 pedwarn ("ignoring extra initializers for `%T'", type
);
526 init
= TREE_VALUE (init
);
529 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
530 "initialization", NULL_TREE
, 0);
533 /* Come here only for records and arrays (and unions with constructors). */
535 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
537 error ("variable-sized object of type `%T' may not be initialized",
539 return error_mark_node
;
542 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
544 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
545 && TREE_HAS_CONSTRUCTOR (init
))
547 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
549 return error_mark_node
;
551 else if (raw_constructor
)
552 return process_init_constructor (type
, init
, (tree
*)0);
553 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
554 || TYPE_NON_AGGREGATE_CLASS (type
))
555 /* These are never initialized from multiple constructor elements. */;
558 *tail
= old_tail_contents
;
559 return process_init_constructor (type
, 0, tail
);
562 if (code
!= ARRAY_TYPE
)
564 int flags
= LOOKUP_NORMAL
;
565 /* Initialization from { } is copy-initialization. */
567 flags
|= LOOKUP_ONLYCONVERTING
;
569 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
570 "initialization", NULL_TREE
, 0);
574 error ("invalid initializer");
575 return error_mark_node
;
578 /* Process a constructor for a variable of type TYPE.
579 The constructor elements may be specified either with INIT or with ELTS,
580 only one of which should be non-null.
582 If INIT is specified, it is a CONSTRUCTOR node which is specifically
583 and solely for initializing this datum.
585 If ELTS is specified, it is the address of a variable containing
586 a list of expressions. We take as many elements as we need
587 from the head of the list and update the list.
589 In the resulting constructor, TREE_CONSTANT is set if all elts are
590 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
591 constants that the assembler and linker can compute them. */
594 process_init_constructor (tree type
, tree init
, tree
* elts
)
597 /* List of the elements of the result constructor,
599 register tree members
= NULL
;
606 /* Make TAIL be the list of elements to use for the initialization,
607 no matter how the data was given to us. */
611 if (warn_missing_braces
)
612 warning ("aggregate has a partly bracketed initializer");
616 tail
= CONSTRUCTOR_ELTS (init
);
618 /* Gobble as many elements as needed, and make a constructor or initial value
619 for each element of this aggregate. Chain them together in result.
620 If there are too few, use 0 for each scalar ultimate component. */
622 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
627 if (TREE_CODE (type
) == ARRAY_TYPE
)
629 tree domain
= TYPE_DOMAIN (type
);
631 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
632 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
635 len
= -1; /* Take as many as there are */
639 /* Vectors are like simple fixed-size arrays. */
640 len
= TYPE_VECTOR_SUBPARTS (type
);
643 for (i
= 0; len
< 0 || i
< len
; i
++)
647 if (TREE_PURPOSE (tail
)
648 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
649 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
650 sorry ("non-trivial labeled initializers");
652 if (TREE_VALUE (tail
) != 0)
655 next1
= digest_init (TREE_TYPE (type
),
656 TREE_VALUE (tail
), &tail1
);
657 if (next1
== error_mark_node
)
660 (same_type_ignoring_top_level_qualifiers_p
661 (TREE_TYPE (type
), TREE_TYPE (next1
)),
663 my_friendly_assert (tail1
== 0
664 || TREE_CODE (tail1
) == TREE_LIST
, 319);
665 if (tail
== tail1
&& len
< 0)
667 error ("non-empty initializer for array of empty elements");
668 /* Just ignore what we were supposed to use. */
675 next1
= error_mark_node
;
676 tail
= TREE_CHAIN (tail
);
682 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
684 /* If this type needs constructors run for
685 default-initialization, we can't rely on the backend to do it
686 for us, so build up TARGET_EXPRs. If the type in question is
687 a class, just build one up; if it's an array, recurse. */
689 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
690 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
692 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
693 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
695 else if (! zero_init_p (TREE_TYPE (type
)))
696 next1
= build_zero_init (TREE_TYPE (type
),
698 /*static_storage_p=*/false);
700 /* The default zero-initialization is fine for us; don't
701 add anything to the CONSTRUCTOR. */
704 if (next1
== error_mark_node
)
706 else if (!TREE_CONSTANT (next1
))
708 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
710 members
= tree_cons (size_int (i
), next1
, members
);
713 else if (TREE_CODE (type
) == RECORD_TYPE
)
719 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
721 sorry ("initializer list for object of class with virtual base classes");
722 return error_mark_node
;
725 if (TYPE_BINFO_BASETYPES (type
))
727 sorry ("initializer list for object of class with base classes");
728 return error_mark_node
;
731 if (TYPE_POLYMORPHIC_P (type
))
733 sorry ("initializer list for object using virtual functions");
734 return error_mark_node
;
738 for (field
= TYPE_FIELDS (type
); field
;
739 field
= TREE_CHAIN (field
))
741 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
743 members
= tree_cons (field
, integer_zero_node
, members
);
747 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
752 if (TREE_PURPOSE (tail
)
753 && TREE_PURPOSE (tail
) != field
754 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
755 sorry ("non-trivial labeled initializers");
757 if (TREE_VALUE (tail
) != 0)
761 next1
= digest_init (TREE_TYPE (field
),
762 TREE_VALUE (tail
), &tail1
);
763 my_friendly_assert (tail1
== 0
764 || TREE_CODE (tail1
) == TREE_LIST
, 320);
769 next1
= error_mark_node
;
770 tail
= TREE_CHAIN (tail
);
773 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
775 /* If this type needs constructors run for
776 default-initialization, we can't rely on the backend to do it
777 for us, so build up TARGET_EXPRs. If the type in question is
778 a class, just build one up; if it's an array, recurse. */
780 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
781 next1
= build_functional_cast (TREE_TYPE (field
),
785 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
787 TREE_HAS_CONSTRUCTOR (next1
)
788 = TREE_HAS_CONSTRUCTOR (init
);
790 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
792 /* Warn when some struct elements are implicitly initialized. */
794 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
795 warning ("missing initializer for member `%D'", field
);
799 if (TREE_READONLY (field
))
800 error ("uninitialized const member `%D'", field
);
801 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
802 error ("member `%D' with uninitialized const fields",
804 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
805 error ("member `%D' is uninitialized reference", field
);
807 /* Warn when some struct elements are implicitly initialized
810 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
811 warning ("missing initializer for member `%D'", field
);
813 if (! zero_init_p (TREE_TYPE (field
)))
814 next1
= build_zero_init (TREE_TYPE (field
),
816 /*static_storage_p=*/false);
818 /* The default zero-initialization is fine for us; don't
819 add anything to the CONSTRUCTOR. */
823 if (next1
== error_mark_node
)
825 else if (!TREE_CONSTANT (next1
))
827 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
829 members
= tree_cons (field
, next1
, members
);
832 else if (TREE_CODE (type
) == UNION_TYPE
833 /* If the initializer was empty, use default zero initialization. */
836 register tree field
= TYPE_FIELDS (type
);
838 /* Find the first named field. ANSI decided in September 1990
839 that only named fields count here. */
840 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
841 field
= TREE_CHAIN (field
);
843 /* If this element specifies a field, initialize via that field. */
844 if (TREE_PURPOSE (tail
) != NULL_TREE
)
848 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
849 /* Handle the case of a call by build_c_cast. */
850 field
= TREE_PURPOSE (tail
), win
= 1;
851 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
852 error ("index value instead of field name in union initializer");
856 for (temp
= TYPE_FIELDS (type
);
858 temp
= TREE_CHAIN (temp
))
859 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
862 field
= temp
, win
= 1;
864 error ("no field `%D' in union being initialized",
865 TREE_PURPOSE (tail
));
868 TREE_VALUE (tail
) = error_mark_node
;
872 error ("union `%T' with no named members cannot be initialized",
874 TREE_VALUE (tail
) = error_mark_node
;
877 if (TREE_VALUE (tail
) != 0)
881 next1
= digest_init (TREE_TYPE (field
),
882 TREE_VALUE (tail
), &tail1
);
883 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
889 next1
= error_mark_node
;
890 tail
= TREE_CHAIN (tail
);
893 if (next1
== error_mark_node
)
895 else if (!TREE_CONSTANT (next1
))
897 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
899 members
= tree_cons (field
, next1
, members
);
902 /* If arguments were specified as a list, just remove the ones we used. */
905 /* If arguments were specified as a constructor,
906 complain unless we used all the elements of the constructor. */
908 pedwarn ("excess elements in aggregate initializer");
911 return error_mark_node
;
913 result
= build_constructor (type
, nreverse (members
));
914 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
915 complete_array_type (type
, result
, /*do_default=*/0);
917 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
918 if (allconstant
) TREE_CONSTANT (result
) = 1;
919 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
923 /* Given a structure or union value DATUM, construct and return
924 the structure or union component which results from narrowing
925 that value to the base specified in BASETYPE. For example, given the
931 class C : A, B { ... };
939 x.A::ii refers to the ii member of the L part of
940 the A part of the C object named by X. In this case,
941 DATUM would be x, and BASETYPE would be A.
943 I used to think that this was nonconformant, that the standard specified
944 that first we look up ii in A, then convert x to an L& and pull out the
945 ii part. But in fact, it does say that we convert x to an A&; A here
946 is known as the "naming class". (jason 2000-12-19)
948 BINFO_P points to a variable initialized either to NULL_TREE or to the
949 binfo for the specific base subobject we want to convert to. */
952 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
956 if (datum
== error_mark_node
)
957 return error_mark_node
;
961 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
963 if (!binfo
|| binfo
== error_mark_node
)
965 *binfo_p
= NULL_TREE
;
967 error_not_base_type (basetype
, TREE_TYPE (datum
));
968 return error_mark_node
;
972 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
975 /* Build a reference to an object specified by the C++ `->' operator.
976 Usually this just involves dereferencing the object, but if the
977 `->' operator is overloaded, then such overloads must be
978 performed until an object which does not have the `->' operator
979 overloaded is found. An error is reported when circular pointer
980 delegation is detected. */
983 build_x_arrow (tree expr
)
985 tree orig_expr
= expr
;
986 tree types_memoized
= NULL_TREE
;
987 tree type
= TREE_TYPE (expr
);
988 tree last_rval
= NULL_TREE
;
990 if (type
== error_mark_node
)
991 return error_mark_node
;
993 if (processing_template_decl
)
995 if (type_dependent_expression_p (expr
))
996 return build_min_nt (ARROW_EXPR
, expr
);
997 expr
= build_non_dependent_expr (expr
);
1000 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1002 expr
= convert_from_reference (expr
);
1003 type
= TREE_TYPE (expr
);
1006 if (IS_AGGR_TYPE (type
))
1008 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1009 NULL_TREE
, NULL_TREE
)))
1011 if (expr
== error_mark_node
)
1012 return error_mark_node
;
1014 if (value_member (TREE_TYPE (expr
), types_memoized
))
1016 error ("circular pointer delegation detected");
1017 return error_mark_node
;
1021 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1027 if (last_rval
== NULL_TREE
)
1029 error ("base operand of `->' has non-pointer type `%T'", type
);
1030 return error_mark_node
;
1033 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1034 last_rval
= convert_from_reference (last_rval
);
1037 last_rval
= decay_conversion (expr
);
1039 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1041 if (processing_template_decl
)
1042 return build_min (ARROW_EXPR
,
1043 TREE_TYPE (TREE_TYPE (last_rval
)),
1046 return build_indirect_ref (last_rval
, NULL
);
1050 error ("result of `operator->()' yields non-pointer result");
1052 error ("base operand of `->' is not a pointer");
1053 return error_mark_node
;
1056 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1057 already been checked out to be of aggregate type. */
1060 build_m_component_ref (tree datum
, tree component
)
1067 datum
= decay_conversion (datum
);
1069 if (datum
== error_mark_node
|| component
== error_mark_node
)
1070 return error_mark_node
;
1072 ptrmem_type
= TREE_TYPE (component
);
1073 if (!TYPE_PTRMEM_P (ptrmem_type
)
1074 && !TYPE_PTRMEMFUNC_P (ptrmem_type
))
1076 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1077 component
, ptrmem_type
);
1078 return error_mark_node
;
1081 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1082 if (! IS_AGGR_TYPE (objtype
))
1084 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1085 component
, datum
, objtype
);
1086 return error_mark_node
;
1089 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1090 binfo
= lookup_base (objtype
, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
),
1094 error ("member type `%T::' incompatible with object type `%T'",
1096 return error_mark_node
;
1098 else if (binfo
== error_mark_node
)
1099 return error_mark_node
;
1101 if (TYPE_PTRMEM_P (ptrmem_type
))
1103 /* Compute the type of the field, as described in [expr.ref].
1104 There's no such thing as a mutable pointer-to-member, so
1105 things are not as complex as they are for references to
1106 non-static data members. */
1107 type
= cp_build_qualified_type (type
,
1108 (cp_type_quals (type
)
1109 | cp_type_quals (TREE_TYPE (datum
))));
1111 datum
= build_base_path (PLUS_EXPR
, build_address (datum
), binfo
, 1);
1112 component
= cp_convert (ptrdiff_type_node
, component
);
1113 datum
= build (PLUS_EXPR
, build_pointer_type (type
), datum
, component
);
1114 return build_indirect_ref (datum
, 0);
1117 return build (OFFSET_REF
, type
, datum
, component
);
1120 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1123 build_functional_cast (tree exp
, tree parms
)
1125 /* This is either a call to a constructor,
1126 or a C cast in C++'s `functional' notation. */
1129 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1130 return error_mark_node
;
1132 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1134 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1135 /* Either an enum or an aggregate type. */
1136 type
= IDENTIFIER_TYPE_VALUE (exp
);
1139 type
= lookup_name (exp
, 1);
1140 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1142 error ("`%T' fails to be a typedef or built-in type", exp
);
1143 return error_mark_node
;
1145 type
= TREE_TYPE (type
);
1148 else if (TREE_CODE (exp
) == TYPE_DECL
)
1149 type
= TREE_TYPE (exp
);
1153 if (processing_template_decl
)
1154 return build_min (CAST_EXPR
, type
, parms
);
1156 if (! IS_AGGR_TYPE (type
))
1158 /* this must build a C cast */
1159 if (parms
== NULL_TREE
)
1160 parms
= integer_zero_node
;
1163 if (TREE_CHAIN (parms
) != NULL_TREE
)
1164 pedwarn ("initializer list being treated as compound expression");
1165 parms
= build_compound_expr (parms
);
1168 return build_c_cast (type
, parms
);
1171 /* Prepare to evaluate as a call to a constructor. If this expression
1172 is actually used, for example,
1174 return X (arg1, arg2, ...);
1176 then the slot being initialized will be filled in. */
1178 if (!complete_type_or_else (type
, NULL_TREE
))
1179 return error_mark_node
;
1180 if (abstract_virtuals_error (NULL_TREE
, type
))
1181 return error_mark_node
;
1183 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1184 return build_c_cast (type
, TREE_VALUE (parms
));
1186 /* We need to zero-initialize POD types. Let's do that for everything
1187 that doesn't need a constructor. */
1188 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1189 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1191 exp
= build_constructor (type
, NULL_TREE
);
1192 return get_target_expr (exp
);
1195 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1196 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1198 if (exp
== error_mark_node
)
1199 return error_mark_node
;
1201 return build_cplus_new (type
, exp
);
1205 /* Add new exception specifier SPEC, to the LIST we currently have.
1206 If it's already in LIST then do nothing.
1207 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1208 know what we're doing. */
1211 add_exception_specifier (tree list
, tree spec
, int complain
)
1216 int diag_type
= -1; /* none */
1218 if (spec
== error_mark_node
)
1221 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1223 /* [except.spec] 1, type in an exception specifier shall not be
1224 incomplete, or pointer or ref to incomplete other than pointer
1226 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1227 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1228 core
= TREE_TYPE (core
);
1231 else if (VOID_TYPE_P (core
))
1233 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1235 else if (processing_template_decl
)
1240 /* 15.4/1 says that types in an exception specifier must be complete,
1241 but it seems more reasonable to only require this on definitions
1242 and calls. So just give a pedwarn at this point; we will give an
1243 error later if we hit one of those two cases. */
1244 if (!COMPLETE_TYPE_P (complete_type (core
)))
1245 diag_type
= 2; /* pedwarn */
1252 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1253 if (same_type_p (TREE_VALUE (probe
), spec
))
1256 list
= tree_cons (NULL_TREE
, spec
, list
);
1259 diag_type
= 0; /* error */
1261 if (diag_type
>= 0 && complain
)
1262 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1267 /* Combine the two exceptions specifier lists LIST and ADD, and return
1271 merge_exception_specifiers (tree list
, tree add
)
1275 else if (!TREE_VALUE (list
))
1277 else if (!TREE_VALUE (add
))
1281 tree orig_list
= list
;
1283 for (; add
; add
= TREE_CHAIN (add
))
1285 tree spec
= TREE_VALUE (add
);
1288 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1289 if (same_type_p (TREE_VALUE (probe
), spec
))
1293 spec
= build_tree_list (NULL_TREE
, spec
);
1294 TREE_CHAIN (spec
) = list
;
1302 /* Subroutine of build_call. Ensure that each of the types in the
1303 exception specification is complete. Technically, 15.4/1 says that
1304 they need to be complete when we see a declaration of the function,
1305 but we should be able to get away with only requiring this when the
1306 function is defined or called. See also add_exception_specifier. */
1309 require_complete_eh_spec_types (tree fntype
, tree decl
)
1312 /* Don't complain about calls to op new. */
1313 if (decl
&& DECL_ARTIFICIAL (decl
))
1315 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1316 raises
= TREE_CHAIN (raises
))
1318 tree type
= TREE_VALUE (raises
);
1319 if (type
&& !COMPLETE_TYPE_P (type
))
1323 ("call to function `%D' which throws incomplete type `%#T'",
1326 error ("call to function which throws incomplete type `%#T'",