1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
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. */
188 cxx_incomplete_type_error (value
, type
)
194 /* Avoid duplicate error message. */
195 if (TREE_CODE (type
) == ERROR_MARK
)
198 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
199 || TREE_CODE (value
) == PARM_DECL
))
201 cp_error_at ("`%D' has incomplete type", value
);
205 /* We must print an error message. Be clever about what it says. */
207 switch (TREE_CODE (type
))
213 error ("invalid use of undefined type `%#T'", type
);
214 cp_error_at ("forward declaration of `%#T'", type
);
218 error ("invalid use of `%T'", type
);
222 if (TYPE_DOMAIN (type
))
224 type
= TREE_TYPE (type
);
227 error ("invalid use of array with unspecified bounds");
232 error ("invalid use of member (did you forget the `&' ?)");
235 case TEMPLATE_TYPE_PARM
:
236 error ("invalid use of template type parameter");
240 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
242 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
243 error ("address of overloaded function with no contextual type information");
244 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
245 error ("overloaded function with no contextual type information");
247 error ("insufficient contextual information to determine type");
256 /* Perform appropriate conversions on the initial value of a variable,
257 store it in the declaration DECL,
258 and print any error messages that are appropriate.
259 If the init is invalid, store an ERROR_MARK.
261 C++: Note that INIT might be a TREE_LIST, which would mean that it is
262 a base class initializer for some aggregate type, hopefully compatible
263 with DECL. If INIT is a single element, and DECL is an aggregate
264 type, we silently convert INIT into a TREE_LIST, allowing a constructor
267 If INIT is a TREE_LIST and there is no constructor, turn INIT
268 into a CONSTRUCTOR and use standard initialization techniques.
269 Perhaps a warning should be generated?
271 Returns value of initializer if initialization could not be
272 performed for static variable. In that case, caller must do
276 store_init_value (decl
, init
)
279 register tree value
, type
;
281 /* If variable's type was invalidly declared, just ignore it. */
283 type
= TREE_TYPE (decl
);
284 if (TREE_CODE (type
) == ERROR_MARK
)
288 /* This breaks arrays, and should not have any effect for other decls. */
289 /* Take care of C++ business up here. */
290 type
= TYPE_MAIN_VARIANT (type
);
293 if (IS_AGGR_TYPE (type
))
295 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
296 && TREE_CODE (init
) != CONSTRUCTOR
)
299 if (TREE_CODE (init
) == TREE_LIST
)
301 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
302 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
305 if (TREE_CODE (init
) == CONSTRUCTOR
)
309 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
310 if (CLASSTYPE_N_BASECLASSES (type
))
311 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl
);
312 if (CLASSTYPE_VTBL_PTR (type
))
313 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl
);
314 if (TYPE_NEEDS_CONSTRUCTING (type
))
316 cp_error_at ("initializer list construction invalid for `%D'", decl
);
317 error ("due to the presence of a constructor");
319 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
320 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
322 cp_error_at ("initializer list construction invalid for `%D'", decl
);
323 cp_error_at ("due to non-public access of member `%D'", field
);
325 for (field
= TYPE_METHODS (type
); field
; field
= TREE_CHAIN (field
))
326 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
328 cp_error_at ("initializer list construction invalid for `%D'", decl
);
329 cp_error_at ("due to non-public access of member `%D'", field
);
334 else if (TREE_CODE (init
) == TREE_LIST
335 && TREE_TYPE (init
) != unknown_type_node
)
337 if (TREE_CODE (decl
) == RESULT_DECL
)
339 if (TREE_CHAIN (init
))
341 warning ("comma expression used to initialize return value");
342 init
= build_compound_expr (init
);
345 init
= TREE_VALUE (init
);
347 else if (TREE_CODE (init
) == TREE_LIST
348 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
350 error ("cannot initialize arrays using this syntax");
355 /* We get here with code like `int a (2);' */
357 if (TREE_CHAIN (init
) != NULL_TREE
)
359 pedwarn ("initializer list being treated as compound expression");
360 init
= build_compound_expr (init
);
363 init
= TREE_VALUE (init
);
367 /* End of special C++ code. */
369 /* We might have already run this bracketed initializer through
370 digest_init. Don't do so again. */
371 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
)
373 && TYPE_MAIN_VARIANT (TREE_TYPE (init
)) == TYPE_MAIN_VARIANT (type
))
376 /* Digest the specified initializer into an expression. */
377 value
= digest_init (type
, init
, (tree
*) 0);
379 /* Store the expression if valid; else report error. */
381 if (TREE_CODE (value
) == ERROR_MARK
)
383 /* Other code expects that initializers for objects of types that need
384 constructing never make it into DECL_INITIAL, and passes 'init' to
385 build_aggr_init without checking DECL_INITIAL. So just return. */
386 else if (TYPE_NEEDS_CONSTRUCTING (type
))
388 else if (TREE_STATIC (decl
)
389 && (! TREE_CONSTANT (value
)
390 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
392 /* A STATIC PUBLIC int variable doesn't have to be
393 run time inited when doing pic. (mrs) */
394 /* Since ctors and dtors are the only things that can
395 reference vtables, and they are always written down
396 the vtable definition, we can leave the
397 vtables in initialized data space.
398 However, other initialized data cannot be initialized
399 this way. Instead a global file-level initializer
401 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
406 #if 0 /* No, that's C. jason 9/19/94 */
409 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
411 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
412 pedwarn ("ISO C++ forbids non-constant aggregate initializer expressions");
417 /* Store the VALUE in DECL_INITIAL. If we're building a
418 statement-tree we will actually expand the initialization later
419 when we output this function. */
420 DECL_INITIAL (decl
) = value
;
424 /* Digest the parser output INIT as an initializer for type TYPE.
425 Return a C expression of type TYPE to represent the initial value.
427 If TAIL is nonzero, it points to a variable holding a list of elements
428 of which INIT is the first. We update the list stored there by
429 removing from the head all the elements that we use.
430 Normally this is only one; we use more than one element only if
431 TYPE is an aggregate and INIT is not a constructor. */
434 digest_init (type
, init
, tail
)
435 tree type
, init
, *tail
;
437 enum tree_code code
= TREE_CODE (type
);
438 tree element
= NULL_TREE
;
439 tree old_tail_contents
= NULL_TREE
;
440 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
441 tree node which has no TREE_TYPE. */
444 /* By default, assume we use one element from a list.
445 We correct this later in the sole case where it is not true. */
449 old_tail_contents
= *tail
;
450 *tail
= TREE_CHAIN (*tail
);
453 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
454 && TREE_VALUE (init
) == error_mark_node
))
455 return error_mark_node
;
457 if (TREE_CODE (init
) == ERROR_MARK
)
458 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
459 a template function. This gets substituted during instantiation. */
462 /* We must strip the outermost array type when completing the type,
463 because the its bounds might be incomplete at the moment. */
464 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
465 ? TREE_TYPE (type
) : type
, NULL_TREE
))
466 return error_mark_node
;
468 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
469 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
470 init
= TREE_OPERAND (init
, 0);
472 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == type
)
475 raw_constructor
= TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == 0;
478 && CONSTRUCTOR_ELTS (init
) != 0
479 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
481 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
482 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
483 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
484 element
= TREE_OPERAND (element
, 0);
485 if (element
== error_mark_node
)
489 /* Initialization of an array of chars from a string constant
490 optionally enclosed in braces. */
492 if (code
== ARRAY_TYPE
)
496 if (TREE_CODE (init
) == TREE_LIST
)
498 error ("initializing array with parameter list");
499 return error_mark_node
;
502 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
503 if (char_type_p (typ1
)
504 && ((init
&& TREE_CODE (init
) == STRING_CST
)
505 || (element
&& TREE_CODE (element
) == STRING_CST
)))
507 tree string
= element
? element
: init
;
509 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
511 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
513 error ("char-array initialized from wide string");
514 return error_mark_node
;
516 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
518 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
520 error ("int-array initialized from non-wide string");
521 return error_mark_node
;
524 TREE_TYPE (string
) = type
;
525 if (TYPE_DOMAIN (type
) != 0
526 && TREE_CONSTANT (TYPE_SIZE (type
)))
529 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
530 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
531 /* In C it is ok to subtract 1 from the length of the string
532 because it's ok to ignore the terminating null char that is
533 counted in the length of the constant, but in C++ this would
535 if (size
< TREE_STRING_LENGTH (string
))
536 pedwarn ("initializer-string for array of chars is too long");
542 /* Handle scalar types, including conversions,
543 and signature pointers and references. */
545 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
546 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
547 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
548 || TYPE_PTRMEMFUNC_P (type
))
554 error ("initializer for scalar variable requires one element");
555 return error_mark_node
;
559 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
561 pedwarn ("braces around scalar initializer for `%T'", type
);
562 init
= CONSTRUCTOR_ELTS (init
);
563 if (TREE_CHAIN (init
))
564 pedwarn ("ignoring extra initializers for `%T'", type
);
565 init
= TREE_VALUE (init
);
568 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
569 "initialization", NULL_TREE
, 0);
572 /* Come here only for records and arrays (and unions with constructors). */
574 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
576 error ("variable-sized object of type `%T' may not be initialized",
578 return error_mark_node
;
581 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
583 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
584 && TREE_HAS_CONSTRUCTOR (init
))
586 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
588 return error_mark_node
;
590 else if (raw_constructor
)
591 return process_init_constructor (type
, init
, (tree
*)0);
592 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
593 || TYPE_NON_AGGREGATE_CLASS (type
))
594 /* These are never initialized from multiple constructor elements. */;
597 *tail
= old_tail_contents
;
598 return process_init_constructor (type
, 0, tail
);
601 if (code
!= ARRAY_TYPE
)
603 int flags
= LOOKUP_NORMAL
;
604 /* Initialization from { } is copy-initialization. */
606 flags
|= LOOKUP_ONLYCONVERTING
;
608 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
609 "initialization", NULL_TREE
, 0);
613 error ("invalid initializer");
614 return error_mark_node
;
617 /* Process a constructor for a variable of type TYPE.
618 The constructor elements may be specified either with INIT or with ELTS,
619 only one of which should be non-null.
621 If INIT is specified, it is a CONSTRUCTOR node which is specifically
622 and solely for initializing this datum.
624 If ELTS is specified, it is the address of a variable containing
625 a list of expressions. We take as many elements as we need
626 from the head of the list and update the list.
628 In the resulting constructor, TREE_CONSTANT is set if all elts are
629 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
630 constants that the assembler and linker can compute them. */
633 process_init_constructor (type
, init
, elts
)
634 tree type
, init
, *elts
;
637 /* List of the elements of the result constructor,
639 register tree members
= NULL
;
646 /* Make TAIL be the list of elements to use for the initialization,
647 no matter how the data was given to us. */
651 if (warn_missing_braces
)
652 warning ("aggregate has a partly bracketed initializer");
656 tail
= CONSTRUCTOR_ELTS (init
);
658 /* Gobble as many elements as needed, and make a constructor or initial value
659 for each element of this aggregate. Chain them together in result.
660 If there are too few, use 0 for each scalar ultimate component. */
662 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
667 if (TREE_CODE (type
) == ARRAY_TYPE
)
669 tree domain
= TYPE_DOMAIN (type
);
671 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
672 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
675 len
= -1; /* Take as many as there are */
679 /* Vectors are like simple fixed-size arrays. */
680 len
= TYPE_VECTOR_SUBPARTS (type
);
683 for (i
= 0; len
< 0 || i
< len
; i
++)
687 if (TREE_PURPOSE (tail
)
688 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
689 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
690 sorry ("non-trivial labeled initializers");
692 if (TREE_VALUE (tail
) != 0)
695 next1
= digest_init (TREE_TYPE (type
),
696 TREE_VALUE (tail
), &tail1
);
697 if (next1
== error_mark_node
)
700 (same_type_ignoring_top_level_qualifiers_p
701 (TREE_TYPE (type
), TREE_TYPE (next1
)),
703 my_friendly_assert (tail1
== 0
704 || TREE_CODE (tail1
) == TREE_LIST
, 319);
705 if (tail
== tail1
&& len
< 0)
707 error ("non-empty initializer for array of empty elements");
708 /* Just ignore what we were supposed to use. */
715 next1
= error_mark_node
;
716 tail
= TREE_CHAIN (tail
);
722 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
724 /* If this type needs constructors run for
725 default-initialization, we can't rely on the backend to do it
726 for us, so build up TARGET_EXPRs. If the type in question is
727 a class, just build one up; if it's an array, recurse. */
729 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
730 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
732 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
733 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
736 /* The default zero-initialization is fine for us; don't
737 add anything to the CONSTRUCTOR. */
740 if (next1
== error_mark_node
)
742 else if (!TREE_CONSTANT (next1
))
744 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
746 members
= tree_cons (size_int (i
), next1
, members
);
749 else if (TREE_CODE (type
) == RECORD_TYPE
)
755 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
757 sorry ("initializer list for object of class with virtual base classes");
758 return error_mark_node
;
761 if (TYPE_BINFO_BASETYPES (type
))
763 sorry ("initializer list for object of class with base classes");
764 return error_mark_node
;
767 if (TYPE_POLYMORPHIC_P (type
))
769 sorry ("initializer list for object using virtual functions");
770 return error_mark_node
;
774 for (field
= TYPE_FIELDS (type
); field
;
775 field
= TREE_CHAIN (field
))
777 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
779 members
= tree_cons (field
, integer_zero_node
, members
);
783 if (TREE_CODE (field
) != FIELD_DECL
)
788 if (TREE_PURPOSE (tail
)
789 && TREE_PURPOSE (tail
) != field
790 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
791 sorry ("non-trivial labeled initializers");
793 if (TREE_VALUE (tail
) != 0)
797 next1
= digest_init (TREE_TYPE (field
),
798 TREE_VALUE (tail
), &tail1
);
799 my_friendly_assert (tail1
== 0
800 || TREE_CODE (tail1
) == TREE_LIST
, 320);
805 next1
= error_mark_node
;
806 tail
= TREE_CHAIN (tail
);
809 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
811 /* If this type needs constructors run for
812 default-initialization, we can't rely on the backend to do it
813 for us, so build up TARGET_EXPRs. If the type in question is
814 a class, just build one up; if it's an array, recurse. */
816 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
817 next1
= build_functional_cast (TREE_TYPE (field
),
821 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
824 TREE_HAS_CONSTRUCTOR (next1
)
825 = TREE_HAS_CONSTRUCTOR (init
);
827 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
829 /* Warn when some struct elements are implicitly initialized. */
831 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
832 warning ("missing initializer for member `%D'", field
);
836 if (TREE_READONLY (field
))
837 error ("uninitialized const member `%D'", field
);
838 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field
))
839 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
840 error ("member `%D' with uninitialized const fields",
842 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
843 error ("member `%D' is uninitialized reference", field
);
845 /* Warn when some struct elements are implicitly initialized
848 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
849 warning ("missing initializer for member `%D'", field
);
851 /* The default zero-initialization is fine for us; don't
852 add anything to the CONSTRUCTOR. */
856 if (next1
== error_mark_node
)
858 else if (!TREE_CONSTANT (next1
))
860 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
862 members
= tree_cons (field
, next1
, members
);
865 else if (TREE_CODE (type
) == UNION_TYPE
866 /* If the initializer was empty, use default zero initialization. */
869 register tree field
= TYPE_FIELDS (type
);
871 /* Find the first named field. ANSI decided in September 1990
872 that only named fields count here. */
873 while (field
&& (DECL_NAME (field
) == 0
874 || TREE_CODE (field
) != FIELD_DECL
))
875 field
= TREE_CHAIN (field
);
877 /* If this element specifies a field, initialize via that field. */
878 if (TREE_PURPOSE (tail
) != NULL_TREE
)
882 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
883 /* Handle the case of a call by build_c_cast. */
884 field
= TREE_PURPOSE (tail
), win
= 1;
885 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
886 error ("index value instead of field name in union initializer");
890 for (temp
= TYPE_FIELDS (type
);
892 temp
= TREE_CHAIN (temp
))
893 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
896 field
= temp
, win
= 1;
898 error ("no field `%D' in union being initialized",
899 TREE_PURPOSE (tail
));
902 TREE_VALUE (tail
) = error_mark_node
;
906 error ("union `%T' with no named members cannot be initialized",
908 TREE_VALUE (tail
) = error_mark_node
;
911 if (TREE_VALUE (tail
) != 0)
915 next1
= digest_init (TREE_TYPE (field
),
916 TREE_VALUE (tail
), &tail1
);
917 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
923 next1
= error_mark_node
;
924 tail
= TREE_CHAIN (tail
);
927 if (next1
== error_mark_node
)
929 else if (!TREE_CONSTANT (next1
))
931 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
933 members
= tree_cons (field
, next1
, members
);
936 /* If arguments were specified as a list, just remove the ones we used. */
939 /* If arguments were specified as a constructor,
940 complain unless we used all the elements of the constructor. */
942 pedwarn ("excess elements in aggregate initializer");
945 return error_mark_node
;
947 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
949 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
950 if (allconstant
) TREE_CONSTANT (result
) = 1;
951 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
955 /* Given a structure or union value DATUM, construct and return
956 the structure or union component which results from narrowing
957 that value to the base specified in BASETYPE. For example, given the
963 class C : A, B { ... };
971 x.A::ii refers to the ii member of the L part of
972 the A part of the C object named by X. In this case,
973 DATUM would be x, and BASETYPE would be A.
975 I used to think that this was nonconformant, that the standard specified
976 that first we look up ii in A, then convert x to an L& and pull out the
977 ii part. But in fact, it does say that we convert x to an A&; A here
978 is known as the "naming class". (jason 2000-12-19)
980 BINFO_P points to a variable initialized either to NULL_TREE or to the
981 binfo for the specific base subobject we want to convert to. */
984 build_scoped_ref (datum
, basetype
, binfo_p
)
991 if (datum
== error_mark_node
)
992 return error_mark_node
;
996 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
998 if (!binfo
|| binfo
== error_mark_node
)
1000 *binfo_p
= NULL_TREE
;
1002 error_not_base_type (basetype
, TREE_TYPE (datum
));
1003 return error_mark_node
;
1007 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1010 /* Build a reference to an object specified by the C++ `->' operator.
1011 Usually this just involves dereferencing the object, but if the
1012 `->' operator is overloaded, then such overloads must be
1013 performed until an object which does not have the `->' operator
1014 overloaded is found. An error is reported when circular pointer
1015 delegation is detected. */
1018 build_x_arrow (datum
)
1021 tree types_memoized
= NULL_TREE
;
1022 register tree rval
= datum
;
1023 tree type
= TREE_TYPE (rval
);
1024 tree last_rval
= NULL_TREE
;
1026 if (type
== error_mark_node
)
1027 return error_mark_node
;
1029 if (processing_template_decl
)
1030 return build_min_nt (ARROW_EXPR
, rval
);
1032 if (TREE_CODE (rval
) == OFFSET_REF
)
1034 rval
= resolve_offset_ref (datum
);
1035 type
= TREE_TYPE (rval
);
1038 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1040 rval
= convert_from_reference (rval
);
1041 type
= TREE_TYPE (rval
);
1044 if (IS_AGGR_TYPE (type
))
1046 while ((rval
= build_opfncall (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1047 NULL_TREE
, NULL_TREE
)))
1049 if (rval
== error_mark_node
)
1050 return error_mark_node
;
1052 if (value_member (TREE_TYPE (rval
), types_memoized
))
1054 error ("circular pointer delegation detected");
1055 return error_mark_node
;
1059 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1065 if (last_rval
== NULL_TREE
)
1067 error ("base operand of `->' has non-pointer type `%T'", type
);
1068 return error_mark_node
;
1071 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1072 last_rval
= convert_from_reference (last_rval
);
1075 last_rval
= default_conversion (rval
);
1077 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1078 return build_indirect_ref (last_rval
, NULL
);
1081 error ("result of `operator->()' yields non-pointer result");
1083 error ("base operand of `->' is not a pointer");
1084 return error_mark_node
;
1087 /* Make an expression to refer to the COMPONENT field of
1088 structure or union value DATUM. COMPONENT is an arbitrary
1089 expression. DATUM has not already been checked out to be of
1092 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1093 return an object of member type to a method of the current class,
1094 but there is not yet enough typing information to know which one.
1095 As a special case, if there is only one method by that name,
1096 it is returned. Otherwise we return an expression which other
1097 routines will have to know how to deal with later. */
1100 build_m_component_ref (datum
, component
)
1101 tree datum
, component
;
1109 if (processing_template_decl
)
1110 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1112 datum
= decay_conversion (datum
);
1114 if (datum
== error_mark_node
|| component
== error_mark_node
)
1115 return error_mark_node
;
1117 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1119 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1121 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1124 else if (TYPE_PTRMEM_P (TREE_TYPE (component
)))
1126 type
= TREE_TYPE (TREE_TYPE (component
));
1127 field_type
= TREE_TYPE (type
);
1129 /* Compute the type of the field, as described in [expr.ref]. */
1130 type_quals
= TYPE_UNQUALIFIED
;
1131 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1132 /* The standard says that the type of the result should be the
1133 type referred to by the reference. But for now, at least,
1134 we do the conversion from reference type later. */
1138 type_quals
= (cp_type_quals (field_type
)
1139 | cp_type_quals (TREE_TYPE (datum
)));
1141 /* There's no such thing as a mutable pointer-to-member, so
1142 we don't need to deal with that here like we do in
1143 build_component_ref. */
1144 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1149 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1150 component
, TREE_TYPE (component
));
1151 return error_mark_node
;
1154 if (! IS_AGGR_TYPE (objtype
))
1156 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1157 component
, datum
, objtype
);
1158 return error_mark_node
;
1161 binfo
= lookup_base (objtype
, TYPE_METHOD_BASETYPE (type
),
1165 error ("member type `%T::' incompatible with object type `%T'",
1166 TYPE_METHOD_BASETYPE (type
), objtype
);
1167 return error_mark_node
;
1169 else if (binfo
== error_mark_node
)
1170 return error_mark_node
;
1172 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1173 if (TREE_CODE (type
) == OFFSET_TYPE
)
1174 component
= resolve_offset_ref (component
);
1178 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1181 build_functional_cast (exp
, parms
)
1185 /* This is either a call to a constructor,
1186 or a C cast in C++'s `functional' notation. */
1189 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1190 return error_mark_node
;
1192 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1194 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1195 /* Either an enum or an aggregate type. */
1196 type
= IDENTIFIER_TYPE_VALUE (exp
);
1199 type
= lookup_name (exp
, 1);
1200 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1202 error ("`%T' fails to be a typedef or built-in type", exp
);
1203 return error_mark_node
;
1205 type
= TREE_TYPE (type
);
1208 else if (TREE_CODE (exp
) == TYPE_DECL
)
1209 type
= TREE_TYPE (exp
);
1213 if (processing_template_decl
)
1214 return build_min (CAST_EXPR
, type
, parms
);
1216 if (! IS_AGGR_TYPE (type
))
1218 /* this must build a C cast */
1219 if (parms
== NULL_TREE
)
1220 parms
= integer_zero_node
;
1223 if (TREE_CHAIN (parms
) != NULL_TREE
)
1224 pedwarn ("initializer list being treated as compound expression");
1225 parms
= build_compound_expr (parms
);
1228 return build_c_cast (type
, parms
);
1231 /* Prepare to evaluate as a call to a constructor. If this expression
1232 is actually used, for example,
1234 return X (arg1, arg2, ...);
1236 then the slot being initialized will be filled in. */
1238 if (!complete_type_or_else (type
, NULL_TREE
))
1239 return error_mark_node
;
1240 if (abstract_virtuals_error (NULL_TREE
, type
))
1241 return error_mark_node
;
1243 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1244 return build_c_cast (type
, TREE_VALUE (parms
));
1246 /* We need to zero-initialize POD types. Let's do that for everything
1247 that doesn't need a constructor. */
1248 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1249 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1251 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1252 return get_target_expr (exp
);
1255 exp
= build_method_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1256 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1258 if (exp
== error_mark_node
)
1259 return error_mark_node
;
1261 return build_cplus_new (type
, exp
);
1265 /* Complain about defining new types in inappropriate places. We give an
1266 exception for C-style casts, to accommodate GNU C stylings. */
1269 check_for_new_type (string
, inptree
)
1271 flagged_type_tree inptree
;
1273 if (inptree
.new_type_flag
1274 && (pedantic
|| strcmp (string
, "cast") != 0))
1275 pedwarn ("ISO C++ forbids defining types within %s", string
);
1278 /* Add new exception specifier SPEC, to the LIST we currently have.
1279 If it's already in LIST then do nothing.
1280 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1281 know what we're doing. */
1284 add_exception_specifier (list
, spec
, complain
)
1292 if (spec
== error_mark_node
)
1295 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1297 /* [except.spec] 1, type in an exception specifier shall not be
1298 incomplete, or pointer or ref to incomplete other than pointer
1300 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1301 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1302 core
= TREE_TYPE (core
);
1305 else if (VOID_TYPE_P (core
))
1307 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1309 else if (processing_template_decl
)
1312 ok
= COMPLETE_TYPE_P (complete_type (core
));
1318 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1319 if (same_type_p (TREE_VALUE (probe
), spec
))
1323 spec
= build_tree_list (NULL_TREE
, spec
);
1324 TREE_CHAIN (spec
) = list
;
1329 cxx_incomplete_type_error (NULL_TREE
, core
);
1333 /* Combine the two exceptions specifier lists LIST and ADD, and return
1337 merge_exception_specifiers (list
, add
)
1342 else if (!TREE_VALUE (list
))
1344 else if (!TREE_VALUE (add
))
1348 tree orig_list
= list
;
1350 for (; add
; add
= TREE_CHAIN (add
))
1352 tree spec
= TREE_VALUE (add
);
1355 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1356 if (same_type_p (TREE_VALUE (probe
), spec
))
1360 spec
= build_tree_list (NULL_TREE
, spec
);
1361 TREE_CHAIN (spec
) = list
;