2002-11-05  Tom Tromey  <tromey@redhat.com>

	Fix for PR java/6388.
	* lex.h (JAVA_INTEGRAL_RANGE_ERROR): Wrap in do...while.
	* java-tree.h (enum java_tree_index): New values
	JTI_DECIMAL_INT_MAX_NODE, JTI_DECIMAL_LONG_MAX_NODE.
	(decimal_int_max, decimal_long_max): New defines.
	* lex.c (yylex): Rewrote range checking.  Sign extend literals.
	(error_if_numeric_overflow): Rewrote range checking.
	* decl.c (java_init_decl_processing): Initialize decimal_int_max,
	decimal_long_max.

--- gcc/java/decl.c	2 Nov 2002 21:29:36 -0000	1.134
+++ gcc/java/decl.c	6 Nov 2002 00:01:00 -0000	1.135
@@ -454,6 +454,20 @@ java_init_decl_processing ()
   integer_four_node = build_int_2 (4, 0);
   integer_minus_one_node = build_int_2 (-1, -1);
 
+  /* A few values used for range checking in the lexer.  */
+  decimal_int_max = build_int_2 (0x80000000, 0);
+  TREE_TYPE (decimal_int_max) = unsigned_int_type_node;
+#if HOST_BITS_PER_WIDE_INT == 64
+  decimal_long_max = build_int_2 (0x8000000000000000, 0);
+#else
+#if HOST_BITS_PER_WIDE_INT == 32
+  decimal_long_max = build_int_2 (0, 0x80000000);
+#else
+ #error "unsupported size"
+#endif
+#endif
+  TREE_TYPE (decimal_long_max) = unsigned_long_type_node;
+
   size_zero_node = size_int (0);
   size_one_node = size_int (1);
   bitsize_zero_node = bitsize_int (0);
--- gcc/java/java-tree.h	2 Nov 2002 23:52:26 -0000	1.161
+++ gcc/java/java-tree.h	6 Nov 2002 00:01:00 -0000	1.162
@@ -275,6 +275,9 @@ enum java_tree_index
   JTI_UNSIGNED_INT_TYPE_NODE,
   JTI_UNSIGNED_LONG_TYPE_NODE,
   
+  JTI_DECIMAL_INT_MAX_NODE,
+  JTI_DECIMAL_LONG_MAX_NODE,
+
   JTI_BOOLEAN_TYPE_NODE,
 
   JTI_OBJECT_TYPE_NODE,
@@ -441,6 +444,11 @@ extern GTY(()) tree java_global_trees[JT
 #define unsigned_long_type_node \
   java_global_trees[JTI_UNSIGNED_LONG_TYPE_NODE]
 
+#define decimal_int_max \
+  java_global_trees[JTI_DECIMAL_INT_MAX_NODE]
+#define decimal_long_max \
+  java_global_trees[JTI_DECIMAL_LONG_MAX_NODE]
+
 #define boolean_type_node \
   java_global_trees[JTI_BOOLEAN_TYPE_NODE]
 
--- gcc/java/lex.c	2 Nov 2002 21:29:36 -0000	1.94
+++ gcc/java/lex.c	6 Nov 2002 00:01:01 -0000	1.95
@@ -1218,34 +1218,35 @@ java_lex (java_lval)
 	}
       /* End borrowed section.  */
 
+#ifndef JC1_LITE
       /* Range checking.  */
