Java does not support unsigned types, so special care needs to be taken when mimicking unsigned types with their signed counterparts. Also remove Cloneable interface from DiyFp and instead call the constructor directly, no need to follow the C++ implementation and its copy-constructor so closely

anba · hns · commit d1bc9b648712 · 2012-05-24T11:22:32.000+02:00
diff --git a/src/org/mozilla/javascript/v8dtoa/DiyFp.java b/src/org/mozilla/javascript/v8dtoa/DiyFp.java
@@ -35,7 +35,7 @@
 // have the most significant bit of the significand set.
 // Multiplication and Subtraction do not normalize their results.
 // DiyFp are not designed to contain special doubles (NaN and Infinity).
-class DiyFp implements Cloneable {
+class DiyFp {
 
     private long f;
     private int e;
@@ -54,21 +54,26 @@ class DiyFp implements Cloneable {
         this.e = e;
     }
 
+    private static boolean uint64_gte(long a, long b) {
+        // greater-or-equal for unsigned int64 in java-style...
+        return (a == b) || ((a > b) ^ (a < 0) ^ (b < 0));
+    }
+
     // this = this - other.
     // The exponents of both numbers must be the same and the significand of this
     // must be bigger than the significand of other.
     // The result will not be normalized.
     void subtract(DiyFp other) {
         assert (e == other.e);
-        assert (f >= other.f);
+        assert uint64_gte(f, other.f);
         f -= other.f;
     }
 
     // Returns a - b.
     // The exponents of both numbers must be the same and this must be bigger
     // than other. The result will not be normalized.
     static DiyFp minus(DiyFp a, DiyFp b) {
-        DiyFp result = a.clone();
+        DiyFp result = new DiyFp(a.f, a.e);
         result.subtract(b);
         return result;
     }
@@ -100,7 +105,7 @@ void multiply(DiyFp other) {
 
     // returns a * b;
     static DiyFp times(DiyFp a, DiyFp b) {
-        DiyFp result = a.clone();
+        DiyFp result = new DiyFp(a.f, a.e);
         result.multiply(b);
         return result;
     }
@@ -126,7 +131,7 @@ void normalize() {
     }
 
     static DiyFp normalize(DiyFp a) {
-        DiyFp result = a.clone();
+        DiyFp result = new DiyFp(a.f, a.e);
         result.normalize();
         return result;
     }
@@ -137,14 +142,6 @@ static DiyFp normalize(DiyFp a) {
     void setF(long new_value) { f = new_value; }
     void setE(int new_value) { e = new_value; }
 
-    public DiyFp clone() {
-        try {
-            return (DiyFp) super.clone();
-        } catch (CloneNotSupportedException e) {
-            throw new RuntimeException(); // won't happen
-        }
-    }
-
     @Override
     public String toString() {
         return "[DiyFp f:" + f + ", e:" + e + "]";
diff --git a/src/org/mozilla/javascript/v8dtoa/FastDtoa.java b/src/org/mozilla/javascript/v8dtoa/FastDtoa.java
@@ -276,6 +276,10 @@ static long biggestPowerTen(int number,
         return ((long)power << 32) | (0xffffffffL & exponent);
     }
 
+    private static boolean uint64_lte(long a, long b) {
+        // less-or-equal for unsigned int64 in java-style...
+        return (a == b) || ((a < b) ^ (a < 0) ^ (b < 0));
+    }
 
     // Generates the digits of input number w.
     // w is a floating-point number (DiyFp), consisting of a significand and an
@@ -325,7 +329,7 @@ static boolean digitGen(DiyFp low,
                      FastDtoaBuilder buffer,
                      int mk) {
         assert(low.e() == w.e() && w.e() == high.e());
-        assert(low.f() + 1 <= high.f() - 1);
+        assert uint64_lte(low.f() + 1, high.f() - 1);
         assert(minimal_target_exponent <= w.e() && w.e() <= maximal_target_exponent);
         // low, w and high are imprecise, but by less than one ulp (unit in the last
         // place).
