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). */
42 static tree process_init_constructor
PARAMS ((tree
, tree
, tree
*));
44 /* Print an error message stemming from an attempt to use
45 BASETYPE as a base class for TYPE. */
48 error_not_base_type (basetype
, type
)
51 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
52 basetype
= DECL_CONTEXT (basetype
);
53 cp_error ("type `%T' is not a base type for type `%T'", basetype
, type
);
54 return error_mark_node
;
58 binfo_or_else (parent_or_type
, type
)
59 tree parent_or_type
, type
;
62 if (TYPE_MAIN_VARIANT (parent_or_type
) == TYPE_MAIN_VARIANT (type
))
63 return TYPE_BINFO (parent_or_type
);
64 if ((binfo
= get_binfo (parent_or_type
, TYPE_MAIN_VARIANT (type
), 0)))
66 if (binfo
== error_mark_node
)
70 error_not_base_type (parent_or_type
, type
);
74 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
75 value may not be changed thereafter. Thus, we emit hard errors for these,
76 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
77 example, conversions to references.) */
80 readonly_error (arg
, string
, soft
)
86 void (*fn
) PARAMS ((const char *, ...));
93 if (TREE_CODE (arg
) == COMPONENT_REF
)
95 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
96 fmt
= "%s of data-member `%D' in read-only structure";
98 fmt
= "%s of read-only data-member `%D'";
99 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
101 else if (TREE_CODE (arg
) == VAR_DECL
)
103 if (DECL_LANG_SPECIFIC (arg
)
104 && DECL_IN_AGGR_P (arg
)
105 && !TREE_STATIC (arg
))
106 fmt
= "%s of constant field `%D'";
108 fmt
= "%s of read-only variable `%D'";
109 (*fn
) (fmt
, string
, arg
);
111 else if (TREE_CODE (arg
) == PARM_DECL
)
112 (*fn
) ("%s of read-only parameter `%D'", string
, arg
);
113 else if (TREE_CODE (arg
) == INDIRECT_REF
114 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
115 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
116 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
117 (*fn
) ("%s of read-only reference `%D'", string
, TREE_OPERAND (arg
, 0));
118 else if (TREE_CODE (arg
) == RESULT_DECL
)
119 (*fn
) ("%s of read-only named return value `%D'", string
, arg
);
120 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
121 (*fn
) ("%s of function `%D'", string
, arg
);
123 (*fn
) ("%s of read-only location", string
);
126 /* If TYPE has abstract virtual functions, issue an error about trying
127 to create an object of that type. DECL is the object declared, or
128 NULL_TREE if the declaration is unavailable. Returns 1 if an error
129 occurred; zero if all was well. */
132 abstract_virtuals_error (decl
, type
)
139 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
142 u
= CLASSTYPE_PURE_VIRTUALS (type
);
145 if (TREE_CODE (decl
) == RESULT_DECL
)
148 if (TREE_CODE (decl
) == VAR_DECL
)
149 cp_error ("cannot declare variable `%D' to be of type `%T'",
151 else if (TREE_CODE (decl
) == PARM_DECL
)
152 cp_error ("cannot declare parameter `%D' to be of type `%T'",
154 else if (TREE_CODE (decl
) == FIELD_DECL
)
155 cp_error ("cannot declare field `%D' to be of type `%T'",
157 else if (TREE_CODE (decl
) == FUNCTION_DECL
158 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
159 cp_error ("invalid return type for member function `%#D'", decl
);
160 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
161 cp_error ("invalid return type for function `%#D'", decl
);
164 cp_error ("cannot allocate an object of type `%T'", type
);
166 /* Only go through this once. */
167 if (TREE_PURPOSE (u
) == NULL_TREE
)
169 TREE_PURPOSE (u
) = error_mark_node
;
171 error (" because the following virtual functions are abstract:");
172 for (tu
= u
; tu
; tu
= TREE_CHAIN (tu
))
173 cp_error_at ("\t%#D", TREE_VALUE (tu
));
176 cp_error (" since type `%T' has abstract virtual functions", type
);
181 /* Print an error message for invalid use of an incomplete type.
182 VALUE is the expression that was used (or 0 if that isn't known)
183 and TYPE is the type that was invalid. */
186 incomplete_type_error (value
, type
)
192 /* Avoid duplicate error message. */
193 if (TREE_CODE (type
) == ERROR_MARK
)
196 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
197 || TREE_CODE (value
) == PARM_DECL
))
199 cp_error_at ("`%D' has incomplete type", value
);
203 /* We must print an error message. Be clever about what it says. */
205 switch (TREE_CODE (type
))
211 cp_error ("invalid use of undefined type `%#T'", type
);
212 cp_error_at ("forward declaration of `%#T'", type
);
216 cp_error ("invalid use of `%T'", type
);
220 if (TYPE_DOMAIN (type
))
222 type
= TREE_TYPE (type
);
225 cp_error ("invalid use of array with unspecified bounds");
230 cp_error ("invalid use of member (did you forget the `&' ?)");
233 case TEMPLATE_TYPE_PARM
:
234 cp_error ("invalid use of template type parameter");
238 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
240 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
241 cp_error ("address of overloaded function with no contextual type information");
242 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
243 cp_error ("overloaded function with no contextual type information");
245 cp_error ("insufficient contextual information to determine type");
249 my_friendly_abort (108);
253 /* This is a wrapper around fancy_abort, as used in the back end and
254 other front ends. It will also report the magic number assigned to
255 this particular abort. That is for backward compatibility with the
256 old C++ abort handler, which would just report the magic number. */
258 friendly_abort (where
, file
, line
, func
)
264 if (errorcount
> 0 || sorrycount
> 0)
268 error ("Internal error #%d.", where
);
270 /* Uncount this error, so internal_error will do the right thing. */
274 fancy_abort (file
, line
, func
);
278 /* Perform appropriate conversions on the initial value of a variable,
279 store it in the declaration DECL,
280 and print any error messages that are appropriate.
281 If the init is invalid, store an ERROR_MARK.
283 C++: Note that INIT might be a TREE_LIST, which would mean that it is
284 a base class initializer for some aggregate type, hopefully compatible
285 with DECL. If INIT is a single element, and DECL is an aggregate
286 type, we silently convert INIT into a TREE_LIST, allowing a constructor
289 If INIT is a TREE_LIST and there is no constructor, turn INIT
290 into a CONSTRUCTOR and use standard initialization techniques.
291 Perhaps a warning should be generated?
293 Returns value of initializer if initialization could not be
294 performed for static variable. In that case, caller must do
298 store_init_value (decl
, init
)
301 register tree value
, type
;
303 /* If variable's type was invalidly declared, just ignore it. */
305 type
= TREE_TYPE (decl
);
306 if (TREE_CODE (type
) == ERROR_MARK
)
310 /* This breaks arrays, and should not have any effect for other decls. */
311 /* Take care of C++ business up here. */
312 type
= TYPE_MAIN_VARIANT (type
);
315 if (IS_AGGR_TYPE (type
))
317 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
318 && TREE_CODE (init
) != CONSTRUCTOR
)
319 my_friendly_abort (109);
321 if (TREE_CODE (init
) == TREE_LIST
)
323 cp_error ("constructor syntax used, but no constructor declared for type `%T'", type
);
324 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
327 if (TREE_CODE (init
) == CONSTRUCTOR
)
331 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
332 if (CLASSTYPE_N_BASECLASSES (type
))
333 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl
);
334 if (CLASSTYPE_VTBL_PTR (type
))
335 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl
);
336 if (TYPE_NEEDS_CONSTRUCTING (type
))
338 cp_error_at ("initializer list construction invalid for `%D'", decl
);
339 error ("due to the presence of a constructor");
341 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
342 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
344 cp_error_at ("initializer list construction invalid for `%D'", decl
);
345 cp_error_at ("due to non-public access of member `%D'", field
);
347 for (field
= TYPE_METHODS (type
); field
; field
= TREE_CHAIN (field
))
348 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
350 cp_error_at ("initializer list construction invalid for `%D'", decl
);
351 cp_error_at ("due to non-public access of member `%D'", field
);
356 else if (TREE_CODE (init
) == TREE_LIST
357 && TREE_TYPE (init
) != unknown_type_node
)
359 if (TREE_CODE (decl
) == RESULT_DECL
)
361 if (TREE_CHAIN (init
))
363 warning ("comma expression used to initialize return value");
364 init
= build_compound_expr (init
);
367 init
= TREE_VALUE (init
);
369 else if (TREE_CODE (init
) == TREE_LIST
370 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
372 error ("cannot initialize arrays using this syntax");
377 /* We get here with code like `int a (2);' */
379 if (TREE_CHAIN (init
) != NULL_TREE
)
381 pedwarn ("initializer list being treated as compound expression");
382 init
= build_compound_expr (init
);
385 init
= TREE_VALUE (init
);
389 /* End of special C++ code. */
391 /* Digest the specified initializer into an expression. */
393 value
= digest_init (type
, init
, (tree
*) 0);
395 /* Store the expression if valid; else report error. */
397 if (TREE_CODE (value
) == ERROR_MARK
)
399 /* Other code expects that initializers for objects of types that need
400 constructing never make it into DECL_INITIAL, and passes 'init' to
401 build_aggr_init without checking DECL_INITIAL. So just return. */
402 else if (TYPE_NEEDS_CONSTRUCTING (type
))
404 else if (TREE_STATIC (decl
)
405 && (! TREE_CONSTANT (value
)
406 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
408 /* A STATIC PUBLIC int variable doesn't have to be
409 run time inited when doing pic. (mrs) */
410 /* Since ctors and dtors are the only things that can
411 reference vtables, and they are always written down
412 the vtable definition, we can leave the
413 vtables in initialized data space.
414 However, other initialized data cannot be initialized
415 this way. Instead a global file-level initializer
417 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
422 #if 0 /* No, that's C. jason 9/19/94 */
425 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
427 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
428 pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
433 /* Store the VALUE in DECL_INITIAL. If we're building a
434 statement-tree we will actually expand the initialization later
435 when we output this function. */
436 DECL_INITIAL (decl
) = value
;
440 /* Digest the parser output INIT as an initializer for type TYPE.
441 Return a C expression of type TYPE to represent the initial value.
443 If TAIL is nonzero, it points to a variable holding a list of elements
444 of which INIT is the first. We update the list stored there by
445 removing from the head all the elements that we use.
446 Normally this is only one; we use more than one element only if
447 TYPE is an aggregate and INIT is not a constructor. */
450 digest_init (type
, init
, tail
)
451 tree type
, init
, *tail
;
453 enum tree_code code
= TREE_CODE (type
);
454 tree element
= NULL_TREE
;
455 tree old_tail_contents
= NULL_TREE
;
456 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
457 tree node which has no TREE_TYPE. */
460 /* By default, assume we use one element from a list.
461 We correct this later in the sole case where it is not true. */
465 old_tail_contents
= *tail
;
466 *tail
= TREE_CHAIN (*tail
);
469 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
470 && TREE_VALUE (init
) == error_mark_node
))
471 return error_mark_node
;
473 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
474 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
475 init
= TREE_OPERAND (init
, 0);
477 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == type
)
480 raw_constructor
= TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == 0;
483 && CONSTRUCTOR_ELTS (init
) != 0
484 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
486 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
487 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
488 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
489 element
= TREE_OPERAND (element
, 0);
490 if (element
== error_mark_node
)
494 /* Initialization of an array of chars from a string constant
495 optionally enclosed in braces. */
497 if (code
== ARRAY_TYPE
)
501 if (TREE_CODE (init
) == TREE_LIST
)
503 error ("initializing array with parameter list");
504 return error_mark_node
;
507 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
508 if (char_type_p (typ1
)
509 && ((init
&& TREE_CODE (init
) == STRING_CST
)
510 || (element
&& TREE_CODE (element
) == STRING_CST
)))
512 tree string
= element
? element
: init
;
514 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
516 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
518 error ("char-array initialized from wide string");
519 return error_mark_node
;
521 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
523 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
525 error ("int-array initialized from non-wide string");
526 return error_mark_node
;
529 TREE_TYPE (string
) = type
;
530 if (TYPE_DOMAIN (type
) != 0
531 && TREE_CONSTANT (TYPE_SIZE (type
)))
534 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
535 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
536 /* In C it is ok to subtract 1 from the length of the string
537 because it's ok to ignore the terminating null char that is
538 counted in the length of the constant, but in C++ this would
540 if (size
< TREE_STRING_LENGTH (string
))
541 pedwarn ("initializer-string for array of chars is too long");
547 /* Handle scalar types, including conversions,
548 and signature pointers and references. */
550 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
551 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
552 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
553 || TYPE_PTRMEMFUNC_P (type
))
559 error ("initializer for scalar variable requires one element");
560 return error_mark_node
;
564 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
566 cp_pedwarn ("braces around scalar initializer for `%T'", type
);
567 init
= CONSTRUCTOR_ELTS (init
);
568 if (TREE_CHAIN (init
))
569 cp_pedwarn ("ignoring extra initializers for `%T'", type
);
570 init
= TREE_VALUE (init
);
573 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
574 "initialization", NULL_TREE
, 0);
577 /* Come here only for records and arrays (and unions with constructors). */
579 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
581 cp_error ("variable-sized object of type `%T' may not be initialized",
583 return error_mark_node
;
586 if (code
== ARRAY_TYPE
|| IS_AGGR_TYPE_CODE (code
))
588 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
589 && TREE_HAS_CONSTRUCTOR (init
))
591 cp_error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
593 return error_mark_node
;
595 else if (raw_constructor
)
596 return process_init_constructor (type
, init
, (tree
*)0);
597 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
598 || TYPE_NON_AGGREGATE_CLASS (type
))
599 /* These are never initialized from multiple constructor elements. */;
602 *tail
= old_tail_contents
;
603 return process_init_constructor (type
, 0, tail
);
606 if (code
!= ARRAY_TYPE
)
608 int flags
= LOOKUP_NORMAL
;
609 /* Initialization from { } is copy-initialization. */
611 flags
|= LOOKUP_ONLYCONVERTING
;
613 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
614 "initialization", NULL_TREE
, 0);
618 error ("invalid initializer");
619 return error_mark_node
;
622 /* Process a constructor for a variable of type TYPE.
623 The constructor elements may be specified either with INIT or with ELTS,
624 only one of which should be non-null.
626 If INIT is specified, it is a CONSTRUCTOR node which is specifically
627 and solely for initializing this datum.
629 If ELTS is specified, it is the address of a variable containing
630 a list of expressions. We take as many elements as we need
631 from the head of the list and update the list.
633 In the resulting constructor, TREE_CONSTANT is set if all elts are
634 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
635 constants that the assembler and linker can compute them. */
638 process_init_constructor (type
, init
, elts
)
639 tree type
, init
, *elts
;
642 /* List of the elements of the result constructor,
644 register tree members
= NULL
;
651 /* Make TAIL be the list of elements to use for the initialization,
652 no matter how the data was given to us. */
656 if (warn_missing_braces
)
657 warning ("aggregate has a partly bracketed initializer");
661 tail
= CONSTRUCTOR_ELTS (init
);
663 /* Gobble as many elements as needed, and make a constructor or initial value
664 for each element of this aggregate. Chain them together in result.
665 If there are too few, use 0 for each scalar ultimate component. */
667 if (TREE_CODE (type
) == ARRAY_TYPE
)
669 tree domain
= TYPE_DOMAIN (type
);
674 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
675 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
678 len
= -1; /* Take as many as there are */
680 for (i
= 0; len
< 0 || i
< len
; i
++)
684 if (TREE_PURPOSE (tail
)
685 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
686 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
687 sorry ("non-trivial labeled initializers");
689 if (TREE_VALUE (tail
) != 0)
692 next1
= digest_init (TREE_TYPE (type
),
693 TREE_VALUE (tail
), &tail1
);
694 if (next1
== error_mark_node
)
697 (same_type_ignoring_top_level_qualifiers_p
698 (TREE_TYPE (type
), TREE_TYPE (next1
)),
700 my_friendly_assert (tail1
== 0
701 || TREE_CODE (tail1
) == TREE_LIST
, 319);
702 if (tail
== tail1
&& len
< 0)
704 error ("non-empty initializer for array of empty elements");
705 /* Just ignore what we were supposed to use. */
712 next1
= error_mark_node
;
713 tail
= TREE_CHAIN (tail
);
719 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
721 /* If this type needs constructors run for
722 default-initialization, we can't rely on the backend to do it
723 for us, so build up TARGET_EXPRs. If the type in question is
724 a class, just build one up; if it's an array, recurse. */
726 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
727 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
729 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
730 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
733 /* The default zero-initialization is fine for us; don't
734 add anything to the CONSTRUCTOR. */
737 if (next1
== error_mark_node
)
739 else if (!TREE_CONSTANT (next1
))
741 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
743 members
= tree_cons (size_int (i
), next1
, members
);
746 else if (TREE_CODE (type
) == RECORD_TYPE
)
752 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
754 sorry ("initializer list for object of class with virtual base classes");
755 return error_mark_node
;
758 if (TYPE_BINFO_BASETYPES (type
))
760 sorry ("initializer list for object of class with base classes");
761 return error_mark_node
;
764 if (TYPE_POLYMORPHIC_P (type
))
766 sorry ("initializer list for object using virtual functions");
767 return error_mark_node
;
771 for (field
= TYPE_FIELDS (type
); field
;
772 field
= TREE_CHAIN (field
))
774 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
776 members
= tree_cons (field
, integer_zero_node
, members
);
780 if (TREE_CODE (field
) != FIELD_DECL
)
785 if (TREE_PURPOSE (tail
)
786 && TREE_PURPOSE (tail
) != field
787 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
788 sorry ("non-trivial labeled initializers");
790 if (TREE_VALUE (tail
) != 0)
794 next1
= digest_init (TREE_TYPE (field
),
795 TREE_VALUE (tail
), &tail1
);
796 my_friendly_assert (tail1
== 0
797 || TREE_CODE (tail1
) == TREE_LIST
, 320);
802 next1
= error_mark_node
;
803 tail
= TREE_CHAIN (tail
);
806 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
808 /* If this type needs constructors run for
809 default-initialization, we can't rely on the backend to do it
810 for us, so build up TARGET_EXPRs. If the type in question is
811 a class, just build one up; if it's an array, recurse. */
813 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
814 next1
= build_functional_cast (TREE_TYPE (field
),
818 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
821 TREE_HAS_CONSTRUCTOR (next1
)
822 = TREE_HAS_CONSTRUCTOR (init
);
824 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
826 /* Warn when some struct elements are implicitly initialized. */
828 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
829 cp_warning ("missing initializer for member `%D'", field
);
833 if (TREE_READONLY (field
))
834 cp_error ("uninitialized const member `%D'", field
);
835 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field
))
836 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
837 cp_error ("member `%D' with uninitialized const fields",
839 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
840 cp_error ("member `%D' is uninitialized reference", field
);
842 /* Warn when some struct elements are implicitly initialized
845 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
846 cp_warning ("missing initializer for member `%D'", field
);
848 /* The default zero-initialization is fine for us; don't
849 add anything to the CONSTRUCTOR. */
853 if (next1
== error_mark_node
)
855 else if (!TREE_CONSTANT (next1
))
857 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
859 members
= tree_cons (field
, next1
, members
);
862 else if (TREE_CODE (type
) == UNION_TYPE
863 /* If the initializer was empty, use default zero initialization. */
866 register tree field
= TYPE_FIELDS (type
);
868 /* Find the first named field. ANSI decided in September 1990
869 that only named fields count here. */
870 while (field
&& (DECL_NAME (field
) == 0
871 || TREE_CODE (field
) != FIELD_DECL
))
872 field
= TREE_CHAIN (field
);
874 /* If this element specifies a field, initialize via that field. */
875 if (TREE_PURPOSE (tail
) != NULL_TREE
)
879 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
880 /* Handle the case of a call by build_c_cast. */
881 field
= TREE_PURPOSE (tail
), win
= 1;
882 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
883 error ("index value instead of field name in union initializer");
887 for (temp
= TYPE_FIELDS (type
);
889 temp
= TREE_CHAIN (temp
))
890 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
893 field
= temp
, win
= 1;
895 cp_error ("no field `%D' in union being initialized",
896 TREE_PURPOSE (tail
));
899 TREE_VALUE (tail
) = error_mark_node
;
903 cp_error ("union `%T' with no named members cannot be initialized",
905 TREE_VALUE (tail
) = error_mark_node
;
908 if (TREE_VALUE (tail
) != 0)
912 next1
= digest_init (TREE_TYPE (field
),
913 TREE_VALUE (tail
), &tail1
);
914 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
915 my_friendly_abort (357);
920 next1
= error_mark_node
;
921 tail
= TREE_CHAIN (tail
);
924 if (next1
== error_mark_node
)
926 else if (!TREE_CONSTANT (next1
))
928 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
930 members
= tree_cons (field
, next1
, members
);
933 /* If arguments were specified as a list, just remove the ones we used. */
936 /* If arguments were specified as a constructor,
937 complain unless we used all the elements of the constructor. */
939 pedwarn ("excess elements in aggregate initializer");
942 return error_mark_node
;
944 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
946 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
947 if (allconstant
) TREE_CONSTANT (result
) = 1;
948 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
952 /* Given a structure or union value DATUM, construct and return
953 the structure or union component which results from narrowing
954 that value by the type specified in BASETYPE. For example, given the
960 class C : A, B { ... };
968 x.A::ii refers to the ii member of the L part of
969 the A part of the C object named by X. In this case,
970 DATUM would be x, and BASETYPE would be A.
972 I used to think that this was nonconformant, that the standard specified
973 that first we look up ii in A, then convert x to an L& and pull out the
974 ii part. But in fact, it does say that we convert x to an A&; A here
975 is known as the "naming class". (jason 2000-12-19) */
978 build_scoped_ref (datum
, basetype
)
984 if (datum
== error_mark_node
)
985 return error_mark_node
;
987 ref
= build_unary_op (ADDR_EXPR
, datum
, 0);
988 ref
= convert_pointer_to (basetype
, ref
);
990 return build_indirect_ref (ref
, "(compiler error in build_scoped_ref)");
993 /* Build a reference to an object specified by the C++ `->' operator.
994 Usually this just involves dereferencing the object, but if the
995 `->' operator is overloaded, then such overloads must be
996 performed until an object which does not have the `->' operator
997 overloaded is found. An error is reported when circular pointer
998 delegation is detected. */
1001 build_x_arrow (datum
)
1004 tree types_memoized
= NULL_TREE
;
1005 register tree rval
= datum
;
1006 tree type
= TREE_TYPE (rval
);
1007 tree last_rval
= NULL_TREE
;
1009 if (type
== error_mark_node
)
1010 return error_mark_node
;
1012 if (processing_template_decl
)
1013 return build_min_nt (ARROW_EXPR
, rval
);
1015 if (TREE_CODE (rval
) == OFFSET_REF
)
1017 rval
= resolve_offset_ref (datum
);
1018 type
= TREE_TYPE (rval
);
1021 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1023 rval
= convert_from_reference (rval
);
1024 type
= TREE_TYPE (rval
);
1027 if (IS_AGGR_TYPE (type
))
1029 while ((rval
= build_opfncall (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1030 NULL_TREE
, NULL_TREE
)))
1032 if (rval
== error_mark_node
)
1033 return error_mark_node
;
1035 if (value_member (TREE_TYPE (rval
), types_memoized
))
1037 error ("circular pointer delegation detected");
1038 return error_mark_node
;
1042 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1048 if (last_rval
== NULL_TREE
)
1050 cp_error ("base operand of `->' has non-pointer type `%T'", type
);
1051 return error_mark_node
;
1054 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1055 last_rval
= convert_from_reference (last_rval
);
1058 last_rval
= default_conversion (rval
);
1060 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1061 return build_indirect_ref (last_rval
, NULL_PTR
);
1064 error ("result of `operator->()' yields non-pointer result");
1066 error ("base operand of `->' is not a pointer");
1067 return error_mark_node
;
1070 /* Make an expression to refer to the COMPONENT field of
1071 structure or union value DATUM. COMPONENT is an arbitrary
1072 expression. DATUM has not already been checked out to be of
1075 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1076 return an object of member type to a method of the current class,
1077 but there is not yet enough typing information to know which one.
1078 As a special case, if there is only one method by that name,
1079 it is returned. Otherwise we return an expression which other
1080 routines will have to know how to deal with later. */
1083 build_m_component_ref (datum
, component
)
1084 tree datum
, component
;
1092 if (processing_template_decl
)
1093 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1095 datum
= decay_conversion (datum
);
1097 if (datum
== error_mark_node
|| component
== error_mark_node
)
1098 return error_mark_node
;
1100 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1102 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1104 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1107 else if (TYPE_PTRMEM_P (TREE_TYPE (component
)))
1109 type
= TREE_TYPE (TREE_TYPE (component
));
1110 field_type
= TREE_TYPE (type
);
1114 cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1115 component
, TREE_TYPE (component
));
1116 return error_mark_node
;
1119 if (! IS_AGGR_TYPE (objtype
))
1121 cp_error ("cannot apply member pointer `%E' to `%E'", component
, datum
);
1122 cp_error ("which is of non-aggregate type `%T'", objtype
);
1123 return error_mark_node
;
1126 binfo
= get_binfo (TYPE_METHOD_BASETYPE (type
), objtype
, 1);
1127 if (binfo
== NULL_TREE
)
1129 cp_error ("member type `%T::' incompatible with object type `%T'",
1130 TYPE_METHOD_BASETYPE (type
), objtype
);
1131 return error_mark_node
;
1133 else if (binfo
== error_mark_node
)
1134 return error_mark_node
;
1136 /* Compute the type of the field, as described in [expr.ref]. */
1137 type_quals
= TYPE_UNQUALIFIED
;
1138 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1139 /* The standard says that the type of the result should be the
1140 type referred to by the reference. But for now, at least, we
1141 do the conversion from reference type later. */
1145 type_quals
= (CP_TYPE_QUALS (field_type
)
1146 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
1148 /* There's no such thing as a mutable pointer-to-member, so we don't
1149 need to deal with that here like we do in build_component_ref. */
1150 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1153 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1154 if (TREE_CODE (type
) == OFFSET_TYPE
)
1155 component
= resolve_offset_ref (component
);
1159 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1162 build_functional_cast (exp
, parms
)
1166 /* This is either a call to a constructor,
1167 or a C cast in C++'s `functional' notation. */
1170 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1171 return error_mark_node
;
1173 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1175 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1176 /* Either an enum or an aggregate type. */
1177 type
= IDENTIFIER_TYPE_VALUE (exp
);
1180 type
= lookup_name (exp
, 1);
1181 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1183 cp_error ("`%T' fails to be a typedef or built-in type", exp
);
1184 return error_mark_node
;
1186 type
= TREE_TYPE (type
);
1189 else if (TREE_CODE (exp
) == TYPE_DECL
)
1190 type
= TREE_TYPE (exp
);
1194 if (processing_template_decl
)
1195 return build_min (CAST_EXPR
, type
, parms
);
1197 if (! IS_AGGR_TYPE (type
))
1199 /* this must build a C cast */
1200 if (parms
== NULL_TREE
)
1201 parms
= integer_zero_node
;
1204 if (TREE_CHAIN (parms
) != NULL_TREE
)
1205 pedwarn ("initializer list being treated as compound expression");
1206 parms
= build_compound_expr (parms
);
1209 return build_c_cast (type
, parms
);
1212 /* Prepare to evaluate as a call to a constructor. If this expression
1213 is actually used, for example,
1215 return X (arg1, arg2, ...);
1217 then the slot being initialized will be filled in. */
1219 if (!complete_type_or_else (type
, NULL_TREE
))
1220 return error_mark_node
;
1221 if (abstract_virtuals_error (NULL_TREE
, type
))
1222 return error_mark_node
;
1224 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1225 return build_c_cast (type
, TREE_VALUE (parms
));
1227 /* We need to zero-initialize POD types. Let's do that for everything
1228 that doesn't need a constructor. */
1229 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1230 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1232 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1233 return get_target_expr (exp
);
1236 exp
= build_method_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1237 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1239 if (exp
== error_mark_node
)
1240 return error_mark_node
;
1242 return build_cplus_new (type
, exp
);
1246 /* Complain about defining new types in inappropriate places. We give an
1247 exception for C-style casts, to accommodate GNU C stylings. */
1250 check_for_new_type (string
, inptree
)
1252 flagged_type_tree inptree
;
1254 if (inptree
.new_type_flag
1255 && (pedantic
|| strcmp (string
, "cast") != 0))
1256 pedwarn ("ISO C++ forbids defining types within %s", string
);
1259 /* Add new exception specifier SPEC, to the LIST we currently have.
1260 If it's already in LIST then do nothing.
1261 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1262 know what we're doing. */
1265 add_exception_specifier (list
, spec
, complain
)
1273 if (spec
== error_mark_node
)
1276 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1278 /* [except.spec] 1, type in an exception specifier shall not be
1279 incomplete, or pointer or ref to incomplete other than pointer
1281 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1282 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1283 core
= TREE_TYPE (core
);
1286 else if (VOID_TYPE_P (core
))
1288 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1291 ok
= COMPLETE_TYPE_P (complete_type (core
));
1297 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1298 if (same_type_p (TREE_VALUE (probe
), spec
))
1302 spec
= build_tree_list (NULL_TREE
, spec
);
1303 TREE_CHAIN (spec
) = list
;
1308 incomplete_type_error (NULL_TREE
, core
);
1312 /* Combine the two exceptions specifier lists LIST and ADD, and return
1316 merge_exception_specifiers (list
, add
)
1321 else if (!TREE_VALUE (list
))
1323 else if (!TREE_VALUE (add
))
1327 tree orig_list
= list
;
1329 for (; add
; add
= TREE_CHAIN (add
))
1331 tree spec
= TREE_VALUE (add
);
1334 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1335 if (same_type_p (TREE_VALUE (probe
), spec
))
1339 spec
= build_tree_list (NULL_TREE
, spec
);
1340 TREE_CHAIN (spec
) = list
;