1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
38 static tree process_init_constructor ();
39 extern void pedwarn (), error ();
41 extern int errorcount;
42 extern int sorrycount;
44 /* Print an error message stemming from an attempt to use
45 BASETYPE as a base class for TYPE. */
47 error_not_base_type (basetype, type)
50 if (TREE_CODE (basetype) == FUNCTION_DECL)
51 basetype = DECL_CLASS_CONTEXT (basetype);
52 cp_error ("type `%T' is not a base type for type `%T'", basetype, type);
53 return error_mark_node;
57 binfo_or_else (parent_or_type, type)
58 tree parent_or_type, type;
61 if (TYPE_MAIN_VARIANT (parent_or_type) == TYPE_MAIN_VARIANT (type))
62 return TYPE_BINFO (parent_or_type);
63 if ((binfo = get_binfo (parent_or_type, TYPE_MAIN_VARIANT (type), 0)))
65 if (binfo == error_mark_node)
69 error_not_base_type (parent_or_type, type);
73 /* Print an error message stemming from an invalid use of an
76 TYPE is the type or binfo which draws the error.
77 MSG is the message to print.
78 ARG is an optional argument which may provide more information. */
80 error_with_aggr_type (type, msg, arg)
87 if (TREE_CODE (type) == TREE_VEC)
88 type = BINFO_TYPE (type);
90 name = TYPE_NAME (type);
91 if (TREE_CODE (name) == TYPE_DECL)
92 name = DECL_NAME (name);
93 error (msg, IDENTIFIER_POINTER (name), arg);
96 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
97 value may not be changed thereafter. Thus, we emit hard errors for these,
98 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
99 example, conversions to references.) */
101 readonly_error (arg, string, soft)
114 if (TREE_CODE (arg) == COMPONENT_REF)
116 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
117 fmt = "%s of member `%s' in read-only structure";
119 fmt = "%s of read-only member `%s'";
120 (*fn) (fmt, string, lang_printable_name (TREE_OPERAND (arg, 1)));
122 else if (TREE_CODE (arg) == VAR_DECL)
124 if (DECL_LANG_SPECIFIC (arg)
125 && DECL_IN_AGGR_P (arg)
126 && !TREE_STATIC (arg))
127 fmt = "%s of constant field `%s'";
129 fmt = "%s of read-only variable `%s'";
130 (*fn) (fmt, string, lang_printable_name (arg));
132 else if (TREE_CODE (arg) == PARM_DECL)
133 (*fn) ("%s of read-only parameter `%s'", string,
134 lang_printable_name (arg));
135 else if (TREE_CODE (arg) == INDIRECT_REF
136 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
137 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
138 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
139 (*fn) ("%s of read-only reference `%s'",
140 string, lang_printable_name (TREE_OPERAND (arg, 0)));
141 else if (TREE_CODE (arg) == RESULT_DECL)
142 (*fn) ("%s of read-only named return value `%s'",
143 string, lang_printable_name (arg));
145 (*fn) ("%s of read-only location", string);
148 /* Print an error message for invalid use of a type which declares
149 virtual functions which are not inheritable. */
151 abstract_virtuals_error (decl, type)
155 tree u = CLASSTYPE_ABSTRACT_VIRTUALS (type);
159 if (TREE_CODE (decl) == RESULT_DECL)
162 if (TREE_CODE (decl) == VAR_DECL)
163 cp_error ("cannot declare variable `%D' to be of type `%T'",
165 else if (TREE_CODE (decl) == PARM_DECL)
166 cp_error ("cannot declare parameter `%D' to be of type `%T'",
168 else if (TREE_CODE (decl) == FIELD_DECL)
169 cp_error ("cannot declare field `%D' to be of type `%T'",
171 else if (TREE_CODE (decl) == FUNCTION_DECL
172 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
173 cp_error ("invalid return type for method `%#D'", decl);
174 else if (TREE_CODE (decl) == FUNCTION_DECL)
175 cp_error ("invalid return type for function `%#D'", decl);
177 else cp_error ("cannot allocate an object of type `%T'", type);
178 /* Only go through this once. */
179 if (TREE_PURPOSE (u) == NULL_TREE)
181 error (" since the following virtual functions are abstract:");
182 TREE_PURPOSE (u) = error_mark_node;
185 cp_error ("\t%#D", TREE_VALUE (u));
189 else cp_error (" since type `%T' has abstract virtual functions", type);
192 /* Print an error message for invalid use of a signature type.
193 Signatures are treated similar to abstract classes here, they
194 cannot be instantiated. */
196 signature_error (decl, type)
202 if (TREE_CODE (decl) == RESULT_DECL)
205 if (TREE_CODE (decl) == VAR_DECL)
206 cp_error ("cannot declare variable `%D' to be of signature type `%T'",
208 else if (TREE_CODE (decl) == PARM_DECL)
209 cp_error ("cannot declare parameter `%D' to be of signature type `%T'",
211 else if (TREE_CODE (decl) == FIELD_DECL)
212 cp_error ("cannot declare field `%D' to be of signature type `%T'",
214 else if (TREE_CODE (decl) == FUNCTION_DECL
215 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
216 cp_error ("invalid return type for method `%#D'", decl);
217 else if (TREE_CODE (decl) == FUNCTION_DECL)
218 cp_error ("invalid return type for function `%#D'", decl);
221 cp_error ("cannot allocate an object of signature type `%T'", type);
224 /* Print an error message for invalid use of an incomplete type.
225 VALUE is the expression that was used (or 0 if that isn't known)
226 and TYPE is the type that was invalid. */
229 incomplete_type_error (value, type)
235 /* Avoid duplicate error message. */
236 if (TREE_CODE (type) == ERROR_MARK)
239 if (value != 0 && (TREE_CODE (value) == VAR_DECL
240 || TREE_CODE (value) == PARM_DECL))
241 error ("`%s' has an incomplete type",
242 IDENTIFIER_POINTER (DECL_NAME (value)));
246 /* We must print an error message. Be clever about what it says. */
248 switch (TREE_CODE (type))
251 errmsg = "invalid use of undefined type `struct %s'";
255 errmsg = "invalid use of undefined type `union %s'";
259 errmsg = "invalid use of undefined type `enum %s'";
263 error ("invalid use of void expression");
267 if (TYPE_DOMAIN (type))
269 type = TREE_TYPE (type);
272 error ("invalid use of array with unspecified bounds");
276 error ("invalid use of member type (did you forget the `&' ?)");
280 my_friendly_abort (108);
283 error_with_aggr_type (type, errmsg);
287 /* Like error(), but don't call report_error_function(). */
294 extern char * progname;
297 fprintf (stderr, "%s:%d: ", input_filename, lineno);
299 fprintf (stderr, "%s: ", progname);
301 fprintf (stderr, s, v, v2);
302 fprintf (stderr, "\n");
305 /* There are times when the compiler can get very confused, confused
306 to the point of giving up by aborting, simply because of previous
307 input errors. It is much better to have the user go back and
308 correct those errors first, and see if it makes us happier, than it
309 is to abort on him. This is because when one has a 10,000 line
310 program, and the compiler comes back with ``core dump'', the user
311 is left not knowing even where to begin to fix things and no place
312 to even try and work around things.
314 The parameter is to uniquely identify the problem to the user, so
315 that they can say, I am having problem 59, and know that fix 7 will
316 probably solve their problem. Or, we can document what problem
317 59 is, so they can understand how to work around it, should they
320 Note, there will be no more calls in the C++ front end to abort,
321 because the C++ front end is so unreliable still. The C front end
322 can get away with calling abort, because for most of the calls to
323 abort on most machines, it, I suspect, can be proven that it is
324 impossible to ever call abort. The same is not yet true for C++,
325 one day, maybe it will be.
327 We used to tell people to "fix the above error[s] and try recompiling
328 the program" via a call to fatal, but that message tended to look
329 silly. So instead, we just do the equivalent of a call to fatal in the
330 same situation (call exit). */
332 /* First used: 0 (reserved), Last used: 366. Free: */
334 static int abortcount = 0;
337 my_friendly_abort (i)
340 /* if the previous error came through here, i.e. report_error_function
341 ended up calling us again, don't just exit; we want a diagnostic of
344 current_function_decl = NULL_TREE;
345 else if (errorcount > 0 || sorrycount > 0)
350 ack ("Internal compiler error.");
352 ack ("Internal compiler error %d.", i);
353 ack ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
356 error ("confused by earlier errors, bailing out");
363 error ("Internal compiler error.");
365 error ("Internal compiler error %d.", i);
367 fatal ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
371 my_friendly_assert (cond, where)
375 my_friendly_abort (where);
378 /* Return nonzero if VALUE is a valid constant-valued expression
379 for use in initializing a static variable; one that can be an
380 element of a "constant" initializer.
382 Return null_pointer_node if the value is absolute;
383 if it is relocatable, return the variable that determines the relocation.
384 We assume that VALUE has been folded as much as possible;
385 therefore, we do not need to check for such things as
386 arithmetic-combinations of integers. */
389 initializer_constant_valid_p (value, endtype)
393 switch (TREE_CODE (value))
396 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
397 && TREE_CONSTANT (value))
399 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
402 return TREE_STATIC (value) ? null_pointer_node : 0;
408 return null_pointer_node;
411 return TREE_OPERAND (value, 0);
413 case NON_LVALUE_EXPR:
414 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
418 /* Allow conversions between pointer types. */
419 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
420 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
421 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
423 /* Allow conversions between real types. */
424 if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
425 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
426 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
428 /* Allow length-preserving conversions between integer types. */
429 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
430 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
431 && (TYPE_PRECISION (TREE_TYPE (value))
432 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
433 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
435 /* Allow conversions between other integer types only if
437 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
438 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
440 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
442 if (inner == null_pointer_node)
443 return null_pointer_node;
447 /* Allow (int) &foo provided int is as wide as a pointer. */
448 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
449 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
450 && (TYPE_PRECISION (TREE_TYPE (value))
451 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
452 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
455 /* Likewise conversions from int to pointers. */
456 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
457 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
458 && (TYPE_PRECISION (TREE_TYPE (value))
459 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
460 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
463 /* Allow conversions to union types if the value inside is okay. */
464 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
465 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
470 if (TREE_CODE (endtype) == INTEGER_TYPE
471 && TYPE_PRECISION (endtype) < POINTER_SIZE)
474 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
476 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
478 /* If either term is absolute, use the other terms relocation. */
479 if (valid0 == null_pointer_node)
481 if (valid1 == null_pointer_node)
487 if (TREE_CODE (endtype) == INTEGER_TYPE
488 && TYPE_PRECISION (endtype) < POINTER_SIZE)
491 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
493 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
495 /* Win if second argument is absolute. */
496 if (valid1 == null_pointer_node)
498 /* Win if both arguments have the same relocation.
499 Then the value is absolute. */
500 if (valid0 == valid1)
501 return null_pointer_node;
509 /* Perform appropriate conversions on the initial value of a variable,
510 store it in the declaration DECL,
511 and print any error messages that are appropriate.
512 If the init is invalid, store an ERROR_MARK.
514 C++: Note that INIT might be a TREE_LIST, which would mean that it is
515 a base class initializer for some aggregate type, hopefully compatible
516 with DECL. If INIT is a single element, and DECL is an aggregate
517 type, we silently convert INIT into a TREE_LIST, allowing a constructor
520 If INIT is a TREE_LIST and there is no constructor, turn INIT
521 into a CONSTRUCTOR and use standard initialization techniques.
522 Perhaps a warning should be generated?
524 Returns value of initializer if initialization could not be
525 performed for static variable. In that case, caller must do
529 store_init_value (decl, init)
532 register tree value, type;
534 /* If variable's type was invalidly declared, just ignore it. */
536 type = TREE_TYPE (decl);
537 if (TREE_CODE (type) == ERROR_MARK)
541 /* This breaks arrays, and should not have any effect for other decls. */
542 /* Take care of C++ business up here. */
543 type = TYPE_MAIN_VARIANT (type);
546 if (IS_AGGR_TYPE (type))
548 if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
549 && TREE_CODE (init) != CONSTRUCTOR)
550 my_friendly_abort (109);
552 /* Although we are not allowed to declare variables of signature
553 type, we complain about a possible constructor call in such a
554 declaration as well. */
555 if (TREE_CODE (init) == TREE_LIST
556 && IS_SIGNATURE (type))
558 cp_error ("constructor syntax cannot be used with signature type `%T'",
560 init = error_mark_node;
562 else if (TREE_CODE (init) == TREE_LIST)
564 cp_error ("constructor syntax used, but no constructor declared for type `%T'", type);
565 init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
568 if (TREE_CODE (init) == CONSTRUCTOR)
574 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
575 if (CLASSTYPE_N_BASECLASSES (type))
576 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl);
577 if (CLASSTYPE_VTBL_PTR (type))
578 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl);
579 if (TYPE_NEEDS_CONSTRUCTING (type))
581 cp_error_at ("initializer list construction invalid for `%D'", decl);
582 error ("due to the presence of a constructor");
584 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
585 if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
587 cp_error_at ("initializer list construction invalid for `%D'", decl);
588 cp_error_at ("due to non-public access of member `%D'", field);
590 funcs = TYPE_METHODS (type);
592 for (func = 0; func < TREE_VEC_LENGTH (funcs); func++)
594 field = TREE_VEC_ELT (funcs, func);
595 if (field && (TREE_PRIVATE (field) || TREE_PROTECTED (field)))
597 cp_error_at ("initializer list construction invalid for `%D'", decl);
598 cp_error_at ("due to non-public access of member `%D'", field);
604 else if (TREE_CODE (init) == TREE_LIST
605 && TREE_TYPE (init) != unknown_type_node)
607 if (TREE_CODE (decl) == RESULT_DECL)
609 if (TREE_CHAIN (init))
611 warning ("comma expression used to initialize return value");
612 init = build_compound_expr (init);
615 init = TREE_VALUE (init);
617 else if (TREE_TYPE (init) != 0
618 && TREE_CODE (TREE_TYPE (init)) == OFFSET_TYPE)
620 /* Use the type of our variable to instantiate
621 the type of our initializer. */
622 init = instantiate_type (type, init, 1);
624 else if (TREE_CODE (init) == TREE_LIST
625 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
627 error ("cannot initialize arrays using this syntax");
632 /* We get here with code like `int a (2);' */
634 if (TREE_CHAIN (init) != NULL_TREE)
636 pedwarn ("initializer list being treated as compound expression");
637 init = build_compound_expr (init);
640 init = TREE_VALUE (init);
644 /* End of special C++ code. */
646 /* Digest the specified initializer into an expression. */
648 value = digest_init (type, init, (tree *) 0);
650 /* Store the expression if valid; else report error. */
652 if (TREE_CODE (value) == ERROR_MARK)
654 else if (TREE_STATIC (decl)
655 && (! TREE_CONSTANT (value)
656 || ! initializer_constant_valid_p (value, TREE_TYPE (value))
658 /* A STATIC PUBLIC int variable doesn't have to be
659 run time inited when doing pic. (mrs) */
660 /* Since ctors and dtors are the only things that can
661 reference vtables, and they are always written down
662 the the vtable definition, we can leave the
663 vtables in initialized data space.
664 However, other initialized data cannot be initialized
665 this way. Instead a global file-level initializer
667 || (flag_pic && !DECL_VIRTUAL_P (decl) && TREE_PUBLIC (decl))
672 #if 0 /* No, that's C. jason 9/19/94 */
675 if (pedantic && TREE_CODE (value) == CONSTRUCTOR
676 /* Don't complain about non-constant initializers of
677 signature tables and signature pointers/references. */
678 && ! (TYPE_LANG_SPECIFIC (type)
679 && (IS_SIGNATURE (type)
680 || IS_SIGNATURE_POINTER (type)
681 || IS_SIGNATURE_REFERENCE (type))))
683 if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
684 pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
688 DECL_INITIAL (decl) = value;
692 /* Digest the parser output INIT as an initializer for type TYPE.
693 Return a C expression of type TYPE to represent the initial value.
695 If TAIL is nonzero, it points to a variable holding a list of elements
696 of which INIT is the first. We update the list stored there by
697 removing from the head all the elements that we use.
698 Normally this is only one; we use more than one element only if
699 TYPE is an aggregate and INIT is not a constructor. */
702 digest_init (type, init, tail)
703 tree type, init, *tail;
705 enum tree_code code = TREE_CODE (type);
706 tree element = NULL_TREE;
707 tree old_tail_contents;
708 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
709 tree node which has no TREE_TYPE. */
712 /* By default, assume we use one element from a list.
713 We correct this later in the sole case where it is not true. */
717 old_tail_contents = *tail;
718 *tail = TREE_CHAIN (*tail);
721 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
722 && TREE_VALUE (init) == error_mark_node))
723 return error_mark_node;
725 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
726 if (TREE_CODE (init) == NON_LVALUE_EXPR)
727 init = TREE_OPERAND (init, 0);
729 if (init && TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (type))
730 init = default_conversion (init);
732 if (init && TYPE_PTRMEMFUNC_P (type)
733 && ((TREE_CODE (init) == ADDR_EXPR
734 && ((TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE
735 && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE)
736 || TREE_CODE (TREE_OPERAND (init, 0)) == TREE_LIST))
737 || TREE_CODE (init) == TREE_LIST
738 || integer_zerop (init)
739 || (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))))
741 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), init, 0);
744 raw_constructor = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == 0;
746 if (init && raw_constructor
747 && CONSTRUCTOR_ELTS (init) != 0
748 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
750 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
751 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
752 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
753 element = TREE_OPERAND (element, 0);
754 if (element == error_mark_node)
758 /* Any type can be initialized from an expression of the same type,
759 optionally with braces. */
761 if (init && TREE_TYPE (init)
762 && (TYPE_MAIN_VARIANT (TREE_TYPE (init)) == type
763 || (code == ARRAY_TYPE && comptypes (TREE_TYPE (init), type, 1))))
765 if (pedantic && code == ARRAY_TYPE
766 && TREE_CODE (init) != STRING_CST)
767 pedwarn ("ANSI C++ forbids initializing array from array expression");
768 if (TREE_CODE (init) == CONST_DECL)
769 init = DECL_INITIAL (init);
770 else if (TREE_READONLY_DECL_P (init))
771 init = decl_constant_value (init);
775 if (element && (TREE_TYPE (element) == type
776 || (code == ARRAY_TYPE && TREE_TYPE (element)
777 && comptypes (TREE_TYPE (element), type, 1))))
779 if (pedantic && code == ARRAY_TYPE)
780 pedwarn ("ANSI C++ forbids initializing array from array expression");
781 if (pedantic && (code == RECORD_TYPE || code == UNION_TYPE))
782 pedwarn ("ANSI C++ forbids single nonscalar initializer with braces");
783 if (TREE_CODE (element) == CONST_DECL)
784 element = DECL_INITIAL (element);
785 else if (TREE_READONLY_DECL_P (element))
786 element = decl_constant_value (element);
790 /* Initialization of an array of chars from a string constant
791 optionally enclosed in braces. */
793 if (code == ARRAY_TYPE)
795 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
796 if ((typ1 == char_type_node
797 || typ1 == signed_char_type_node
798 || typ1 == unsigned_char_type_node
799 || typ1 == unsigned_wchar_type_node
800 || typ1 == signed_wchar_type_node)
801 && ((init && TREE_CODE (init) == STRING_CST)
802 || (element && TREE_CODE (element) == STRING_CST)))
804 tree string = element ? element : init;
806 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
808 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
810 error ("char-array initialized from wide string");
811 return error_mark_node;
813 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
815 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
817 error ("int-array initialized from non-wide string");
818 return error_mark_node;
822 && typ1 != char_type_node
823 && typ1 != signed_char_type_node
824 && typ1 != unsigned_char_type_node)
825 pedwarn ("ANSI C++ forbids string initializer except for `char' elements");
826 TREE_TYPE (string) = type;
827 if (TYPE_DOMAIN (type) != 0
828 && TREE_CONSTANT (TYPE_SIZE (type)))
831 = TREE_INT_CST_LOW (TYPE_SIZE (type));
832 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
833 /* In C it is ok to subtract 1 from the length of the string
834 because it's ok to ignore the terminating null char that is
835 counted in the length of the constant, but in C++ this would
837 if (size < TREE_STRING_LENGTH (string))
838 pedwarn ("initializer-string for array of chars is too long");
844 /* Handle scalar types, including conversions,
845 and signature pointers and references. */
847 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
848 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
849 || code == BOOLEAN_TYPE
850 || (code == RECORD_TYPE && ! raw_constructor
851 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))))
857 error ("initializer for scalar variable requires one element");
858 return error_mark_node;
862 while (TREE_CODE (init) == CONSTRUCTOR)
864 cp_pedwarn ("braces around scalar initializer for `%T'", type);
865 init = CONSTRUCTOR_ELTS (init);
866 if (TREE_CHAIN (init))
867 cp_pedwarn ("ignoring extra initializers for `%T'", type);
868 init = TREE_VALUE (init);
871 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
872 "initialization", NULL_TREE, 0);
875 /* Come here only for records and arrays (and unions with constructors). */
877 if (TYPE_SIZE (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
879 cp_error ("variable-sized object of type `%T' may not be initialized",
881 return error_mark_node;
884 if (code == ARRAY_TYPE || code == RECORD_TYPE || code == UNION_TYPE)
887 return process_init_constructor (type, init, (tree *)0);
888 else if (TYPE_NEEDS_CONSTRUCTING (type))
890 /* This can only be reached when caller is initializing
891 ARRAY_TYPE. In that case, we don't want to convert
892 INIT to TYPE. We will let `expand_vec_init' do it. */
897 *tail = old_tail_contents;
898 return process_init_constructor (type, 0, tail);
900 else if (flag_traditional)
901 /* Traditionally one can say `char x[100] = 0;'. */
902 return process_init_constructor (type,
903 build_nt (CONSTRUCTOR, 0,
904 tree_cons (0, init, 0)),
906 if (code != ARRAY_TYPE)
907 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
908 "initialization", NULL_TREE, 0);
911 error ("invalid initializer");
912 return error_mark_node;
915 /* Process a constructor for a variable of type TYPE.
916 The constructor elements may be specified either with INIT or with ELTS,
917 only one of which should be non-null.
919 If INIT is specified, it is a CONSTRUCTOR node which is specifically
920 and solely for initializing this datum.
922 If ELTS is specified, it is the address of a variable containing
923 a list of expressions. We take as many elements as we need
924 from the head of the list and update the list.
926 In the resulting constructor, TREE_CONSTANT is set if all elts are
927 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
928 constants that the assembler and linker can compute them. */
931 process_init_constructor (type, init, elts)
932 tree type, init, *elts;
935 /* List of the elements of the result constructor,
937 register tree members = NULL;
943 /* Make TAIL be the list of elements to use for the initialization,
944 no matter how the data was given to us. */
948 if (warn_missing_braces)
949 warning ("aggregate has a partly bracketed initializer");
953 tail = CONSTRUCTOR_ELTS (init);
955 /* Gobble as many elements as needed, and make a constructor or initial value
956 for each element of this aggregate. Chain them together in result.
957 If there are too few, use 0 for each scalar ultimate component. */
959 if (TREE_CODE (type) == ARRAY_TYPE)
961 tree domain = TYPE_DOMAIN (type);
966 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
967 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
970 len = -1; /* Take as many as there are */
972 for (i = 0; (len < 0 || i < len) && tail != 0; i++)
976 if (TREE_VALUE (tail) != 0)
979 next1 = digest_init (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
980 TREE_VALUE (tail), &tail1);
981 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))
982 && TYPE_MAIN_VARIANT (TREE_TYPE (type)) != TYPE_MAIN_VARIANT (TREE_TYPE (next1)))
984 /* The fact this needs to be done suggests this code needs
985 to be totally rewritten. */
986 next1 = convert_for_initialization (NULL_TREE, TREE_TYPE (type), next1, LOOKUP_NORMAL, "initialization", NULL_TREE, 0);
988 my_friendly_assert (tail1 == 0
989 || TREE_CODE (tail1) == TREE_LIST, 319);
990 if (tail == tail1 && len < 0)
992 error ("non-empty initializer for array of empty elements");
993 /* Just ignore what we were supposed to use. */
1000 next1 = error_mark_node;
1001 tail = TREE_CHAIN (tail);
1004 if (next1 == error_mark_node)
1006 else if (!TREE_CONSTANT (next1))
1008 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1010 members = tree_cons (NULL_TREE, next1, members);
1013 if (TREE_CODE (type) == RECORD_TYPE)
1015 register tree field;
1019 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
1021 sorry ("initializer list for object of class with virtual baseclasses");
1022 return error_mark_node;
1025 if (TYPE_BINFO_BASETYPES (type))
1027 sorry ("initializer list for object of class with baseclasses");
1028 return error_mark_node;
1031 if (TYPE_VIRTUAL_P (type))
1033 sorry ("initializer list for object using virtual functions");
1034 return error_mark_node;
1038 for (field = TYPE_FIELDS (type); field && tail;
1039 field = TREE_CHAIN (field))
1041 register tree next1;
1043 if (! DECL_NAME (field))
1045 members = tree_cons (field, integer_zero_node, members);
1049 if (TREE_CODE (field) != FIELD_DECL)
1052 if (TREE_VALUE (tail) != 0)
1056 next1 = digest_init (TREE_TYPE (field),
1057 TREE_VALUE (tail), &tail1);
1058 my_friendly_assert (tail1 == 0
1059 || TREE_CODE (tail1) == TREE_LIST, 320);
1064 next1 = error_mark_node;
1065 tail = TREE_CHAIN (tail);
1068 if (next1 == error_mark_node)
1070 else if (!TREE_CONSTANT (next1))
1072 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1074 members = tree_cons (field, next1, members);
1076 for (; field; field = TREE_CHAIN (field))
1078 if (TREE_CODE (field) != FIELD_DECL)
1081 /* Does this field have a default initialization? */
1082 if (DECL_INITIAL (field))
1084 register tree next1 = DECL_INITIAL (field);
1085 if (TREE_CODE (next1) == ERROR_MARK)
1087 else if (!TREE_CONSTANT (next1))
1089 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1091 members = tree_cons (field, next1, members);
1093 else if (TREE_READONLY (field))
1094 error ("uninitialized const member `%s'",
1095 IDENTIFIER_POINTER (DECL_NAME (field)));
1096 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
1097 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1098 error ("member `%s' with uninitialized const fields",
1099 IDENTIFIER_POINTER (DECL_NAME (field)));
1100 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1101 error ("member `%s' is uninitialized reference",
1102 IDENTIFIER_POINTER (DECL_NAME (field)));
1106 if (TREE_CODE (type) == UNION_TYPE)
1108 register tree field = TYPE_FIELDS (type);
1109 register tree next1;
1111 /* Find the first named field. ANSI decided in September 1990
1112 that only named fields count here. */
1113 while (field && DECL_NAME (field) == 0)
1114 field = TREE_CHAIN (field);
1116 /* If this element specifies a field, initialize via that field. */
1117 if (TREE_PURPOSE (tail) != NULL_TREE)
1121 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
1122 /* Handle the case of a call by build_c_cast. */
1123 field = TREE_PURPOSE (tail), win = 1;
1124 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
1125 error ("index value instead of field name in union initializer");
1129 for (temp = TYPE_FIELDS (type);
1131 temp = TREE_CHAIN (temp))
1132 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
1135 field = temp, win = 1;
1137 error ("no field `%s' in union being initialized",
1138 IDENTIFIER_POINTER (TREE_PURPOSE (tail)));
1141 TREE_VALUE (tail) = error_mark_node;
1143 else if (field == 0)
1145 cp_error ("union `%T' with no named members cannot be initialized",
1147 TREE_VALUE (tail) = error_mark_node;
1150 if (TREE_VALUE (tail) != 0)
1154 next1 = digest_init (TREE_TYPE (field),
1155 TREE_VALUE (tail), &tail1);
1156 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
1157 my_friendly_abort (357);
1162 next1 = error_mark_node;
1163 tail = TREE_CHAIN (tail);
1166 if (next1 == error_mark_node)
1168 else if (!TREE_CONSTANT (next1))
1170 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
1172 members = tree_cons (field, next1, members);
1175 /* If arguments were specified as a list, just remove the ones we used. */
1178 /* If arguments were specified as a constructor,
1179 complain unless we used all the elements of the constructor. */
1181 pedwarn ("excess elements in aggregate initializer");
1184 return error_mark_node;
1186 result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
1188 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1189 if (allconstant) TREE_CONSTANT (result) = 1;
1190 if (allconstant && allsimple) TREE_STATIC (result) = 1;
1194 /* Given a structure or union value DATUM, construct and return
1195 the structure or union component which results from narrowing
1196 that value by the types specified in TYPES. For example, given the
1199 class L { int ii; };
1200 class A : L { ... };
1201 class B : L { ... };
1202 class C : A, B { ... };
1210 x::C::A::L::ii refers to the ii member of the L part of
1211 of A part of the C object named by X. In this case,
1212 DATUM would be x, and TYPES would be a SCOPE_REF consisting of
1219 The last entry in the SCOPE_REF is always an IDENTIFIER_NODE.
1224 build_scoped_ref (datum, types)
1229 tree type = TREE_TYPE (datum);
1231 if (datum == error_mark_node)
1232 return error_mark_node;
1234 if (TREE_CODE (type) == REFERENCE_TYPE)
1235 type = TREE_TYPE (type);
1237 type = TYPE_MAIN_VARIANT (type);
1239 if (TREE_CODE (types) == SCOPE_REF)
1241 /* We have some work to do. */
1243 { tree type; struct type_chain *next; }
1244 *chain = NULL, *head = NULL, scratch;
1245 ref = build_unary_op (ADDR_EXPR, datum, 0);
1246 while (TREE_CODE (types) == SCOPE_REF)
1248 tree t = TREE_OPERAND (types, 1);
1249 if (is_aggr_typedef (t, 1))
1251 head = (struct type_chain *)alloca (sizeof (struct type_chain));
1252 head->type = IDENTIFIER_TYPE_VALUE (t);
1255 types = TREE_OPERAND (types, 0);
1257 else return error_mark_node;
1259 if (! is_aggr_typedef (types, 1))
1260 return error_mark_node;
1263 head->type = IDENTIFIER_TYPE_VALUE (types);
1268 tree binfo = chain->type;
1269 type = TREE_TYPE (TREE_TYPE (ref));
1270 if (binfo != TYPE_BINFO (type))
1272 binfo = get_binfo (binfo, type, 1);
1273 if (binfo == error_mark_node)
1274 return error_mark_node;
1276 return error_not_base_type (chain->type, type);
1277 ref = convert_pointer_to (binfo, ref);
1279 chain = chain->next;
1281 return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1284 /* This is an easy conversion. */
1285 if (is_aggr_typedef (types, 1))
1287 tree binfo = TYPE_BINFO (IDENTIFIER_TYPE_VALUE (types));
1288 if (binfo != TYPE_BINFO (type))
1290 binfo = get_binfo (binfo, type, 1);
1291 if (binfo == error_mark_node)
1292 return error_mark_node;
1294 return error_not_base_type (IDENTIFIER_TYPE_VALUE (types), type);
1297 switch (TREE_CODE (datum))
1302 case FIX_TRUNC_EXPR:
1303 case FIX_FLOOR_EXPR:
1304 case FIX_ROUND_EXPR:
1306 ref = convert_pointer_to (binfo,
1307 build_unary_op (ADDR_EXPR, TREE_OPERAND (datum, 0), 0));
1310 ref = convert_pointer_to (binfo,
1311 build_unary_op (ADDR_EXPR, datum, 0));
1313 return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1315 return error_mark_node;
1318 /* Build a reference to an object specified by the C++ `->' operator.
1319 Usually this just involves dereferencing the object, but if the
1320 `->' operator is overloaded, then such overloads must be
1321 performed until an object which does not have the `->' operator
1322 overloaded is found. An error is reported when circular pointer
1323 delegation is detected. */
1325 build_x_arrow (datum)
1328 tree types_memoized = NULL_TREE;
1329 register tree rval = datum;
1330 tree type = TREE_TYPE (rval);
1333 if (type == error_mark_node)
1334 return error_mark_node;
1336 if (TREE_CODE (rval) == OFFSET_REF)
1338 rval = resolve_offset_ref (datum);
1339 type = TREE_TYPE (rval);
1342 if (TREE_CODE (type) == REFERENCE_TYPE)
1344 rval = convert_from_reference (rval);
1345 type = TREE_TYPE (rval);
1348 if (IS_AGGR_TYPE (type) && TYPE_OVERLOADS_ARROW (type))
1350 while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, NULL_TREE, NULL_TREE)))
1352 if (rval == error_mark_node)
1353 return error_mark_node;
1355 if (value_member (TREE_TYPE (rval), types_memoized))
1357 error ("circular pointer delegation detected");
1358 return error_mark_node;
1362 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1367 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1368 last_rval = convert_from_reference (last_rval);
1371 last_rval = default_conversion (rval);
1373 /* Signature pointers are not dereferenced. */
1374 if (TYPE_LANG_SPECIFIC (TREE_TYPE (last_rval))
1375 && IS_SIGNATURE_POINTER (TREE_TYPE (last_rval)))
1378 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1379 return build_indirect_ref (last_rval, NULL_PTR);
1382 error ("result of `operator->()' yields non-pointer result");
1384 error ("base operand of `->' is not a pointer");
1385 return error_mark_node;
1388 /* Make an expression to refer to the COMPONENT field of
1389 structure or union value DATUM. COMPONENT is an arbitrary
1390 expression. DATUM has not already been checked out to be of
1393 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1394 return an object of member type to a method of the current class,
1395 but there is not yet enough typing information to know which one.
1396 As a special case, if there is only one method by that name,
1397 it is returned. Otherwise we return an expression which other
1398 routines will have to know how to deal with later. */
1400 build_m_component_ref (datum, component)
1401 tree datum, component;
1404 tree objtype = TREE_TYPE (datum);
1408 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1410 type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1415 component = build_indirect_ref (component, NULL_PTR);
1416 type = TREE_TYPE (component);
1417 rettype = TREE_TYPE (TREE_TYPE (component));
1420 if (datum == error_mark_node || component == error_mark_node)
1421 return error_mark_node;
1423 if (TREE_CODE (type) != OFFSET_TYPE && TREE_CODE (type) != METHOD_TYPE)
1425 cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'", component, type);
1426 return error_mark_node;
1429 if (TREE_CODE (objtype) == REFERENCE_TYPE)
1430 objtype = TREE_TYPE (objtype);
1431 objtype = TYPE_MAIN_VARIANT (objtype);
1433 if (! IS_AGGR_TYPE (objtype))
1435 cp_error ("cannot apply member pointer `%E' to `%E'", component, datum);
1436 cp_error ("which is of non-aggregate type `%T'", objtype);
1437 return error_mark_node;
1440 binfo = get_binfo (TYPE_METHOD_BASETYPE (type), objtype, 1);
1441 if (binfo == NULL_TREE)
1443 cp_error ("member type `%T::' incompatible with object type `%T'",
1444 TYPE_METHOD_BASETYPE (type), objtype);
1445 return error_mark_node;
1447 else if (binfo == error_mark_node)
1448 return error_mark_node;
1450 return build (OFFSET_REF, rettype, datum, component);
1453 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.
1455 Because we cannot tell whether this construct is really a call to a
1456 constructor or a request for a type conversion, we try both, and
1457 report any ambiguities we find. */
1459 build_functional_cast (exp, parms)
1463 /* This is either a call to a constructor,
1464 or a C cast in C++'s `functional' notation. */
1465 tree type, name = NULL_TREE;
1466 tree expr_as_ctor = NULL_TREE;
1468 if (exp == error_mark_node || parms == error_mark_node)
1469 return error_mark_node;
1471 if (TREE_CODE (exp) == IDENTIFIER_NODE)
1475 if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1476 /* Either an enum or an aggregate type. */
1477 type = IDENTIFIER_TYPE_VALUE (exp);
1480 type = lookup_name (exp, 1);
1481 if (!type || TREE_CODE (type) != TYPE_DECL)
1483 cp_error ("`%T' fails to be a typedef or built-in type", name);
1484 return error_mark_node;
1486 type = TREE_TYPE (type);
1492 if (IS_SIGNATURE (type))
1494 error ("signature type not allowed in cast or constructor expression");
1495 return error_mark_node;
1498 /* Prepare to evaluate as a call to a constructor. If this expression
1499 is actually used, for example,
1501 return X (arg1, arg2, ...);
1503 then the slot being initialized will be filled in. */
1505 if (name == NULL_TREE)
1507 name = TYPE_NAME (type);
1508 if (TREE_CODE (name) == TYPE_DECL)
1509 name = DECL_NESTED_TYPENAME (name);
1512 if (! IS_AGGR_TYPE (type))
1514 /* this must build a C cast */
1515 if (parms == NULL_TREE)
1516 parms = integer_zero_node;
1519 if (TREE_CHAIN (parms) != NULL_TREE)
1520 pedwarn ("initializer list being treated as compound expression");
1521 parms = build_compound_expr (parms);
1524 return build_c_cast (type, parms, 1);
1527 if (TYPE_SIZE (type) == NULL_TREE)
1529 cp_error ("type `%T' is not yet defined", type);
1530 return error_mark_node;
1533 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1534 return build_c_cast (type, parms, 1);
1536 expr_as_ctor = build_method_call (NULL_TREE, name, parms,
1537 NULL_TREE, LOOKUP_NORMAL);
1539 if (expr_as_ctor == error_mark_node)
1540 return error_mark_node;
1542 return build_cplus_new (type, expr_as_ctor, 1);
1545 /* Return the character string for the name that encodes the
1546 enumeral value VALUE in the domain TYPE. */
1548 enum_name_string (value, type)
1552 register tree values = TYPE_VALUES (type);
1553 register HOST_WIDE_INT intval = TREE_INT_CST_LOW (value);
1555 my_friendly_assert (TREE_CODE (type) == ENUMERAL_TYPE, 324);
1557 && TREE_INT_CST_LOW (TREE_VALUE (values)) != intval)
1558 values = TREE_CHAIN (values);
1559 if (values == NULL_TREE)
1561 char *buf = (char *)oballoc (16 + TYPE_NAME_LENGTH (type));
1563 /* Value must have been cast. */
1564 sprintf (buf, "(enum %s)%d",
1565 TYPE_NAME_STRING (type), intval);
1568 return IDENTIFIER_POINTER (TREE_PURPOSE (values));
1572 /* Print out a language-specific error message for
1573 (Pascal) case or (C) switch statements.
1574 CODE tells what sort of message to print.
1575 TYPE is the type of the switch index expression.
1576 NEW is the new value that we were trying to add.
1577 OLD is the old value that stopped us from adding it. */
1579 report_case_error (code, type, new_value, old_value)
1582 tree new_value, old_value;
1587 error ("case label not within a switch statement");
1589 error ("default label not within a switch statement");
1595 error ("multiple default labels in one switch");
1598 if (TREE_CODE (new_value) == RANGE_EXPR)
1599 if (TREE_CODE (old_value) == RANGE_EXPR)
1601 char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1602 if (TREE_CODE (type) == ENUMERAL_TYPE)
1603 sprintf (buf, "overlapping ranges [%s..%s], [%s..%s] in case expression",
1604 enum_name_string (TREE_OPERAND (new_value, 0), type),
1605 enum_name_string (TREE_OPERAND (new_value, 1), type),
1606 enum_name_string (TREE_OPERAND (old_value, 0), type),
1607 enum_name_string (TREE_OPERAND (old_value, 1), type));
1609 sprintf (buf, "overlapping ranges [%d..%d], [%d..%d] in case expression",
1610 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1611 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1612 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1613 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)));
1618 char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1619 if (TREE_CODE (type) == ENUMERAL_TYPE)
1620 sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
1621 enum_name_string (TREE_OPERAND (new_value, 0), type),
1622 enum_name_string (TREE_OPERAND (new_value, 1), type),
1623 enum_name_string (old_value, type));
1625 sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1626 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1627 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1628 TREE_INT_CST_LOW (old_value));
1631 else if (TREE_CODE (old_value) == RANGE_EXPR)
1633 char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1634 if (TREE_CODE (type) == ENUMERAL_TYPE)
1635 sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
1636 enum_name_string (TREE_OPERAND (old_value, 0), type),
1637 enum_name_string (TREE_OPERAND (old_value, 1), type),
1638 enum_name_string (new_value, type));
1640 sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1641 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1642 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)),
1643 TREE_INT_CST_LOW (new_value));
1648 if (TREE_CODE (type) == ENUMERAL_TYPE)
1649 error ("duplicate label `%s' in switch statement",
1650 enum_name_string (new_value, type));
1652 error ("duplicate label (%d) in switch statement",
1653 TREE_INT_CST_LOW (new_value));
1658 if (TREE_CODE (type) == ENUMERAL_TYPE)
1659 warning ("case value out of range for enum %s",
1660 TYPE_NAME_STRING (type));
1662 warning ("case value out of range");
1666 if (TREE_CODE (type) == ENUMERAL_TYPE)
1667 error ("range values `%s' and `%s' reversed",
1668 enum_name_string (new_value, type),
1669 enum_name_string (old_value, type));
1671 error ("range values reversed");