Changeset 11722

Timestamp:

04/01/09 19:58:11 (14 years ago)

Author:

ehuelsmann

Message:

Make sure to create Fixnums when the LispInteger/Bignum? created is in the Fixnum range.

Note: After this commit, your .abcl files need to be recompiled as it makes the

Bignum and Fixnum constructors 'private'.

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• Bignum.java (modified) (1 diff)
• Fixnum.java (modified) (12 diffs)
• FloatFunctions.java (modified) (1 diff)
• JavaObject.java (modified) (1 diff)
• Lisp.java (modified) (4 diffs)
• LispInteger.java (modified) (1 diff)
• RuntimeClass.java (modified) (1 diff)
• Stream.java (modified) (3 diffs)
• compiler-pass2.lisp (modified) (3 diffs)

trunk/abcl/src/org/armedbear/lisp/Bignum.java

@@ -40 +40 @@
   public final BigInteger value;
 
-  public static Bignum getInstance(long l) {
-    return new Bignum(l);
-  }
-
-  public Bignum(long l)
+  private static BigInteger MOST_NEGATIVE_FIXNUM =
+          BigInteger.valueOf(Integer.MIN_VALUE);
+  private static BigInteger MOST_POSITIVE_FIXNUM =
+          BigInteger.valueOf(Integer.MAX_VALUE);
+
+  public static LispInteger getInstance(long l) {
+      if (Integer.MIN_VALUE <= l && l <= Integer.MAX_VALUE)
+          return Fixnum.getInstance(l);
+      else
+          return new Bignum(l);
+  }
+
+  public static LispInteger getInstance(BigInteger n) {
+      if (MOST_NEGATIVE_FIXNUM.compareTo(n) < 0 ||
+              MOST_POSITIVE_FIXNUM.compareTo(n) > 0)
+          return new Bignum(n);
+      else
+          return Fixnum.getInstance(n.intValue());
+  }
+
+  public static LispInteger getInstance(String s, int radix) {
+      BigInteger value = new BigInteger(s, radix);
+
+      return Bignum.getInstance(value);
+  }
+
+  private Bignum(long l)
   {
     value = BigInteger.valueOf(l);
   }
 
-  public Bignum(BigInteger n)
+  private Bignum(BigInteger n)
   {
     value = n;
-  }
-
-  public Bignum(String s, int radix)
-  {
-    value = new BigInteger(s, radix);
   }
 

trunk/abcl/src/org/armedbear/lisp/Fixnum.java

@@ -253 +253 @@
     if (value >= 0)
       return this;
-    if (value > Integer.MIN_VALUE)
-      return Fixnum.getInstance(-value);
-    return new Bignum(-((long)Integer.MIN_VALUE));
+    return LispInteger.getInstance(-(long)value);
   }
 
@@ -372 +370 @@
   public final LispObject incr()
   {
-    if (value < Integer.MAX_VALUE)
-      return Fixnum.getInstance(value + 1);
-    return new Bignum((long) value + 1);
+    return LispInteger.getInstance(1 + (long)value);
   }
 
@@ -380 +376 @@
   public final LispObject decr()
   {
-    if (value > Integer.MIN_VALUE)
-      return Fixnum.getInstance(value - 1);
-    return new Bignum((long) value - 1);
+    return LispInteger.getInstance(-1 + (long)value);
   }
 
@@ -388 +382 @@
   public LispObject negate()
   {
-    long result = 0L - value;
-    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-      return Fixnum.getInstance((int)result);
-    else
-      return new Bignum(result);
+    return LispInteger.getInstance((-(long)value));
   }
 
@@ -398 +388 @@
   public LispObject add(int n)
   {
-    long result = (long) value + n;
-    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-      return Fixnum.getInstance((int)result);
-    else
-      return new Bignum(result);
+    return LispInteger.getInstance((long) value + n);
   }
 
@@ -411 +397 @@
       {
         long result = (long) value + ((Fixnum)obj).value;
-        if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-          return Fixnum.getInstance((int)result);
-        else
-          return new Bignum(result);
+        return LispInteger.getInstance(result);
       }
     if (obj instanceof Bignum)
@@ -440 +423 @@
   public LispObject subtract(int n)
   {
-    long result = (long) value - n;
-    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-      return Fixnum.getInstance((int)result);
-    else
-      return new Bignum(result);
+    return LispInteger.getInstance((long)value - n);
   }
 
@@ -479 +458 @@
   {
     long result = (long) value * n;
-    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-      return Fixnum.getInstance((int)result);
-    else
-      return new Bignum(result);
+    return LispInteger.getInstance(result);
   }
 
@@ -491 +467 @@
       {
         long result = (long) value * ((Fixnum)obj).value;
-        if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
-          return Fixnum.getInstance((int)result);
-        else
-          return new Bignum(result);
+        return LispInteger.getInstance(result);
       }
     if (obj instanceof Bignum)
@@ -839 +812 @@
       {
         n = n << shift;
-        if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
-          return Fixnum.getInstance((int)n);
-        else
-          return new Bignum(n);
+        return LispInteger.getInstance(n);
       }
     // BigInteger.shiftLeft() succumbs to a stack overflow if shift
@@ -962 +932 @@
 
     if (y.compareTo (BigInteger.ZERO) < 0)