-      if (long_suffix)
+      value = build_int_2 (low, high);
+      /* Temporarily set type to unsigned.  */
+      SET_LVAL_NODE_TYPE (value, (long_suffix
+				  ? unsigned_long_type_node
+				  : unsigned_int_type_node));
+
+      /* For base 10 numbers, only values up to the highest value
+	 (plus one) can be written.  For instance, only ints up to
+	 2147483648 can be written.  The special case of the largest
+	 negative value is handled elsewhere.  For other bases, any
+	 number can be represented.  */
+      if (overflow || (radix == 10
+		       && tree_int_cst_lt (long_suffix
+					   ? decimal_long_max
+					   : decimal_int_max,
+					   value)))
 	{
-	  /* 9223372036854775808L is valid if operand of a '-'. Otherwise
-	     9223372036854775807L is the biggest `long' literal that can be
-	     expressed using a 10 radix. For other radices, everything that
-	     fits withing 64 bits is OK.  */
-	  int hb = (high >> 31);
-	  if (overflow || (hb && low && radix == 10)
-	      || (hb && high & 0x7fffffff && radix == 10))
+	  if (long_suffix)
 	    JAVA_INTEGRAL_RANGE_ERROR ("Numeric overflow for `long' literal");
-	}
-      else
-	{
-	  /* 2147483648 is valid if operand of a '-'. Otherwise,
-	     2147483647 is the biggest `int' literal that can be
-	     expressed using a 10 radix. For other radices, everything
-	     that fits within 32 bits is OK.  As all literals are
-	     signed, we sign extend here.  */
-	  int hb = (low >> 31) & 0x1;
-	  if (overflow || high || (hb && low & 0x7fffffff && radix == 10))
+	  else
 	    JAVA_INTEGRAL_RANGE_ERROR ("Numeric overflow for `int' literal");
-	  high = -hb;
 	}
-#ifndef JC1_LITE
-      value = build_int_2 (low, high);
+
+      /* Sign extend the value.  */
+      SET_LVAL_NODE_TYPE (value, (long_suffix ? long_type_node : int_type_node));
+      force_fit_type (value, 0);
       JAVA_RADIX10_FLAG (value) = radix == 10;
-      SET_LVAL_NODE_TYPE (value, long_suffix ? long_type_node : int_type_node);
 #else
       SET_LVAL_NODE_TYPE (build_int_2 (low, high),
 			  long_suffix ? long_type_node : int_type_node);
@@ -1661,24 +1662,14 @@ static void
 error_if_numeric_overflow (value)
      tree value;
 {
-  if (TREE_CODE (value) == INTEGER_CST && JAVA_RADIX10_FLAG (value))
+  if (TREE_CODE (value) == INTEGER_CST
+      && JAVA_RADIX10_FLAG (value)
+      && tree_int_cst_sgn (value) < 0)
     {
-      unsigned HOST_WIDE_INT lo, hi;
-
-      lo = TREE_INT_CST_LOW (value);
-      hi = TREE_INT_CST_HIGH (value);
       if (TREE_TYPE (value) == long_type_node)
-	{
-	  int hb = (hi >> 31);
-	  if (hb && !(hi & 0x7fffffff))
-	    java_lex_error ("Numeric overflow for `long' literal", 0);
-	}
+	java_lex_error ("Numeric overflow for `long' literal", 0);
       else
-	{
-	  int hb = (lo >> 31) & 0x1;
-	  if (hb && !(lo & 0x7fffffff))
-	    java_lex_error ("Numeric overflow for `int' literal", 0);
-	}
+	java_lex_error ("Numeric overflow for `int' literal", 0);
     }
 }
 #endif /* JC1_LITE */
--- gcc/java/lex.h	2 Nov 2002 21:29:36 -0000	1.28
+++ gcc/java/lex.h	6 Nov 2002 00:01:01 -0000	1.29
@@ -185,7 +185,7 @@ extern void java_destroy_lexer PARAMS ((
 #define SET_LVAL_NODE_TYPE(NODE, TYPE)
 #define BUILD_ID_WFL(EXP) (EXP)
 #define JAVA_FLOAT_RANGE_ERROR(S) {}
-#define JAVA_INTEGRAL_RANGE_ERROR(S) {}
+#define JAVA_INTEGRAL_RANGE_ERROR(S) do { } while (0)
 
 #else
 
@@ -237,12 +237,12 @@ extern void java_destroy_lexer PARAMS ((
     ctxp->c_line->current = i;						  \
   }
 #define JAVA_INTEGRAL_RANGE_ERROR(m)		\
-  {						\
+  do {						\
     int i = ctxp->c_line->current;		\
     ctxp->c_line->current = number_beginning;	\
     java_lex_error (m, 0);			\
     ctxp->c_line->current = i;			\
-  }
+  } while (0)
 
 #endif /* Definitions for jc1 compilation only */