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
)
265 error ("Internal error #%d.", where
);
267 /* Uncount this error, so finish_abort will do the right thing. */
270 fancy_abort (file
, line
, func
);
274 /* Perform appropriate conversions on the initial value of a variable,
275 store it in the declaration DECL,
276 and print any error messages that are appropriate.
277 If the init is invalid, store an ERROR_MARK.
279 C++: Note that INIT might be a TREE_LIST, which would mean that it is
280 a base class initializer for some aggregate type, hopefully compatible
281 with DECL. If INIT is a single element, and DECL is an aggregate
282 type, we silently convert INIT into a TREE_LIST, allowing a constructor
285 If INIT is a TREE_LIST and there is no constructor, turn INIT
286 into a CONSTRUCTOR and use standard initialization techniques.
287 Perhaps a warning should be generated?
289 Returns value of initializer if initialization could not be
290 performed for static variable. In that case, caller must do
294 store_init_value (decl
, init
)
297 register tree value
, type
;
299 /* If variable's type was invalidly declared, just ignore it. */
301 type
= TREE_TYPE (decl
);
302 if (TREE_CODE (type
) == ERROR_MARK
)
306 /* This breaks arrays, and should not have any effect for other decls. */
307 /* Take care of C++ business up here. */
308 type
= TYPE_MAIN_VARIANT (type
);
311 if (IS_AGGR_TYPE (type
))
313 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
314 && TREE_CODE (init
) != CONSTRUCTOR
)
315 my_friendly_abort (109);
317 if (TREE_CODE (init
) == TREE_LIST
)
319 cp_error ("constructor syntax used, but no constructor declared for type `%T'", type
);
320 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
323 if (TREE_CODE (init
) == CONSTRUCTOR
)
327 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
328 if (CLASSTYPE_N_BASECLASSES (type
))
329 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl
);
330 if (CLASSTYPE_VTBL_PTR (type
))
331 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl
);
332 if (TYPE_NEEDS_CONSTRUCTING (type
))
334 cp_error_at ("initializer list construction invalid for `%D'", decl
);
335 error ("due to the presence of a constructor");
337 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
338 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
340 cp_error_at ("initializer list construction invalid for `%D'", decl
);
341 cp_error_at ("due to non-public access of member `%D'", field
);
343 for (field
= TYPE_METHODS (type
); field
; field
= TREE_CHAIN (field
))
344 if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
346 cp_error_at ("initializer list construction invalid for `%D'", decl
);
347 cp_error_at ("due to non-public access of member `%D'", field
);
352 else if (TREE_CODE (init
) == TREE_LIST
353 && TREE_TYPE (init
) != unknown_type_node
)
355 if (TREE_CODE (decl
) == RESULT_DECL
)
357 if (TREE_CHAIN (init
))
359 warning ("comma expression used to initialize return value");
360 init
= build_compound_expr (init
);
363 init
= TREE_VALUE (init
);
365 else if (TREE_CODE (init
) == TREE_LIST
366 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
368 error ("cannot initialize arrays using this syntax");
373 /* We get here with code like `int a (2);' */
375 if (TREE_CHAIN (init
) != NULL_TREE
)
377 pedwarn ("initializer list being treated as compound expression");
378 init
= build_compound_expr (init
);
381 init
= TREE_VALUE (init
);
385 /* End of special C++ code. */
387 /* Digest the specified initializer into an expression. */
389 value
= digest_init (type
, init
, (tree
*) 0);
391 /* Store the expression if valid; else report error. */
393 if (TREE_CODE (value
) == ERROR_MARK
)
395 /* Other code expects that initializers for objects of types that need
396 constructing never make it into DECL_INITIAL, and passes 'init' to
397 build_aggr_init without checking DECL_INITIAL. So just return. */
398 else if (TYPE_NEEDS_CONSTRUCTING (type
))
400 else if (TREE_STATIC (decl
)
401 && (! TREE_CONSTANT (value
)
402 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
404 /* A STATIC PUBLIC int variable doesn't have to be
405 run time inited when doing pic. (mrs) */
406 /* Since ctors and dtors are the only things that can
407 reference vtables, and they are always written down
408 the vtable definition, we can leave the
409 vtables in initialized data space.
410 However, other initialized data cannot be initialized
411 this way. Instead a global file-level initializer
413 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
418 #if 0 /* No, that's C. jason 9/19/94 */
421 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
423 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
424 pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
429 /* Store the VALUE in DECL_INITIAL. If we're building a
430 statement-tree we will actually expand the initialization later
431 when we output this function. */
432 DECL_INITIAL (decl
) = value
;
436 /* Digest the parser output INIT as an initializer for type TYPE.
437 Return a C expression of type TYPE to represent the initial value.
439 If TAIL is nonzero, it points to a variable holding a list of elements
440 of which INIT is the first. We update the list stored there by
441 removing from the head all the elements that we use.
442 Normally this is only one; we use more than one element only if
443 TYPE is an aggregate and INIT is not a constructor. */
446 digest_init (type
, init
, tail
)
447 tree type
, init
, *tail
;
449 enum tree_code code
= TREE_CODE (type
);
450 tree element
= NULL_TREE
;
451 tree old_tail_contents
= NULL_TREE
;
452 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
453 tree node which has no TREE_TYPE. */
456 /* By default, assume we use one element from a list.
457 We correct this later in the sole case where it is not true. */
461 old_tail_contents
= *tail
;
462 *tail
= TREE_CHAIN (*tail
);
465 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
466 && TREE_VALUE (init
) == error_mark_node
))
467 return error_mark_node
;
469 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
470 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
471 init
= TREE_OPERAND (init
, 0);
473 if (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == type
)
476 raw_constructor
= TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == 0;
479 && CONSTRUCTOR_ELTS (init
) != 0
480 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
482 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
483 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
484 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
485 element
= TREE_OPERAND (element
, 0);
486 if (element
== error_mark_node
)
490 /* Initialization of an array of chars from a string constant
491 optionally enclosed in braces. */
493 if (code
== ARRAY_TYPE
)
497 if (TREE_CODE (init
) == TREE_LIST
)
499 error ("initializing array with parameter list");
500 return error_mark_node
;
503 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
504 if (char_type_p (typ1
)
505 && ((init
&& TREE_CODE (init
) == STRING_CST
)
506 || (element
&& TREE_CODE (element
) == STRING_CST
)))
508 tree string
= element
? element
: init
;
510 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
512 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
514 error ("char-array initialized from wide string");
515 return error_mark_node
;
517 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
519 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
521 error ("int-array initialized from non-wide string");
522 return error_mark_node
;
525 TREE_TYPE (string
) = type
;
526 if (TYPE_DOMAIN (type
) != 0
527 && TREE_CONSTANT (TYPE_SIZE (type
)))
530 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
531 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
532 /* In C it is ok to subtract 1 from the length of the string
533 because it's ok to ignore the terminating null char that is
534 counted in the length of the constant, but in C++ this would
536 if (size
< TREE_STRING_LENGTH (string
))
537 pedwarn ("initializer-string for array of chars is too long");
543 /* Handle scalar types, including conversions,
544 and signature pointers and references. */
546 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
547 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
548 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
549 || TYPE_PTRMEMFUNC_P (type
))
555 error ("initializer for scalar variable requires one element");
556 return error_mark_node
;
560 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
562 cp_pedwarn ("braces around scalar initializer for `%T'", type
);
563 init
= CONSTRUCTOR_ELTS (init
);
564 if (TREE_CHAIN (init
))
565 cp_pedwarn ("ignoring extra initializers for `%T'", type
);
566 init
= TREE_VALUE (init
);
569 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
570 "initialization", NULL_TREE
, 0);
573 /* Come here only for records and arrays (and unions with constructors). */
575 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
577 cp_error ("variable-sized object of type `%T' may not be initialized",
579 return error_mark_node
;
582 if (code
== ARRAY_TYPE
|| IS_AGGR_TYPE_CODE (code
))
584 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
585 && TREE_HAS_CONSTRUCTOR (init
))
587 cp_error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
589 return error_mark_node
;
591 else if (raw_constructor
)
592 return process_init_constructor (type
, init
, (tree
*)0);
593 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
594 || TYPE_NON_AGGREGATE_CLASS (type
))
595 /* These are never initialized from multiple constructor elements. */;
598 *tail
= old_tail_contents
;
599 return process_init_constructor (type
, 0, tail
);
602 if (code
!= ARRAY_TYPE
)
604 int flags
= LOOKUP_NORMAL
;
605 /* Initialization from { } is copy-initialization. */
607 flags
|= LOOKUP_ONLYCONVERTING
;
609 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
610 "initialization", NULL_TREE
, 0);
614 error ("invalid initializer");
615 return error_mark_node
;
618 /* Process a constructor for a variable of type TYPE.
619 The constructor elements may be specified either with INIT or with ELTS,
620 only one of which should be non-null.
622 If INIT is specified, it is a CONSTRUCTOR node which is specifically
623 and solely for initializing this datum.
625 If ELTS is specified, it is the address of a variable containing
626 a list of expressions. We take as many elements as we need
627 from the head of the list and update the list.
629 In the resulting constructor, TREE_CONSTANT is set if all elts are
630 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
631 constants that the assembler and linker can compute them. */
634 process_init_constructor (type
, init
, elts
)
635 tree type
, init
, *elts
;
638 /* List of the elements of the result constructor,
640 register tree members
= NULL
;
647 /* Make TAIL be the list of elements to use for the initialization,
648 no matter how the data was given to us. */
652 if (warn_missing_braces
)
653 warning ("aggregate has a partly bracketed initializer");
657 tail
= CONSTRUCTOR_ELTS (init
);
659 /* Gobble as many elements as needed, and make a constructor or initial value
660 for each element of this aggregate. Chain them together in result.
661 If there are too few, use 0 for each scalar ultimate component. */
663 if (TREE_CODE (type
) == ARRAY_TYPE
)
665 tree domain
= TYPE_DOMAIN (type
);
670 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
671 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
674 len
= -1; /* Take as many as there are */
676 for (i
= 0; len
< 0 || i
< len
; i
++)
680 if (TREE_PURPOSE (tail
)
681 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
682 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
683 sorry ("non-trivial labeled initializers");
685 if (TREE_VALUE (tail
) != 0)
688 next1
= digest_init (TREE_TYPE (type
),
689 TREE_VALUE (tail
), &tail1
);
690 if (next1
== error_mark_node
)
693 (same_type_ignoring_top_level_qualifiers_p
694 (TREE_TYPE (type
), TREE_TYPE (next1
)),
696 my_friendly_assert (tail1
== 0
697 || TREE_CODE (tail1
) == TREE_LIST
, 319);
698 if (tail
== tail1
&& len
< 0)
700 error ("non-empty initializer for array of empty elements");
701 /* Just ignore what we were supposed to use. */
708 next1
= error_mark_node
;
709 tail
= TREE_CHAIN (tail
);
715 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
717 /* If this type needs constructors run for
718 default-initialization, we can't rely on the backend to do it
719 for us, so build up TARGET_EXPRs. If the type in question is
720 a class, just build one up; if it's an array, recurse. */
722 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
723 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
725 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
726 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
729 /* The default zero-initialization is fine for us; don't
730 add anything to the CONSTRUCTOR. */
733 if (next1
== error_mark_node
)
735 else if (!TREE_CONSTANT (next1
))
737 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
739 members
= tree_cons (size_int (i
), next1
, members
);
742 else if (TREE_CODE (type
) == RECORD_TYPE
)
748 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
750 sorry ("initializer list for object of class with virtual base classes");
751 return error_mark_node
;
754 if (TYPE_BINFO_BASETYPES (type
))
756 sorry ("initializer list for object of class with base classes");
757 return error_mark_node
;
760 if (TYPE_POLYMORPHIC_P (type
))
762 sorry ("initializer list for object using virtual functions");
763 return error_mark_node
;
767 for (field
= TYPE_FIELDS (type
); field
;
768 field
= TREE_CHAIN (field
))
770 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
772 members
= tree_cons (field
, integer_zero_node
, members
);
776 if (TREE_CODE (field
) != FIELD_DECL
)
781 if (TREE_PURPOSE (tail
)
782 && TREE_PURPOSE (tail
) != field
783 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
784 sorry ("non-trivial labeled initializers");
786 if (TREE_VALUE (tail
) != 0)
790 next1
= digest_init (TREE_TYPE (field
),
791 TREE_VALUE (tail
), &tail1
);
792 my_friendly_assert (tail1
== 0
793 || TREE_CODE (tail1
) == TREE_LIST
, 320);
798 next1
= error_mark_node
;
799 tail
= TREE_CHAIN (tail
);
802 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
804 /* If this type needs constructors run for
805 default-initialization, we can't rely on the backend to do it
806 for us, so build up TARGET_EXPRs. If the type in question is
807 a class, just build one up; if it's an array, recurse. */
809 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
810 next1
= build_functional_cast (TREE_TYPE (field
),
813 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
815 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
817 /* Warn when some struct elements are implicitly initialized. */
819 cp_warning ("missing initializer for member `%D'", field
);
823 if (TREE_READONLY (field
))
824 cp_error ("uninitialized const member `%D'", field
);
825 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field
))
826 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
827 cp_error ("member `%D' with uninitialized const fields",
829 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
830 cp_error ("member `%D' is uninitialized reference", field
);
832 /* Warn when some struct elements are implicitly initialized
835 cp_warning ("missing initializer for member `%D'", field
);
837 /* The default zero-initialization is fine for us; don't
838 add anything to the CONSTRUCTOR. */
842 if (next1
== error_mark_node
)
844 else if (!TREE_CONSTANT (next1
))
846 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
848 members
= tree_cons (field
, next1
, members
);
851 else if (TREE_CODE (type
) == UNION_TYPE
852 /* If the initializer was empty, use default zero initialization. */
855 register tree field
= TYPE_FIELDS (type
);
857 /* Find the first named field. ANSI decided in September 1990
858 that only named fields count here. */
859 while (field
&& (DECL_NAME (field
) == 0
860 || TREE_CODE (field
) != FIELD_DECL
))
861 field
= TREE_CHAIN (field
);
863 /* If this element specifies a field, initialize via that field. */
864 if (TREE_PURPOSE (tail
) != NULL_TREE
)
868 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
869 /* Handle the case of a call by build_c_cast. */
870 field
= TREE_PURPOSE (tail
), win
= 1;
871 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
872 error ("index value instead of field name in union initializer");
876 for (temp
= TYPE_FIELDS (type
);
878 temp
= TREE_CHAIN (temp
))
879 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
882 field
= temp
, win
= 1;
884 cp_error ("no field `%D' in union being initialized",
885 TREE_PURPOSE (tail
));
888 TREE_VALUE (tail
) = error_mark_node
;
892 cp_error ("union `%T' with no named members cannot be initialized",
894 TREE_VALUE (tail
) = error_mark_node
;
897 if (TREE_VALUE (tail
) != 0)
901 next1
= digest_init (TREE_TYPE (field
),
902 TREE_VALUE (tail
), &tail1
);
903 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
904 my_friendly_abort (357);
909 next1
= error_mark_node
;
910 tail
= TREE_CHAIN (tail
);
913 if (next1
== error_mark_node
)
915 else if (!TREE_CONSTANT (next1
))
917 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
919 members
= tree_cons (field
, next1
, members
);
922 /* If arguments were specified as a list, just remove the ones we used. */
925 /* If arguments were specified as a constructor,
926 complain unless we used all the elements of the constructor. */
928 pedwarn ("excess elements in aggregate initializer");
931 return error_mark_node
;
933 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
935 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
936 if (allconstant
) TREE_CONSTANT (result
) = 1;
937 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
941 /* Given a structure or union value DATUM, construct and return
942 the structure or union component which results from narrowing
943 that value by the type specified in BASETYPE. For example, given the
949 class C : A, B { ... };
957 x.A::ii refers to the ii member of the L part of
958 the A part of the C object named by X. In this case,
959 DATUM would be x, and BASETYPE would be A.
961 I used to think that this was nonconformant, that the standard specified
962 that first we look up ii in A, then convert x to an L& and pull out the
963 ii part. But in fact, it does say that we convert x to an A&; A here
964 is known as the "naming class". (jason 2000-12-19) */
967 build_scoped_ref (datum
, basetype
)
973 if (datum
== error_mark_node
)
974 return error_mark_node
;
976 ref
= build_unary_op (ADDR_EXPR
, datum
, 0);
977 ref
= convert_pointer_to (basetype
, ref
);
979 return build_indirect_ref (ref
, "(compiler error in build_scoped_ref)");
982 /* Build a reference to an object specified by the C++ `->' operator.
983 Usually this just involves dereferencing the object, but if the
984 `->' operator is overloaded, then such overloads must be
985 performed until an object which does not have the `->' operator
986 overloaded is found. An error is reported when circular pointer
987 delegation is detected. */
990 build_x_arrow (datum
)
993 tree types_memoized
= NULL_TREE
;
994 register tree rval
= datum
;
995 tree type
= TREE_TYPE (rval
);
996 tree last_rval
= NULL_TREE
;
998 if (type
== error_mark_node
)
999 return error_mark_node
;
1001 if (processing_template_decl
)
1002 return build_min_nt (ARROW_EXPR
, rval
);
1004 if (TREE_CODE (rval
) == OFFSET_REF
)
1006 rval
= resolve_offset_ref (datum
);
1007 type
= TREE_TYPE (rval
);
1010 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1012 rval
= convert_from_reference (rval
);
1013 type
= TREE_TYPE (rval
);
1016 if (IS_AGGR_TYPE (type
))
1018 while ((rval
= build_opfncall (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1019 NULL_TREE
, NULL_TREE
)))
1021 if (rval
== error_mark_node
)
1022 return error_mark_node
;
1024 if (value_member (TREE_TYPE (rval
), types_memoized
))
1026 error ("circular pointer delegation detected");
1027 return error_mark_node
;
1031 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1037 if (last_rval
== NULL_TREE
)
1039 cp_error ("base operand of `->' has non-pointer type `%T'", type
);
1040 return error_mark_node
;
1043 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1044 last_rval
= convert_from_reference (last_rval
);
1047 last_rval
= default_conversion (rval
);
1049 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1050 return build_indirect_ref (last_rval
, NULL_PTR
);
1053 error ("result of `operator->()' yields non-pointer result");
1055 error ("base operand of `->' is not a pointer");
1056 return error_mark_node
;
1059 /* Make an expression to refer to the COMPONENT field of
1060 structure or union value DATUM. COMPONENT is an arbitrary
1061 expression. DATUM has not already been checked out to be of
1064 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1065 return an object of member type to a method of the current class,
1066 but there is not yet enough typing information to know which one.
1067 As a special case, if there is only one method by that name,
1068 it is returned. Otherwise we return an expression which other
1069 routines will have to know how to deal with later. */
1072 build_m_component_ref (datum
, component
)
1073 tree datum
, component
;
1081 if (processing_template_decl
)
1082 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1084 datum
= decay_conversion (datum
);
1085 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1087 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1089 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1094 type
= TREE_TYPE (TREE_TYPE (component
));
1095 field_type
= TREE_TYPE (type
);
1098 if (datum
== error_mark_node
|| component
== error_mark_node
)
1099 return error_mark_node
;
1101 if (TREE_CODE (type
) != OFFSET_TYPE
&& TREE_CODE (type
) != METHOD_TYPE
)
1103 cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'", component
, type
);
1104 return error_mark_node
;
1107 if (! IS_AGGR_TYPE (objtype
))
1109 cp_error ("cannot apply member pointer `%E' to `%E'", component
, datum
);
1110 cp_error ("which is of non-aggregate type `%T'", objtype
);
1111 return error_mark_node
;
1114 binfo
= get_binfo (TYPE_METHOD_BASETYPE (type
), objtype
, 1);
1115 if (binfo
== NULL_TREE
)
1117 cp_error ("member type `%T::' incompatible with object type `%T'",
1118 TYPE_METHOD_BASETYPE (type
), objtype
);
1119 return error_mark_node
;
1121 else if (binfo
== error_mark_node
)
1122 return error_mark_node
;
1124 /* Compute the type of the field, as described in [expr.ref]. */
1125 type_quals
= TYPE_UNQUALIFIED
;
1126 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1127 /* The standard says that the type of the result should be the
1128 type referred to by the reference. But for now, at least, we
1129 do the conversion from reference type later. */
1133 type_quals
= (CP_TYPE_QUALS (field_type
)
1134 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
1136 /* There's no such thing as a mutable pointer-to-member, so we don't
1137 need to deal with that here like we do in build_component_ref. */
1138 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1141 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1142 if (TREE_CODE (type
) == OFFSET_TYPE
)
1143 component
= resolve_offset_ref (component
);
1147 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1150 build_functional_cast (exp
, parms
)
1154 /* This is either a call to a constructor,
1155 or a C cast in C++'s `functional' notation. */
1158 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1159 return error_mark_node
;
1161 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1163 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1164 /* Either an enum or an aggregate type. */
1165 type
= IDENTIFIER_TYPE_VALUE (exp
);
1168 type
= lookup_name (exp
, 1);
1169 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1171 cp_error ("`%T' fails to be a typedef or built-in type", exp
);
1172 return error_mark_node
;
1174 type
= TREE_TYPE (type
);
1177 else if (TREE_CODE (exp
) == TYPE_DECL
)
1178 type
= TREE_TYPE (exp
);
1182 if (processing_template_decl
)
1183 return build_min (CAST_EXPR
, type
, parms
);
1185 if (! IS_AGGR_TYPE (type
))
1187 /* this must build a C cast */
1188 if (parms
== NULL_TREE
)
1189 parms
= integer_zero_node
;
1192 if (TREE_CHAIN (parms
) != NULL_TREE
)
1193 pedwarn ("initializer list being treated as compound expression");
1194 parms
= build_compound_expr (parms
);
1197 return build_c_cast (type
, parms
);
1200 /* Prepare to evaluate as a call to a constructor. If this expression
1201 is actually used, for example,
1203 return X (arg1, arg2, ...);
1205 then the slot being initialized will be filled in. */
1207 if (!complete_type_or_else (type
, NULL_TREE
))
1208 return error_mark_node
;
1209 if (abstract_virtuals_error (NULL_TREE
, type
))
1210 return error_mark_node
;
1212 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1213 return build_c_cast (type
, TREE_VALUE (parms
));
1215 /* We need to zero-initialize POD types. Let's do that for everything
1216 that doesn't need a constructor. */
1217 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1218 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1220 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1221 return get_target_expr (exp
);
1224 exp
= build_method_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1225 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1227 if (exp
== error_mark_node
)
1228 return error_mark_node
;
1230 return build_cplus_new (type
, exp
);
1234 /* Complain about defining new types in inappropriate places. We give an
1235 exception for C-style casts, to accommodate GNU C stylings. */
1238 check_for_new_type (string
, inptree
)
1240 flagged_type_tree inptree
;
1242 if (inptree
.new_type_flag
1243 && (pedantic
|| strcmp (string
, "cast") != 0))
1244 pedwarn ("ISO C++ forbids defining types within %s", string
);
1247 /* Add new exception specifier SPEC, to the LIST we currently have.
1248 If it's already in LIST then do nothing.
1249 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1250 know what we're doing. */
1253 add_exception_specifier (list
, spec
, complain
)
1261 if (spec
== error_mark_node
)
1264 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1266 /* [except.spec] 1, type in an exception specifier shall not be
1267 incomplete, or pointer or ref to incomplete other than pointer
1269 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1270 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1271 core
= TREE_TYPE (core
);
1274 else if (VOID_TYPE_P (core
))
1276 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1279 ok
= COMPLETE_TYPE_P (complete_type (core
));
1285 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1286 if (same_type_p (TREE_VALUE (probe
), spec
))
1290 spec
= build_tree_list (NULL_TREE
, spec
);
1291 TREE_CHAIN (spec
) = list
;
1296 incomplete_type_error (NULL_TREE
, core
);
1300 /* Combine the two exceptions specifier lists LIST and ADD, and return
1304 merge_exception_specifiers (list
, add
)
1309 else if (!TREE_VALUE (list
))
1311 else if (!TREE_VALUE (add
))
1315 tree orig_list
= list
;
1317 for (; add
; add
= TREE_CHAIN (add
))
1319 tree spec
= TREE_VALUE (add
);
1322 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1323 if (same_type_p (TREE_VALUE (probe
), spec
))
1327 spec
= build_tree_list (NULL_TREE
, spec
);
1328 TREE_CHAIN (spec
) = list
;