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)
540 /* Take care of C++ business up here. */
541 type = TYPE_MAIN_VARIANT (type);
543 /* implicitly tests if IS_AGGR_TYPE. */
544 if (TYPE_NEEDS_CONSTRUCTING (type) && TREE_CODE (init) != CONSTRUCTOR)
545 my_friendly_abort (109);
546 else if (IS_AGGR_TYPE (type))
548 /* Although we are not allowed to declare variables of signature
549 type, we complain about a possible constructor call in such a
550 declaration as well. */
551 if (TREE_CODE (init) == TREE_LIST
552 && IS_SIGNATURE (type))
554 cp_error ("constructor syntax cannot be used with signature type `%T'",
556 init = error_mark_node;
558 else if (TREE_CODE (init) == TREE_LIST)
560 cp_error ("constructor syntax used, but no constructor declared for type `%T'", type);
561 init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
564 if (TREE_CODE (init) == CONSTRUCTOR)
570 /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
571 if (CLASSTYPE_N_BASECLASSES (type))
572 cp_error_at ("initializer list construction invalid for derived class object `%D'", decl);
573 if (CLASSTYPE_VTBL_PTR (type))
574 cp_error_at ("initializer list construction invalid for polymorphic class object `%D'", decl);
575 if (TYPE_NEEDS_CONSTRUCTING (type))
577 cp_error_at ("initializer list construction invalid for `%D'", decl);
578 error ("due to the presence of a constructor");
580 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
581 if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
583 cp_error_at ("initializer list construction invalid for `%D'", decl);
584 cp_error_at ("due to non-public access of member `%D'", field);
586 funcs = TYPE_METHODS (type);
588 for (func = 0; func < TREE_VEC_LENGTH (funcs); func++)
590 field = TREE_VEC_ELT (funcs, func);
591 if (field && (TREE_PRIVATE (field) || TREE_PROTECTED (field)))
593 cp_error_at ("initializer list construction invalid for `%D'", decl);
594 cp_error_at ("due to non-public access of member `%D'", field);
600 else if (TREE_CODE (init) == TREE_LIST
601 && TREE_TYPE (init) != unknown_type_node)
603 if (TREE_CODE (decl) == RESULT_DECL)
605 if (TREE_CHAIN (init))
607 warning ("comma expression used to initialize return value");
608 init = build_compound_expr (init);
611 init = TREE_VALUE (init);
613 else if (TREE_TYPE (init) != 0
614 && TREE_CODE (TREE_TYPE (init)) == OFFSET_TYPE)
616 /* Use the type of our variable to instantiate
617 the type of our initializer. */
618 init = instantiate_type (type, init, 1);
620 else if (TREE_CODE (init) == TREE_LIST
621 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
623 error ("cannot initialize arrays using this syntax");
628 /* We get here with code like `int a (2);' */
630 if (TREE_CHAIN (init) != NULL_TREE)
632 pedwarn ("initializer list being treated as compound expression");
633 init = build_compound_expr (init);
636 init = TREE_VALUE (init);
640 /* End of special C++ code. */
642 /* Digest the specified initializer into an expression. */
644 value = digest_init (type, init, (tree *) 0);
646 /* Store the expression if valid; else report error. */
648 if (TREE_CODE (value) == ERROR_MARK)
650 else if (TREE_STATIC (decl)
651 && (! TREE_CONSTANT (value)
652 || ! initializer_constant_valid_p (value, TREE_TYPE (value))
654 /* A STATIC PUBLIC int variable doesn't have to be
655 run time inited when doing pic. (mrs) */
656 /* Since ctors and dtors are the only things that can
657 reference vtables, and they are always written down
658 the the vtable definition, we can leave the
659 vtables in initialized data space.
660 However, other initialized data cannot be initialized
661 this way. Instead a global file-level initializer
663 || (flag_pic && !DECL_VIRTUAL_P (decl) && TREE_PUBLIC (decl))
668 #if 0 /* No, that's C. jason 9/19/94 */
671 if (pedantic && TREE_CODE (value) == CONSTRUCTOR
672 /* Don't complain about non-constant initializers of
673 signature tables and signature pointers/references. */
674 && ! (TYPE_LANG_SPECIFIC (type)
675 && (IS_SIGNATURE (type)
676 || IS_SIGNATURE_POINTER (type)
677 || IS_SIGNATURE_REFERENCE (type))))
679 if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
680 pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
684 DECL_INITIAL (decl) = value;
688 /* Digest the parser output INIT as an initializer for type TYPE.
689 Return a C expression of type TYPE to represent the initial value.
691 If TAIL is nonzero, it points to a variable holding a list of elements
692 of which INIT is the first. We update the list stored there by
693 removing from the head all the elements that we use.
694 Normally this is only one; we use more than one element only if
695 TYPE is an aggregate and INIT is not a constructor. */
698 digest_init (type, init, tail)
699 tree type, init, *tail;
701 enum tree_code code = TREE_CODE (type);
702 tree element = NULL_TREE;
703 tree old_tail_contents;
704 /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
705 tree node which has no TREE_TYPE. */
708 /* By default, assume we use one element from a list.
709 We correct this later in the sole case where it is not true. */
713 old_tail_contents = *tail;
714 *tail = TREE_CHAIN (*tail);
717 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
718 && TREE_VALUE (init) == error_mark_node))
719 return error_mark_node;
721 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
722 if (TREE_CODE (init) == NON_LVALUE_EXPR)
723 init = TREE_OPERAND (init, 0);
725 if (init && TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (type))
726 init = default_conversion (init);
728 if (init && TYPE_PTRMEMFUNC_P (type)
729 && ((TREE_CODE (init) == ADDR_EXPR
730 && ((TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE
731 && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE)
732 || TREE_CODE (TREE_OPERAND (init, 0)) == TREE_LIST))
733 || TREE_CODE (init) == TREE_LIST
734 || integer_zerop (init)
735 || (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))))
737 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), init, 0);
740 raw_constructor = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == 0;
742 if (init && raw_constructor
743 && CONSTRUCTOR_ELTS (init) != 0
744 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
746 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
747 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
748 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
749 element = TREE_OPERAND (element, 0);
750 if (element == error_mark_node)
754 /* Any type can be initialized from an expression of the same type,
755 optionally with braces. */
757 if (init && TREE_TYPE (init)
758 && (TYPE_MAIN_VARIANT (TREE_TYPE (init)) == type
759 || (code == ARRAY_TYPE && comptypes (TREE_TYPE (init), type, 1))))
761 if (pedantic && code == ARRAY_TYPE
762 && TREE_CODE (init) != STRING_CST)
763 pedwarn ("ANSI C++ forbids initializing array from array expression");
764 if (TREE_CODE (init) == CONST_DECL)
765 init = DECL_INITIAL (init);
766 else if (TREE_READONLY_DECL_P (init))
767 init = decl_constant_value (init);
771 if (element && (TREE_TYPE (element) == type
772 || (code == ARRAY_TYPE && TREE_TYPE (element)
773 && comptypes (TREE_TYPE (element), type, 1))))
775 if (pedantic && code == ARRAY_TYPE)
776 pedwarn ("ANSI C++ forbids initializing array from array expression");
777 if (pedantic && (code == RECORD_TYPE || code == UNION_TYPE))
778 pedwarn ("ANSI C++ forbids single nonscalar initializer with braces");
779 if (TREE_CODE (element) == CONST_DECL)
780 element = DECL_INITIAL (element);
781 else if (TREE_READONLY_DECL_P (element))
782 element = decl_constant_value (element);
786 /* Initialization of an array of chars from a string constant
787 optionally enclosed in braces. */
789 if (code == ARRAY_TYPE)
791 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
792 if ((typ1 == char_type_node
793 || typ1 == signed_char_type_node
794 || typ1 == unsigned_char_type_node
795 || typ1 == unsigned_wchar_type_node
796 || typ1 == signed_wchar_type_node)
797 && ((init && TREE_CODE (init) == STRING_CST)
798 || (element && TREE_CODE (element) == STRING_CST)))
800 tree string = element ? element : init;
802 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
804 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
806 error ("char-array initialized from wide string");
807 return error_mark_node;
809 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
811 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
813 error ("int-array initialized from non-wide string");
814 return error_mark_node;
818 && typ1 != char_type_node
819 && typ1 != signed_char_type_node
820 && typ1 != unsigned_char_type_node)
821 pedwarn ("ANSI C++ forbids string initializer except for `char' elements");
822 TREE_TYPE (string) = type;
823 if (TYPE_DOMAIN (type) != 0
824 && TREE_CONSTANT (TYPE_SIZE (type)))
827 = TREE_INT_CST_LOW (TYPE_SIZE (type));
828 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
829 /* In C it is ok to subtract 1 from the length of the string
830 because it's ok to ignore the terminating null char that is
831 counted in the length of the constant, but in C++ this would
833 if (size < TREE_STRING_LENGTH (string))
834 pedwarn ("initializer-string for array of chars is too long");
840 /* Handle scalar types, including conversions,
841 and signature pointers and references. */
843 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
844 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
845 || code == BOOLEAN_TYPE
846 || (code == RECORD_TYPE && ! raw_constructor
847 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))))
853 error ("initializer for scalar variable requires one element");
854 return error_mark_node;
858 while (TREE_CODE (init) == CONSTRUCTOR)
860 cp_pedwarn ("braces around scalar initializer for `%T'", type);
861 init = CONSTRUCTOR_ELTS (init);
862 if (TREE_CHAIN (init))
863 cp_pedwarn ("ignoring extra initializers for `%T'", type);
864 init = TREE_VALUE (init);
867 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
868 "initialization", NULL_TREE, 0);
871 /* Come here only for records and arrays (and unions with constructors). */
873 if (TYPE_SIZE (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
875 cp_error ("variable-sized object of type `%T' may not be initialized",
877 return error_mark_node;
880 if (code == ARRAY_TYPE || code == RECORD_TYPE || code == UNION_TYPE)
883 return process_init_constructor (type, init, (tree *)0);
884 else if (TYPE_NEEDS_CONSTRUCTING (type))
886 /* This can only be reached when caller is initializing
887 ARRAY_TYPE. In that case, we don't want to convert
888 INIT to TYPE. We will let `expand_vec_init' do it. */
893 *tail = old_tail_contents;
894 return process_init_constructor (type, 0, tail);
896 else if (flag_traditional)
897 /* Traditionally one can say `char x[100] = 0;'. */
898 return process_init_constructor (type,
899 build_nt (CONSTRUCTOR, 0,
900 tree_cons (0, init, 0)),
902 if (code != ARRAY_TYPE)
903 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
904 "initialization", NULL_TREE, 0);
907 error ("invalid initializer");
908 return error_mark_node;
911 /* Process a constructor for a variable of type TYPE.
912 The constructor elements may be specified either with INIT or with ELTS,
913 only one of which should be non-null.
915 If INIT is specified, it is a CONSTRUCTOR node which is specifically
916 and solely for initializing this datum.
918 If ELTS is specified, it is the address of a variable containing
919 a list of expressions. We take as many elements as we need
920 from the head of the list and update the list.
922 In the resulting constructor, TREE_CONSTANT is set if all elts are
923 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
924 constants that the assembler and linker can compute them. */
927 process_init_constructor (type, init, elts)
928 tree type, init, *elts;
931 /* List of the elements of the result constructor,
933 register tree members = NULL;
939 /* Make TAIL be the list of elements to use for the initialization,
940 no matter how the data was given to us. */
944 if (warn_missing_braces)
945 warning ("aggregate has a partly bracketed initializer");
949 tail = CONSTRUCTOR_ELTS (init);
951 /* Gobble as many elements as needed, and make a constructor or initial value
952 for each element of this aggregate. Chain them together in result.
953 If there are too few, use 0 for each scalar ultimate component. */
955 if (TREE_CODE (type) == ARRAY_TYPE)
957 tree domain = TYPE_DOMAIN (type);
962 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
963 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
966 len = -1; /* Take as many as there are */
968 for (i = 0; (len < 0 || i < len) && tail != 0; i++)
972 if (TREE_VALUE (tail) != 0)
975 next1 = digest_init (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
976 TREE_VALUE (tail), &tail1);
977 my_friendly_assert (tail1 == 0
978 || TREE_CODE (tail1) == TREE_LIST, 319);
979 if (tail == tail1 && len < 0)
981 error ("non-empty initializer for array of empty elements");
982 /* Just ignore what we were supposed to use. */
989 next1 = error_mark_node;
990 tail = TREE_CHAIN (tail);
993 if (next1 == error_mark_node)
995 else if (!TREE_CONSTANT (next1))
997 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
999 members = tree_cons (NULL_TREE, next1, members);
1002 if (TREE_CODE (type) == RECORD_TYPE)
1004 register tree field;
1008 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
1010 sorry ("initializer list for object of class with virtual baseclasses");
1011 return error_mark_node;
1014 if (TYPE_BINFO_BASETYPES (type))
1016 sorry ("initializer list for object of class with baseclasses");
1017 return error_mark_node;
1020 if (TYPE_VIRTUAL_P (type))
1022 sorry ("initializer list for object using virtual functions");
1023 return error_mark_node;
1027 for (field = TYPE_FIELDS (type); field && tail;
1028 field = TREE_CHAIN (field))
1030 register tree next1;
1032 if (! DECL_NAME (field))
1034 members = tree_cons (field, integer_zero_node, members);
1038 if (TREE_CODE (field) != FIELD_DECL)
1041 if (TREE_VALUE (tail) != 0)
1045 next1 = digest_init (TREE_TYPE (field),
1046 TREE_VALUE (tail), &tail1);
1047 my_friendly_assert (tail1 == 0
1048 || TREE_CODE (tail1) == TREE_LIST, 320);
1053 next1 = error_mark_node;
1054 tail = TREE_CHAIN (tail);
1057 if (next1 == error_mark_node)
1059 else if (!TREE_CONSTANT (next1))
1061 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1063 members = tree_cons (field, next1, members);
1065 for (; field; field = TREE_CHAIN (field))
1067 if (TREE_CODE (field) != FIELD_DECL)
1070 /* Does this field have a default initialization? */
1071 if (DECL_INITIAL (field))
1073 register tree next1 = DECL_INITIAL (field);
1074 if (TREE_CODE (next1) == ERROR_MARK)
1076 else if (!TREE_CONSTANT (next1))
1078 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1080 members = tree_cons (field, next1, members);
1082 else if (TREE_READONLY (field))
1083 error ("uninitialized const member `%s'",
1084 IDENTIFIER_POINTER (DECL_NAME (field)));
1085 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
1086 && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1087 error ("member `%s' with uninitialized const fields",
1088 IDENTIFIER_POINTER (DECL_NAME (field)));
1089 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1090 error ("member `%s' is uninitialized reference",
1091 IDENTIFIER_POINTER (DECL_NAME (field)));
1095 if (TREE_CODE (type) == UNION_TYPE)
1097 register tree field = TYPE_FIELDS (type);
1098 register tree next1;
1100 /* Find the first named field. ANSI decided in September 1990
1101 that only named fields count here. */
1102 while (field && DECL_NAME (field) == 0)
1103 field = TREE_CHAIN (field);
1105 /* If this element specifies a field, initialize via that field. */
1106 if (TREE_PURPOSE (tail) != NULL_TREE)
1110 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
1111 /* Handle the case of a call by build_c_cast. */
1112 field = TREE_PURPOSE (tail), win = 1;
1113 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
1114 error ("index value instead of field name in union initializer");
1118 for (temp = TYPE_FIELDS (type);
1120 temp = TREE_CHAIN (temp))
1121 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
1124 field = temp, win = 1;
1126 error ("no field `%s' in union being initialized",
1127 IDENTIFIER_POINTER (TREE_PURPOSE (tail)));
1130 TREE_VALUE (tail) = error_mark_node;
1132 else if (field == 0)
1134 cp_error ("union `%T' with no named members cannot be initialized",
1136 TREE_VALUE (tail) = error_mark_node;
1139 if (TREE_VALUE (tail) != 0)
1143 next1 = digest_init (TREE_TYPE (field),
1144 TREE_VALUE (tail), &tail1);
1145 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
1146 my_friendly_abort (357);
1151 next1 = error_mark_node;
1152 tail = TREE_CHAIN (tail);
1155 if (next1 == error_mark_node)
1157 else if (!TREE_CONSTANT (next1))
1159 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
1161 members = tree_cons (field, next1, members);
1164 /* If arguments were specified as a list, just remove the ones we used. */
1167 /* If arguments were specified as a constructor,
1168 complain unless we used all the elements of the constructor. */
1170 pedwarn ("excess elements in aggregate initializer");
1173 return error_mark_node;
1175 result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
1177 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1178 if (allconstant) TREE_CONSTANT (result) = 1;
1179 if (allconstant && allsimple) TREE_STATIC (result) = 1;
1183 /* Given a structure or union value DATUM, construct and return
1184 the structure or union component which results from narrowing
1185 that value by the types specified in TYPES. For example, given the
1188 class L { int ii; };
1189 class A : L { ... };
1190 class B : L { ... };
1191 class C : A, B { ... };
1199 x::C::A::L::ii refers to the ii member of the L part of
1200 of A part of the C object named by X. In this case,
1201 DATUM would be x, and TYPES would be a SCOPE_REF consisting of
1208 The last entry in the SCOPE_REF is always an IDENTIFIER_NODE.
1213 build_scoped_ref (datum, types)
1218 tree type = TREE_TYPE (datum);
1220 if (datum == error_mark_node)
1221 return error_mark_node;
1223 if (TREE_CODE (type) == REFERENCE_TYPE)
1224 type = TREE_TYPE (type);
1226 type = TYPE_MAIN_VARIANT (type);
1228 if (TREE_CODE (types) == SCOPE_REF)
1230 /* We have some work to do. */
1232 { tree type; struct type_chain *next; }
1233 *chain = NULL, *head = NULL, scratch;
1234 ref = build_unary_op (ADDR_EXPR, datum, 0);
1235 while (TREE_CODE (types) == SCOPE_REF)
1237 tree t = TREE_OPERAND (types, 1);
1238 if (is_aggr_typedef (t, 1))
1240 head = (struct type_chain *)alloca (sizeof (struct type_chain));
1241 head->type = IDENTIFIER_TYPE_VALUE (t);
1244 types = TREE_OPERAND (types, 0);
1246 else return error_mark_node;
1248 if (! is_aggr_typedef (types, 1))
1249 return error_mark_node;
1252 head->type = IDENTIFIER_TYPE_VALUE (types);
1257 tree binfo = chain->type;
1258 type = TREE_TYPE (TREE_TYPE (ref));
1259 if (binfo != TYPE_BINFO (type))
1261 binfo = get_binfo (binfo, type, 1);
1262 if (binfo == error_mark_node)
1263 return error_mark_node;
1265 return error_not_base_type (chain->type, type);
1266 ref = convert_pointer_to (binfo, ref);
1268 chain = chain->next;
1270 return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1273 /* This is an easy conversion. */
1274 if (is_aggr_typedef (types, 1))
1276 tree binfo = TYPE_BINFO (IDENTIFIER_TYPE_VALUE (types));
1277 if (binfo != TYPE_BINFO (type))
1279 binfo = get_binfo (binfo, type, 1);
1280 if (binfo == error_mark_node)
1281 return error_mark_node;
1283 return error_not_base_type (IDENTIFIER_TYPE_VALUE (types), type);
1286 switch (TREE_CODE (datum))
1291 case FIX_TRUNC_EXPR:
1292 case FIX_FLOOR_EXPR:
1293 case FIX_ROUND_EXPR:
1295 ref = convert_pointer_to (binfo,
1296 build_unary_op (ADDR_EXPR, TREE_OPERAND (datum, 0), 0));
1299 ref = convert_pointer_to (binfo,
1300 build_unary_op (ADDR_EXPR, datum, 0));
1302 return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1304 return error_mark_node;
1307 /* Build a reference to an object specified by the C++ `->' operator.
1308 Usually this just involves dereferencing the object, but if the
1309 `->' operator is overloaded, then such overloads must be
1310 performed until an object which does not have the `->' operator
1311 overloaded is found. An error is reported when circular pointer
1312 delegation is detected. */
1314 build_x_arrow (datum)
1317 tree types_memoized = NULL_TREE;
1318 register tree rval = datum;
1319 tree type = TREE_TYPE (rval);
1322 if (type == error_mark_node)
1323 return error_mark_node;
1325 if (TREE_CODE (rval) == OFFSET_REF)
1327 rval = resolve_offset_ref (datum);
1328 type = TREE_TYPE (rval);
1331 if (TREE_CODE (type) == REFERENCE_TYPE)
1333 rval = convert_from_reference (rval);
1334 type = TREE_TYPE (rval);
1337 if (IS_AGGR_TYPE (type) && TYPE_OVERLOADS_ARROW (type))
1339 while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, NULL_TREE, NULL_TREE)))
1341 if (rval == error_mark_node)
1342 return error_mark_node;
1344 if (value_member (TREE_TYPE (rval), types_memoized))
1346 error ("circular pointer delegation detected");
1347 return error_mark_node;
1351 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1356 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1357 last_rval = convert_from_reference (last_rval);
1360 last_rval = default_conversion (rval);
1362 /* Signature pointers are not dereferenced. */
1363 if (TYPE_LANG_SPECIFIC (TREE_TYPE (last_rval))
1364 && IS_SIGNATURE_POINTER (TREE_TYPE (last_rval)))
1367 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1368 return build_indirect_ref (last_rval, NULL_PTR);
1371 error ("result of `operator->()' yields non-pointer result");
1373 error ("base operand of `->' is not a pointer");
1374 return error_mark_node;
1377 /* Make an expression to refer to the COMPONENT field of
1378 structure or union value DATUM. COMPONENT is an arbitrary
1379 expression. DATUM has not already been checked out to be of
1382 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1383 return an object of member type to a method of the current class,
1384 but there is not yet enough typing information to know which one.
1385 As a special case, if there is only one method by that name,
1386 it is returned. Otherwise we return an expression which other
1387 routines will have to know how to deal with later. */
1389 build_m_component_ref (datum, component)
1390 tree datum, component;
1393 tree objtype = TREE_TYPE (datum);
1396 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1398 type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1403 component = build_indirect_ref (component, NULL_PTR);
1404 type = TREE_TYPE (component);
1405 rettype = TREE_TYPE (TREE_TYPE (component));
1408 if (datum == error_mark_node || component == error_mark_node)
1409 return error_mark_node;
1411 if (TREE_CODE (type) != OFFSET_TYPE && TREE_CODE (type) != METHOD_TYPE)
1413 cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'", component, type);
1414 return error_mark_node;
1417 if (TREE_CODE (objtype) == REFERENCE_TYPE)
1418 objtype = TREE_TYPE (objtype);
1419 objtype = TYPE_MAIN_VARIANT (objtype);
1421 if (! IS_AGGR_TYPE (objtype))
1423 cp_error ("cannot apply member pointer `%E' to `%E'", component, datum);
1424 cp_error ("which is of non-aggregate type `%T'", objtype);
1425 return error_mark_node;
1428 if (! comptypes (TYPE_METHOD_BASETYPE (type), objtype, 0))
1430 cp_error ("member type `%T::' incompatible with object type `%T'",
1431 TYPE_METHOD_BASETYPE (type), objtype);
1432 return error_mark_node;
1435 return build (OFFSET_REF, rettype, datum, component);
1438 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.
1440 Because we cannot tell whether this construct is really a call to a
1441 constructor or a request for a type conversion, we try both, and
1442 report any ambiguities we find. */
1444 build_functional_cast (exp, parms)
1448 /* This is either a call to a constructor,
1449 or a C cast in C++'s `functional' notation. */
1450 tree type, name = NULL_TREE;
1451 tree expr_as_ctor = NULL_TREE;
1453 if (exp == error_mark_node || parms == error_mark_node)
1454 return error_mark_node;
1456 if (TREE_CODE (exp) == IDENTIFIER_NODE)
1460 if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1461 /* Either an enum or an aggregate type. */
1462 type = IDENTIFIER_TYPE_VALUE (exp);
1465 type = lookup_name (exp, 1);
1466 if (!type || TREE_CODE (type) != TYPE_DECL)
1468 cp_error ("`%T' fails to be a typedef or built-in type", name);
1469 return error_mark_node;
1471 type = TREE_TYPE (type);
1477 if (IS_SIGNATURE (type))
1479 error ("signature type not allowed in cast or constructor expression");
1480 return error_mark_node;
1483 /* Prepare to evaluate as a call to a constructor. If this expression
1484 is actually used, for example,
1486 return X (arg1, arg2, ...);
1488 then the slot being initialized will be filled in. */
1490 if (name == NULL_TREE)
1492 name = TYPE_NAME (type);
1493 if (TREE_CODE (name) == TYPE_DECL)
1494 name = DECL_NAME (name);
1497 if (! IS_AGGR_TYPE (type))
1499 /* this must build a C cast */
1500 if (parms == NULL_TREE)
1501 parms = integer_zero_node;
1504 if (TREE_CHAIN (parms) != NULL_TREE)
1505 pedwarn ("initializer list being treated as compound expression");
1506 parms = build_compound_expr (parms);
1509 return build_c_cast (type, parms, 1);
1512 if (TYPE_SIZE (type) == NULL_TREE)
1514 cp_error ("type `%T' is not yet defined", type);
1515 return error_mark_node;
1518 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1519 return build_c_cast (type, parms, 1);
1521 expr_as_ctor = build_method_call (NULL_TREE, name, parms,
1522 NULL_TREE, LOOKUP_NORMAL);
1524 if (expr_as_ctor == error_mark_node)
1525 return error_mark_node;
1527 if (current_function_decl)
1528 return build_cplus_new (type, expr_as_ctor, 1);
1531 register tree parm = TREE_OPERAND (expr_as_ctor, 1);
1533 /* Initializers for static variables and parameters have
1534 to handle doing the initialization and cleanup themselves. */
1535 my_friendly_assert (TREE_CODE (expr_as_ctor) == CALL_EXPR, 322);
1537 /* The following assertion fails in cases where we are initializing
1538 a static member variable of a particular instance of a template
1539 class with a call to a constructor of the given instance, as in:
1541 TMPL<int> object = TMPL<int>();
1543 Curiously, the assertion does not fail if we do the same thing
1544 for a static member of a non-template class, as in:
1548 I can't see why we should care here whether or not the initializer
1549 expression involves a call to `new', so for the time being, it
1550 seems best to just avoid doing this assertion. */
1551 my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)), 323);
1553 TREE_VALUE (parm) = NULL_TREE;
1554 expr_as_ctor = build_indirect_ref (expr_as_ctor, NULL_PTR);
1555 TREE_HAS_CONSTRUCTOR (expr_as_ctor) = 1;
1557 return expr_as_ctor;
1560 /* Return the character string for the name that encodes the
1561 enumeral value VALUE in the domain TYPE. */
1563 enum_name_string (value, type)
1567 register tree values = TYPE_VALUES (type);
1568 register HOST_WIDE_INT intval = TREE_INT_CST_LOW (value);
1570 my_friendly_assert (TREE_CODE (type) == ENUMERAL_TYPE, 324);
1572 && TREE_INT_CST_LOW (TREE_VALUE (values)) != intval)
1573 values = TREE_CHAIN (values);
1574 if (values == NULL_TREE)
1576 char *buf = (char *)oballoc (16 + TYPE_NAME_LENGTH (type));
1578 /* Value must have been cast. */
1579 sprintf (buf, "(enum %s)%d",
1580 TYPE_NAME_STRING (type), intval);
1583 return IDENTIFIER_POINTER (TREE_PURPOSE (values));
1587 /* Print out a language-specific error message for
1588 (Pascal) case or (C) switch statements.
1589 CODE tells what sort of message to print.
1590 TYPE is the type of the switch index expression.
1591 NEW is the new value that we were trying to add.
1592 OLD is the old value that stopped us from adding it. */
1594 report_case_error (code, type, new_value, old_value)
1597 tree new_value, old_value;
1602 error ("case label not within a switch statement");
1604 error ("default label not within a switch statement");
1610 error ("multiple default labels in one switch");
1613 if (TREE_CODE (new_value) == RANGE_EXPR)
1614 if (TREE_CODE (old_value) == RANGE_EXPR)
1616 char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1617 if (TREE_CODE (type) == ENUMERAL_TYPE)
1618 sprintf (buf, "overlapping ranges [%s..%s], [%s..%s] in case expression",
1619 enum_name_string (TREE_OPERAND (new_value, 0), type),
1620 enum_name_string (TREE_OPERAND (new_value, 1), type),
1621 enum_name_string (TREE_OPERAND (old_value, 0), type),
1622 enum_name_string (TREE_OPERAND (old_value, 1), type));
1624 sprintf (buf, "overlapping ranges [%d..%d], [%d..%d] in case expression",
1625 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1626 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1627 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1628 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)));
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 (new_value, 0), type),
1637 enum_name_string (TREE_OPERAND (new_value, 1), type),
1638 enum_name_string (old_value, type));
1640 sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1641 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1642 TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1643 TREE_INT_CST_LOW (old_value));
1646 else if (TREE_CODE (old_value) == RANGE_EXPR)
1648 char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1649 if (TREE_CODE (type) == ENUMERAL_TYPE)
1650 sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
1651 enum_name_string (TREE_OPERAND (old_value, 0), type),
1652 enum_name_string (TREE_OPERAND (old_value, 1), type),
1653 enum_name_string (new_value, type));
1655 sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1656 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1657 TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)),
1658 TREE_INT_CST_LOW (new_value));
1663 if (TREE_CODE (type) == ENUMERAL_TYPE)
1664 error ("duplicate label `%s' in switch statement",
1665 enum_name_string (new_value, type));
1667 error ("duplicate label (%d) in switch statement",
1668 TREE_INT_CST_LOW (new_value));
1673 if (TREE_CODE (type) == ENUMERAL_TYPE)
1674 warning ("case value out of range for enum %s",
1675 TYPE_NAME_STRING (type));
1677 warning ("case value out of range");
1681 if (TREE_CODE (type) == ENUMERAL_TYPE)
1682 error ("range values `%s' and `%s' reversed",
1683 enum_name_string (new_value, type),
1684 enum_name_string (old_value, type));
1686 error ("range values reversed");