-      return (Fixnum.getInstance(1)).divideBy(this.pow(new Bignum(y.negate())));
+      return (Fixnum.getInstance(1)).divideBy(this.pow(Bignum.getInstance(y.negate())));
 
     if (y.compareTo(BigInteger.ZERO) == 0)
@@ -988 +958 @@
     }
 
-    return new Bignum(xy);
+    return Bignum.getInstance(xy);
   }
 

trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

@@ -155 +155 @@
                 int bits = Float.floatToIntBits(((SingleFloat)arg).value);
                 BigInteger big = BigInteger.valueOf(bits >> 1);
-                return new Bignum(big.shiftLeft(1).add(((bits & 1) == 1) ? BigInteger.ONE : BigInteger.ZERO));
+                return Bignum.getInstance(big.shiftLeft(1).add(((bits & 1) == 1) ? BigInteger.ONE : BigInteger.ZERO));
             }
             if (arg instanceof DoubleFloat) {
                 long bits = Double.doubleToLongBits(((DoubleFloat)arg).value);
                 BigInteger big = BigInteger.valueOf(bits >> 1);
-                return new Bignum(big.shiftLeft(1).add(((bits & 1) == 1) ? BigInteger.ONE : BigInteger.ZERO));
+                return Bignum.getInstance(big.shiftLeft(1).add(((bits & 1) == 1) ? BigInteger.ONE : BigInteger.ZERO));
             }
             return type_error(arg, Symbol.FLOAT);

trunk/abcl/src/org/armedbear/lisp/JavaObject.java

@@ -135 +135 @@
 
             if (obj instanceof BigInteger)
-                return new Bignum((BigInteger)obj);
+                return Bignum.getInstance((BigInteger)obj);
 
             if (obj instanceof Short)

trunk/abcl/src/org/armedbear/lisp/Lisp.java

@@ -882 +882 @@
       return Fixnum.getInstance((int)n);
     else
-      return new Bignum(n);
+      return Bignum.getInstance(n);
   }
 
@@ -916 +916 @@
       return Fixnum.getInstance(n.intValue());
     else
-      return new Bignum(n);
+      return Bignum.getInstance(n);
   }
 
@@ -1220 +1220 @@
 
   public static final LispObject UNSIGNED_BYTE_32_MAX_VALUE =
-    new Bignum(4294967296L);
+    Bignum.getInstance(4294967296L);
 
   public static final LispObject getUpgradedArrayElementType(LispObject type)
@@ -2089 +2089 @@
     Symbol.MOST_POSITIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MAX_VALUE));
     Symbol.MOST_NEGATIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MIN_VALUE));
-    Symbol.MOST_POSITIVE_JAVA_LONG.initializeConstant(new Bignum(Long.MAX_VALUE));
-    Symbol.MOST_NEGATIVE_JAVA_LONG.initializeConstant(new Bignum(Long.MIN_VALUE));
+    Symbol.MOST_POSITIVE_JAVA_LONG.initializeConstant(Bignum.getInstance(Long.MAX_VALUE));
+    Symbol.MOST_NEGATIVE_JAVA_LONG.initializeConstant(Bignum.getInstance(Long.MIN_VALUE));
   }
 

trunk/abcl/src/org/armedbear/lisp/LispInteger.java

@@ -44 +44 @@
           return Fixnum.getInstance((int)l);
       else
-          return new Bignum(l);
+          return Bignum.getInstance(l);
   }
 

trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java

@@ -170 +170 @@
     }
 
-    public static final Bignum makeLispObject(long i) throws ConditionThrowable
+    public static final LispInteger makeLispObject(long i) throws ConditionThrowable
     {
-        return new Bignum(i);
+        return Bignum.getInstance(i);
     }
 

trunk/abcl/src/org/armedbear/lisp/Stream.java

@@ -1357 +1357 @@
     try
       {
-        return new Bignum(token, radix);
+        return Bignum.getInstance(token, radix);
       }
     catch (NumberFormatException e) {}
@@ -1494 +1494 @@
     try
       {
-        return new Bignum(s, radix);
+        return Bignum.getInstance(s, radix);
       }
     catch (NumberFormatException e) {}
@@ -1523 +1523 @@
     try
       {
-        return new Bignum(s, radix);
+        return Bignum.getInstance(s, radix);
       }
     catch (NumberFormatException e) {}

trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp

@@ -2201 +2201 @@
    (let ((*code* *static-code*))
      (declare-field g +lisp-integer+)
-     (emit 'new +lisp-bignum-class+)
-     (emit 'dup)
      (cond ((<= most-negative-java-long n most-positive-java-long)
 ;;      (setf g (format nil "BIGNUM_~A~D"
@@ -2208 +2206 @@
 ;;          (abs n)))
       (emit 'ldc2_w (pool-long n))
-      (emit-invokespecial-init +lisp-bignum-class+ '("J")))
+      (emit-invokestatic +lisp-bignum-class+ "getInstance"
+                               '("J") +lisp-integer+))
    (t
     (let* ((*print-base* 10)
@@ -2214 +2213 @@
       (emit 'ldc (pool-string s))
       (emit-push-constant-int 10)
-      (emit-invokespecial-init +lisp-bignum-class+
-                                     (list +java-string+ "I")))))
+      (emit-invokestatic +lisp-bignum-class+ "getInstance"
+                               (list +java-string+ "I") +lisp-integer+))))
      (emit 'putstatic *this-class* g +lisp-integer+)
      (setf *static-code* *code*))