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 cp_error ("type `%T' is not a base type for type `%T'", basetype
, type
);
55 return error_mark_node
;
59 binfo_or_else (parent_or_type
, type
)
60 tree parent_or_type
, type
;
63 if (TYPE_MAIN_VARIANT (parent_or_type
) == TYPE_MAIN_VARIANT (type
))
64 return TYPE_BINFO (parent_or_type
);
65 if ((binfo
= get_binfo (parent_or_type
, TYPE_MAIN_VARIANT (type
), 0)))
67 if (binfo
== error_mark_node
)
71 error_not_base_type (parent_or_type
, type
);
75 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
76 value may not be changed thereafter. Thus, we emit hard errors for these,
77 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
78 example, conversions to references.) */
81 readonly_error (arg
, string
, soft
)
87 void (*fn
) PARAMS ((const char *, ...));
94 if (TREE_CODE (arg
) == COMPONENT_REF
)
96 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
97 fmt
= "%s of data-member `%D' in read-only structure";
99 fmt
= "%s of read-only data-member `%D'";
100 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
102 else if (TREE_CODE (arg
) == VAR_DECL
)
104 if (DECL_LANG_SPECIFIC (arg
)
105 && DECL_IN_AGGR_P (arg
)
106 && !TREE_STATIC (arg
))
107 fmt
= "%s of constant field `%D'";
109 fmt
= "%s of read-only variable `%D'";
110 (*fn
) (fmt
, string
, arg
);
112 else if (TREE_CODE (arg
) == PARM_DECL
)
113 (*fn
) ("%s of read-only parameter `%D'", string
, arg
);
114 else if (TREE_CODE (arg
) == INDIRECT_REF
115 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
116 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
117 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
118 (*fn
) ("%s of read-only reference `%D'", string
, TREE_OPERAND (arg
, 0));
119 else if (TREE_CODE (arg
) == RESULT_DECL
)
120 (*fn
) ("%s of read-only named return value `%D'", string
, arg
);
121 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
122 (*fn
) ("%s of function `%D'", string
, arg
);
124 (*fn
) ("%s of read-only location", string
);
127 /* If TYPE has abstract virtual functions, issue an error about trying
128 to create an object of that type. DECL is the object declared, or
129 NULL_TREE if the declaration is unavailable. Returns 1 if an error
130 occurred; zero if all was well. */
133 abstract_virtuals_error (decl
, type
)
140 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
143 u
= CLASSTYPE_PURE_VIRTUALS (type
);
146 if (TREE_CODE (decl
) == RESULT_DECL
)
149 if (TREE_CODE (decl
) == VAR_DECL
)
150 cp_error ("cannot declare variable `%D' to be of type `%T'",
152 else if (TREE_CODE (decl
) == PARM_DECL
)
153 cp_error ("cannot declare parameter `%D' to be of type `%T'",
155 else if (TREE_CODE (decl
) == FIELD_DECL
)
156 cp_error ("cannot declare field `%D' to be of type `%T'",
158 else if (TREE_CODE (decl
) == FUNCTION_DECL
159 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
160 cp_error ("invalid return type for member function `%#D'", decl
);
161 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
162 cp_error ("invalid return type for function `%#D'", decl
);
165 cp_error ("cannot allocate an object of type `%T'", type
);
167 /* Only go through this once. */
168 if (TREE_PURPOSE (u
) == NULL_TREE
)
170 TREE_PURPOSE (u
) = error_mark_node
;
172 error (" because the following virtual functions are abstract:");
173 for (tu
= u
; tu
; tu
= TREE_CHAIN (tu
))
174 cp_error_at ("\t%#D", TREE_VALUE (tu
));
177 cp_error (" since type `%T' has abstract virtual functions", type
);
182 /* Print an error message for invalid use of an incomplete type.
183 VALUE is the expression that was used (or 0 if that isn't known)
184 and TYPE is the type that was invalid. */
187 incomplete_type_error (value
, type
)
193 /* Avoid duplicate error message. */
194 if (TREE_CODE (type
) == ERROR_MARK
)
197 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
198 || TREE_CODE (value
) == PARM_DECL
))
200 cp_error_at ("`%D' has incomplete type", value
);
204 /* We must print an error message. Be clever about what it says. */
206 switch (TREE_CODE (type
))
212 cp_error ("invalid use of undefined type `%#T'", type
);
213 cp_error_at ("forward declaration of `%#T'", type
);
217 cp_error ("invalid use of `%T'", type
);
221 if (TYPE_DOMAIN (type
))
223 type
= TREE_TYPE (type
);
226 cp_error ("invalid use of array with unspecified bounds");
231 cp_error ("invalid use of member (did you forget the `&' ?)");
234 case TEMPLATE_TYPE_PARM
:
235 cp_error ("invalid use of template type parameter");
239 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
241 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
242 cp_error ("address of overloaded function with no contextual type information");
243 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
244 cp_error ("overloaded function with no contextual type information");
246 cp_error ("insufficient contextual information to determine type");
250 my_friendly_abort (108);
254 /* This is a wrapper around fancy_abort, as used in the back end and
255 other front ends. It will also report the magic number assigned to
256 this particular abort. That is for backward compatibility with the
257 old C++ abort handler, which would just report the magic number. */
259 friendly_abort (where
, file
, line
, func
)
265 if (errorcount
> 0 || sorrycount
> 0)
269 error ("Internal error #%d.", where
);
271 /* Uncount this error, so internal_error will do the right thing. */
275 fancy_abort (file
, line
, func
);
279 /* Perform appropriate conversions on the initial value of a variable,
280 store it in the declaration DECL,
281 and print any error messages that are appropriate.
282 If the init is invalid, store an ERROR_MARK.
284 C++: Note that INIT might be a TREE_LIST, which would mean that it is
285 a base class initializer for some aggregate type, hopefully compatible
286 with DECL. If INIT is a single element, and DECL is an aggregate
287 type, we silently convert INIT into a TREE_LIST, allowing a constructor
290 If INIT is a TREE_LIST and there is no constructor, turn INIT
291 into a CONSTRUCTOR and use standard initialization techniques.
292 Perhaps a warning should be generated?
294 Returns value of initializer if initialization could not be
295 performed for static variable. In that case, caller must do
299 store_init_value (decl
, init
)
302 register tree value
, type
;
304 /* If variable's type was invalidly declared, just ignore it. */
306 type
= TREE_TYPE (decl
);
307 if (TREE_CODE (type
) == ERROR_MARK
)
311 /* This breaks arrays, and should not have any effect for other decls. */
312 /* Take care of C++ business up here. */
313 type
= TYPE_MAIN_VARIANT (type
);
316 if (IS_AGGR_TYPE (type
))
318 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
319 && TREE_CODE (init
) != CONSTRUCTOR
)
320 my_friendly_abort (109);
322 if (TREE_CODE (init
) == TREE_LIST
)
324 cp_error ("constructor syntax used, but no constructor declared for type `%T'", type
);
325 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
328 if (TREE_CODE (init
) == CONSTRUCTOR
)
332 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
333 if (CLASSTYPE_N_BASECLASSES (type
))
334 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl
);
335 if (CLASSTYPE_VTBL_PTR (type
))
336 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl
);
337 if (TYPE_NEEDS_CONSTRUCTING (type
))
339 cp_error_at ("initializer list construction invalid for `%D'", decl
);
340 error ("due to the presence of a constructor");
342 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
343 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
345 cp_error_at ("initializer list construction invalid for `%D'", decl
);
346 cp_error_at ("due to non-public access of member `%D'", field
);
348 for (field
= TYPE_METHODS (type
); field
; field
= TREE_CHAIN (field
))
349 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
351 cp_error_at ("initializer list construction invalid for `%D'", decl
);
352 cp_error_at ("due to non-public access of member `%D'", field
);
357 else if (TREE_CODE (init
) == TREE_LIST
358 && TREE_TYPE (init
) != unknown_type_node
)
360 if (TREE_CODE (decl
) == RESULT_DECL
)
362 if (TREE_CHAIN (init
))
364 warning ("comma expression used to initialize return value");
365 init
= build_compound_expr (init
);
368 init
= TREE_VALUE (init
);
370 else if (TREE_CODE (init
) == TREE_LIST
371 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
373 error ("cannot initialize arrays using this syntax");
378 /* We get here with code like `int a (2);' */
380 if (TREE_CHAIN (init
) != NULL_TREE
)
382 pedwarn ("initializer list being treated as compound expression");
383 init
= build_compound_expr (init
);
386 init
= TREE_VALUE (init
);
390 /* End of special C++ code. */
392 /* We might have already run this bracketed initializer through
393 digest_init. Don't do so again. */
394 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
)
396 && TYPE_MAIN_VARIANT (TREE_TYPE (init
)) == TYPE_MAIN_VARIANT (type
))
399 /* Digest the specified initializer into an expression. */
400 value
= digest_init (type
, init
, (tree
*) 0);
402 /* Store the expression if valid; else report error. */
404 if (TREE_CODE (value
) == ERROR_MARK
)
406 /* Other code expects that initializers for objects of types that need
407 constructing never make it into DECL_INITIAL, and passes 'init' to
408 build_aggr_init without checking DECL_INITIAL. So just return. */
409 else if (TYPE_NEEDS_CONSTRUCTING (type
))
411 else if (TREE_STATIC (decl
)
412 && (! TREE_CONSTANT (value
)
413 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
415 /* A STATIC PUBLIC int variable doesn't have to be
416 run time inited when doing pic. (mrs) */
417 /* Since ctors and dtors are the only things that can
418 reference vtables, and they are always written down
419 the vtable definition, we can leave the
420 vtables in initialized data space.
421 However, other initialized data cannot be initialized
422 this way. Instead a global file-level initializer
424 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
429 #if 0 /* No, that's C. jason 9/19/94 */
432 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
434 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
435 pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
440 /* Store the VALUE in DECL_INITIAL. If we're building a
441 statement-tree we will actually expand the initialization later
442 when we output this function. */
443 DECL_INITIAL (decl
) = value
;
447 /* Digest the parser output INIT as an initializer for type TYPE.
448 Return a C expression of type TYPE to represent the initial value.
450 If TAIL is nonzero, it points to a variable holding a list of elements
451 of which INIT is the first. We update the list stored there by
452 removing from the head all the elements that we use.
453 Normally this is only one; we use more than one element only if
454 TYPE is an aggregate and INIT is not a constructor. */
457 digest_init (type
, init
, tail
)
458 tree type
, init
, *tail
;
460 enum tree_code code
= TREE_CODE (type
);
461 tree element
= NULL_TREE
;
462 tree old_tail_contents
= NULL_TREE
;
463 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
464 tree node which has no TREE_TYPE. */
467 /* By default, assume we use one element from a list.
468 We correct this later in the sole case where it is not true. */
472 old_tail_contents
= *tail
;
473 *tail
= TREE_CHAIN (*tail
);
476 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
477 && TREE_VALUE (init
) == error_mark_node
))
478 return error_mark_node
;
480 if (TREE_CODE (init
) == ERROR_MARK
)
481 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
482 a template function. This gets substituted during instantiation. */
485 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
486 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
487 init
= TREE_OPERAND (init
, 0);
489 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == type
)
492 raw_constructor
= TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == 0;
495 && CONSTRUCTOR_ELTS (init
) != 0
496 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
498 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
499 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
500 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
501 element
= TREE_OPERAND (element
, 0);
502 if (element
== error_mark_node
)
506 /* Initialization of an array of chars from a string constant
507 optionally enclosed in braces. */
509 if (code
== ARRAY_TYPE
)
513 if (TREE_CODE (init
) == TREE_LIST
)
515 error ("initializing array with parameter list");
516 return error_mark_node
;
519 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
520 if (char_type_p (typ1
)
521 && ((init
&& TREE_CODE (init
) == STRING_CST
)
522 || (element
&& TREE_CODE (element
) == STRING_CST
)))
524 tree string
= element
? element
: init
;
526 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
528 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
530 error ("char-array initialized from wide string");
531 return error_mark_node
;
533 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
535 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
537 error ("int-array initialized from non-wide string");
538 return error_mark_node
;
541 TREE_TYPE (string
) = type
;
542 if (TYPE_DOMAIN (type
) != 0
543 && TREE_CONSTANT (TYPE_SIZE (type
)))
546 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
547 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
548 /* In C it is ok to subtract 1 from the length of the string
549 because it's ok to ignore the terminating null char that is
550 counted in the length of the constant, but in C++ this would
552 if (size
< TREE_STRING_LENGTH (string
))
553 pedwarn ("initializer-string for array of chars is too long");
559 /* Handle scalar types, including conversions,
560 and signature pointers and references. */
562 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
563 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
564 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
565 || TYPE_PTRMEMFUNC_P (type
))
571 error ("initializer for scalar variable requires one element");
572 return error_mark_node
;
576 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
578 cp_pedwarn ("braces around scalar initializer for `%T'", type
);
579 init
= CONSTRUCTOR_ELTS (init
);
580 if (TREE_CHAIN (init
))
581 cp_pedwarn ("ignoring extra initializers for `%T'", type
);
582 init
= TREE_VALUE (init
);
585 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
586 "initialization", NULL_TREE
, 0);
589 /* Come here only for records and arrays (and unions with constructors). */
591 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
593 cp_error ("variable-sized object of type `%T' may not be initialized",
595 return error_mark_node
;
598 if (code
== ARRAY_TYPE
|| IS_AGGR_TYPE_CODE (code
))
600 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
601 && TREE_HAS_CONSTRUCTOR (init
))
603 cp_error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
605 return error_mark_node
;
607 else if (raw_constructor
)
608 return process_init_constructor (type
, init
, (tree
*)0);
609 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
610 || TYPE_NON_AGGREGATE_CLASS (type
))
611 /* These are never initialized from multiple constructor elements. */;
614 *tail
= old_tail_contents
;
615 return process_init_constructor (type
, 0, tail
);
618 if (code
!= ARRAY_TYPE
)
620 int flags
= LOOKUP_NORMAL
;
621 /* Initialization from { } is copy-initialization. */
623 flags
|= LOOKUP_ONLYCONVERTING
;
625 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
626 "initialization", NULL_TREE
, 0);
630 error ("invalid initializer");
631 return error_mark_node
;
634 /* Process a constructor for a variable of type TYPE.
635 The constructor elements may be specified either with INIT or with ELTS,
636 only one of which should be non-null.
638 If INIT is specified, it is a CONSTRUCTOR node which is specifically
639 and solely for initializing this datum.
641 If ELTS is specified, it is the address of a variable containing
642 a list of expressions. We take as many elements as we need
643 from the head of the list and update the list.
645 In the resulting constructor, TREE_CONSTANT is set if all elts are
646 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
647 constants that the assembler and linker can compute them. */
650 process_init_constructor (type
, init
, elts
)
651 tree type
, init
, *elts
;
654 /* List of the elements of the result constructor,
656 register tree members
= NULL
;
663 /* Make TAIL be the list of elements to use for the initialization,
664 no matter how the data was given to us. */
668 if (warn_missing_braces
)
669 warning ("aggregate has a partly bracketed initializer");
673 tail
= CONSTRUCTOR_ELTS (init
);
675 /* Gobble as many elements as needed, and make a constructor or initial value
676 for each element of this aggregate. Chain them together in result.
677 If there are too few, use 0 for each scalar ultimate component. */
679 if (TREE_CODE (type
) == ARRAY_TYPE
)
681 tree domain
= TYPE_DOMAIN (type
);
686 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
687 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
690 len
= -1; /* Take as many as there are */
692 for (i
= 0; len
< 0 || i
< len
; i
++)
696 if (TREE_PURPOSE (tail
)
697 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
698 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
699 sorry ("non-trivial labeled initializers");
701 if (TREE_VALUE (tail
) != 0)
704 next1
= digest_init (TREE_TYPE (type
),
705 TREE_VALUE (tail
), &tail1
);
706 if (next1
== error_mark_node
)
709 (same_type_ignoring_top_level_qualifiers_p
710 (TREE_TYPE (type
), TREE_TYPE (next1
)),
712 my_friendly_assert (tail1
== 0
713 || TREE_CODE (tail1
) == TREE_LIST
, 319);
714 if (tail
== tail1
&& len
< 0)
716 error ("non-empty initializer for array of empty elements");
717 /* Just ignore what we were supposed to use. */
724 next1
= error_mark_node
;
725 tail
= TREE_CHAIN (tail
);
731 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
733 /* If this type needs constructors run for
734 default-initialization, we can't rely on the backend to do it
735 for us, so build up TARGET_EXPRs. If the type in question is
736 a class, just build one up; if it's an array, recurse. */
738 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
739 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
741 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
742 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
745 /* The default zero-initialization is fine for us; don't
746 add anything to the CONSTRUCTOR. */
749 if (next1
== error_mark_node
)
751 else if (!TREE_CONSTANT (next1
))
753 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
755 members
= tree_cons (size_int (i
), next1
, members
);
758 else if (TREE_CODE (type
) == RECORD_TYPE
)
764 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
766 sorry ("initializer list for object of class with virtual base classes");
767 return error_mark_node
;
770 if (TYPE_BINFO_BASETYPES (type
))
772 sorry ("initializer list for object of class with base classes");
773 return error_mark_node
;
776 if (TYPE_POLYMORPHIC_P (type
))
778 sorry ("initializer list for object using virtual functions");
779 return error_mark_node
;
783 for (field
= TYPE_FIELDS (type
); field
;
784 field
= TREE_CHAIN (field
))
786 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
788 members
= tree_cons (field
, integer_zero_node
, members
);
792 if (TREE_CODE (field
) != FIELD_DECL
)
797 if (TREE_PURPOSE (tail
)
798 && TREE_PURPOSE (tail
) != field
799 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
800 sorry ("non-trivial labeled initializers");
802 if (TREE_VALUE (tail
) != 0)
806 next1
= digest_init (TREE_TYPE (field
),
807 TREE_VALUE (tail
), &tail1
);
808 my_friendly_assert (tail1
== 0
809 || TREE_CODE (tail1
) == TREE_LIST
, 320);
814 next1
= error_mark_node
;
815 tail
= TREE_CHAIN (tail
);
818 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
820 /* If this type needs constructors run for
821 default-initialization, we can't rely on the backend to do it
822 for us, so build up TARGET_EXPRs. If the type in question is
823 a class, just build one up; if it's an array, recurse. */
825 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
826 next1
= build_functional_cast (TREE_TYPE (field
),
830 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
833 TREE_HAS_CONSTRUCTOR (next1
)
834 = TREE_HAS_CONSTRUCTOR (init
);
836 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
838 /* Warn when some struct elements are implicitly initialized. */
840 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
841 cp_warning ("missing initializer for member `%D'", field
);
845 if (TREE_READONLY (field
))
846 cp_error ("uninitialized const member `%D'", field
);
847 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field
))
848 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
849 cp_error ("member `%D' with uninitialized const fields",
851 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
852 cp_error ("member `%D' is uninitialized reference", field
);
854 /* Warn when some struct elements are implicitly initialized
857 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
858 cp_warning ("missing initializer for member `%D'", field
);
860 /* The default zero-initialization is fine for us; don't
861 add anything to the CONSTRUCTOR. */
865 if (next1
== error_mark_node
)
867 else if (!TREE_CONSTANT (next1
))
869 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
871 members
= tree_cons (field
, next1
, members
);
874 else if (TREE_CODE (type
) == UNION_TYPE
875 /* If the initializer was empty, use default zero initialization. */
878 register tree field
= TYPE_FIELDS (type
);
880 /* Find the first named field. ANSI decided in September 1990
881 that only named fields count here. */
882 while (field
&& (DECL_NAME (field
) == 0
883 || TREE_CODE (field
) != FIELD_DECL
))
884 field
= TREE_CHAIN (field
);
886 /* If this element specifies a field, initialize via that field. */
887 if (TREE_PURPOSE (tail
) != NULL_TREE
)
891 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
892 /* Handle the case of a call by build_c_cast. */
893 field
= TREE_PURPOSE (tail
), win
= 1;
894 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
895 error ("index value instead of field name in union initializer");
899 for (temp
= TYPE_FIELDS (type
);
901 temp
= TREE_CHAIN (temp
))
902 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
905 field
= temp
, win
= 1;
907 cp_error ("no field `%D' in union being initialized",
908 TREE_PURPOSE (tail
));
911 TREE_VALUE (tail
) = error_mark_node
;
915 cp_error ("union `%T' with no named members cannot be initialized",
917 TREE_VALUE (tail
) = error_mark_node
;
920 if (TREE_VALUE (tail
) != 0)
924 next1
= digest_init (TREE_TYPE (field
),
925 TREE_VALUE (tail
), &tail1
);
926 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
927 my_friendly_abort (357);
932 next1
= error_mark_node
;
933 tail
= TREE_CHAIN (tail
);
936 if (next1
== error_mark_node
)
938 else if (!TREE_CONSTANT (next1
))
940 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
942 members
= tree_cons (field
, next1
, members
);
945 /* If arguments were specified as a list, just remove the ones we used. */
948 /* If arguments were specified as a constructor,
949 complain unless we used all the elements of the constructor. */
951 pedwarn ("excess elements in aggregate initializer");
954 return error_mark_node
;
956 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
958 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
959 if (allconstant
) TREE_CONSTANT (result
) = 1;
960 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
964 /* Given a structure or union value DATUM, construct and return
965 the structure or union component which results from narrowing
966 that value by the type specified in BASETYPE. For example, given the
972 class C : A, B { ... };
980 x.A::ii refers to the ii member of the L part of
981 the A part of the C object named by X. In this case,
982 DATUM would be x, and BASETYPE would be A.
984 I used to think that this was nonconformant, that the standard specified
985 that first we look up ii in A, then convert x to an L& and pull out the
986 ii part. But in fact, it does say that we convert x to an A&; A here
987 is known as the "naming class". (jason 2000-12-19) */
990 build_scoped_ref (datum
, basetype
)
996 if (datum
== error_mark_node
)
997 return error_mark_node
;
999 ref
= build_unary_op (ADDR_EXPR
, datum
, 0);
1000 ref
= convert_pointer_to (basetype
, ref
);
1002 return build_indirect_ref (ref
, "(compiler error in build_scoped_ref)");
1005 /* Build a reference to an object specified by the C++ `->' operator.
1006 Usually this just involves dereferencing the object, but if the
1007 `->' operator is overloaded, then such overloads must be
1008 performed until an object which does not have the `->' operator
1009 overloaded is found. An error is reported when circular pointer
1010 delegation is detected. */
1013 build_x_arrow (datum
)
1016 tree types_memoized
= NULL_TREE
;
1017 register tree rval
= datum
;
1018 tree type
= TREE_TYPE (rval
);
1019 tree last_rval
= NULL_TREE
;
1021 if (type
== error_mark_node
)
1022 return error_mark_node
;
1024 if (processing_template_decl
)
1025 return build_min_nt (ARROW_EXPR
, rval
);
1027 if (TREE_CODE (rval
) == OFFSET_REF
)
1029 rval
= resolve_offset_ref (datum
);
1030 type
= TREE_TYPE (rval
);
1033 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1035 rval
= convert_from_reference (rval
);
1036 type
= TREE_TYPE (rval
);
1039 if (IS_AGGR_TYPE (type
))
1041 while ((rval
= build_opfncall (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1042 NULL_TREE
, NULL_TREE
)))
1044 if (rval
== error_mark_node
)
1045 return error_mark_node
;
1047 if (value_member (TREE_TYPE (rval
), types_memoized
))
1049 error ("circular pointer delegation detected");
1050 return error_mark_node
;
1054 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1060 if (last_rval
== NULL_TREE
)
1062 cp_error ("base operand of `->' has non-pointer type `%T'", type
);
1063 return error_mark_node
;
1066 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1067 last_rval
= convert_from_reference (last_rval
);
1070 last_rval
= default_conversion (rval
);
1072 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1073 return build_indirect_ref (last_rval
, NULL
);
1076 error ("result of `operator->()' yields non-pointer result");
1078 error ("base operand of `->' is not a pointer");
1079 return error_mark_node
;
1082 /* Make an expression to refer to the COMPONENT field of
1083 structure or union value DATUM. COMPONENT is an arbitrary
1084 expression. DATUM has not already been checked out to be of
1087 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1088 return an object of member type to a method of the current class,
1089 but there is not yet enough typing information to know which one.
1090 As a special case, if there is only one method by that name,
1091 it is returned. Otherwise we return an expression which other
1092 routines will have to know how to deal with later. */
1095 build_m_component_ref (datum
, component
)
1096 tree datum
, component
;
1104 if (processing_template_decl
)
1105 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1107 datum
= decay_conversion (datum
);
1109 if (datum
== error_mark_node
|| component
== error_mark_node
)
1110 return error_mark_node
;
1112 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1114 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1116 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1119 else if (TYPE_PTRMEM_P (TREE_TYPE (component
)))
1121 type
= TREE_TYPE (TREE_TYPE (component
));
1122 field_type
= TREE_TYPE (type
);
1126 cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1127 component
, TREE_TYPE (component
));
1128 return error_mark_node
;
1131 if (! IS_AGGR_TYPE (objtype
))
1133 cp_error ("cannot apply member pointer `%E' to `%E'", component
, datum
);
1134 cp_error ("which is of non-aggregate type `%T'", objtype
);
1135 return error_mark_node
;
1138 binfo
= get_binfo (TYPE_METHOD_BASETYPE (type
), objtype
, 1);
1139 if (binfo
== NULL_TREE
)
1141 cp_error ("member type `%T::' incompatible with object type `%T'",
1142 TYPE_METHOD_BASETYPE (type
), objtype
);
1143 return error_mark_node
;
1145 else if (binfo
== error_mark_node
)
1146 return error_mark_node
;
1148 /* Compute the type of the field, as described in [expr.ref]. */
1149 type_quals
= TYPE_UNQUALIFIED
;
1150 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1151 /* The standard says that the type of the result should be the
1152 type referred to by the reference. But for now, at least, we
1153 do the conversion from reference type later. */
1157 type_quals
= (CP_TYPE_QUALS (field_type
)
1158 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
1160 /* There's no such thing as a mutable pointer-to-member, so we don't
1161 need to deal with that here like we do in build_component_ref. */
1162 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1165 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1166 if (TREE_CODE (type
) == OFFSET_TYPE
)
1167 component
= resolve_offset_ref (component
);
1171 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1174 build_functional_cast (exp
, parms
)
1178 /* This is either a call to a constructor,
1179 or a C cast in C++'s `functional' notation. */
1182 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1183 return error_mark_node
;
1185 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1187 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1188 /* Either an enum or an aggregate type. */
1189 type
= IDENTIFIER_TYPE_VALUE (exp
);
1192 type
= lookup_name (exp
, 1);
1193 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1195 cp_error ("`%T' fails to be a typedef or built-in type", exp
);
1196 return error_mark_node
;
1198 type
= TREE_TYPE (type
);
1201 else if (TREE_CODE (exp
) == TYPE_DECL
)
1202 type
= TREE_TYPE (exp
);
1206 if (processing_template_decl
)
1207 return build_min (CAST_EXPR
, type
, parms
);
1209 if (! IS_AGGR_TYPE (type
))
1211 /* this must build a C cast */
1212 if (parms
== NULL_TREE
)
1213 parms
= integer_zero_node
;
1216 if (TREE_CHAIN (parms
) != NULL_TREE
)
1217 pedwarn ("initializer list being treated as compound expression");
1218 parms
= build_compound_expr (parms
);
1221 return build_c_cast (type
, parms
);
1224 /* Prepare to evaluate as a call to a constructor. If this expression
1225 is actually used, for example,
1227 return X (arg1, arg2, ...);
1229 then the slot being initialized will be filled in. */
1231 if (!complete_type_or_else (type
, NULL_TREE
))
1232 return error_mark_node
;
1233 if (abstract_virtuals_error (NULL_TREE
, type
))
1234 return error_mark_node
;
1236 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1237 return build_c_cast (type
, TREE_VALUE (parms
));
1239 /* We need to zero-initialize POD types. Let's do that for everything
1240 that doesn't need a constructor. */
1241 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1242 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1244 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1245 return get_target_expr (exp
);
1248 exp
= build_method_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1249 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1251 if (exp
== error_mark_node
)
1252 return error_mark_node
;
1254 return build_cplus_new (type
, exp
);
1258 /* Complain about defining new types in inappropriate places. We give an
1259 exception for C-style casts, to accommodate GNU C stylings. */
1262 check_for_new_type (string
, inptree
)
1264 flagged_type_tree inptree
;
1266 if (inptree
.new_type_flag
1267 && (pedantic
|| strcmp (string
, "cast") != 0))
1268 pedwarn ("ISO C++ forbids defining types within %s", string
);
1271 /* Add new exception specifier SPEC, to the LIST we currently have.
1272 If it's already in LIST then do nothing.
1273 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1274 know what we're doing. */
1277 add_exception_specifier (list
, spec
, complain
)
1285 if (spec
== error_mark_node
)
1288 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1290 /* [except.spec] 1, type in an exception specifier shall not be
1291 incomplete, or pointer or ref to incomplete other than pointer
1293 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1294 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1295 core
= TREE_TYPE (core
);
1298 else if (VOID_TYPE_P (core
))
1300 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1302 else if (processing_template_decl
)
1305 ok
= COMPLETE_TYPE_P (complete_type (core
));
1311 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1312 if (same_type_p (TREE_VALUE (probe
), spec
))
1316 spec
= build_tree_list (NULL_TREE
, spec
);
1317 TREE_CHAIN (spec
) = list
;
1322 incomplete_type_error (NULL_TREE
, core
);
1326 /* Combine the two exceptions specifier lists LIST and ADD, and return
1330 merge_exception_specifiers (list
, add
)
1335 else if (!TREE_VALUE (list
))
1337 else if (!TREE_VALUE (add
))
1341 tree orig_list
= list
;
1343 for (; add
; add
= TREE_CHAIN (add
))
1345 tree spec
= TREE_VALUE (add
);
1348 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1349 if (same_type_p (TREE_VALUE (probe
), spec
))
1353 spec
= build_tree_list (NULL_TREE
, spec
);
1354 TREE_CHAIN (spec
) = list
;