# HG changeset patch
# User Jaroslav Tulach <jaroslav.tulach@apidesign.org>
# Date 1349054977 25200
# Node ID d65b3a2fbfaf1b3fb3d36bd592a92ac5cee97e0d
# Parent  89b2cb4068fccca2bd0dfcf2a1588030f82e1c0f
Almost compilable

diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Class.java
--- a/emul/src/main/java/java/lang/Class.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Class.java	Sun Sep 30 18:29:37 2012 -0700
@@ -709,7 +709,7 @@
         throw new UnsupportedOperationException();
     }
 
-    static Class<?> getPrimitiveClass(String type) {
+    static Class getPrimitiveClass(String type) {
         throw new UnsupportedOperationException();
     }
 }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Double.java
--- a/emul/src/main/java/java/lang/Double.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Double.java	Sun Sep 30 18:29:37 2012 -0700
@@ -25,10 +25,6 @@
 
 package java.lang;
 
-import sun.misc.FloatingDecimal;
-import sun.misc.FpUtils;
-import sun.misc.DoubleConsts;
-
 /**
  * The {@code Double} class wraps a value of the primitive type
  * {@code double} in an object. An object of type
@@ -193,7 +189,7 @@
      * @return a string representation of the argument.
      */
     public static String toString(double d) {
-        return new FloatingDecimal(d).toJavaFormatString();
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -271,61 +267,62 @@
      * @author Joseph D. Darcy
      */
     public static String toHexString(double d) {
-        /*
-         * Modeled after the "a" conversion specifier in C99, section
-         * 7.19.6.1; however, the output of this method is more
-         * tightly specified.
-         */
-        if (!FpUtils.isFinite(d) )
-            // For infinity and NaN, use the decimal output.
-            return Double.toString(d);
-        else {
-            // Initialized to maximum size of output.
-            StringBuffer answer = new StringBuffer(24);
-
-            if (FpUtils.rawCopySign(1.0, d) == -1.0) // value is negative,
-                answer.append("-");                  // so append sign info
-
-            answer.append("0x");
-
-            d = Math.abs(d);
-
-            if(d == 0.0) {
-                answer.append("0.0p0");
-            }
-            else {
-                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
-
-                // Isolate significand bits and OR in a high-order bit
-                // so that the string representation has a known
-                // length.
-                long signifBits = (Double.doubleToLongBits(d)
-                                   & DoubleConsts.SIGNIF_BIT_MASK) |
-                    0x1000000000000000L;
-
-                // Subnormal values have a 0 implicit bit; normal
-                // values have a 1 implicit bit.
-                answer.append(subnormal ? "0." : "1.");
-
-                // Isolate the low-order 13 digits of the hex
-                // representation.  If all the digits are zero,
-                // replace with a single 0; otherwise, remove all
-                // trailing zeros.
-                String signif = Long.toHexString(signifBits).substring(3,16);
-                answer.append(signif.equals("0000000000000") ? // 13 zeros
-                              "0":
-                              signif.replaceFirst("0{1,12}$", ""));
-
-                // If the value is subnormal, use the E_min exponent
-                // value for double; otherwise, extract and report d's
-                // exponent (the representation of a subnormal uses
-                // E_min -1).
-                answer.append("p" + (subnormal ?
-                               DoubleConsts.MIN_EXPONENT:
-                               FpUtils.getExponent(d) ));
-            }
-            return answer.toString();
-        }
+        throw new UnsupportedOperationException();
+//        /*
+//         * Modeled after the "a" conversion specifier in C99, section
+//         * 7.19.6.1; however, the output of this method is more
+//         * tightly specified.
+//         */
+//        if (!FpUtils.isFinite(d) )
+//            // For infinity and NaN, use the decimal output.
+//            return Double.toString(d);
+//        else {
+//            // Initialized to maximum size of output.
+//            StringBuffer answer = new StringBuffer(24);
+//
+//            if (FpUtils.rawCopySign(1.0, d) == -1.0) // value is negative,
+//                answer.append("-");                  // so append sign info
+//
+//            answer.append("0x");
+//
+//            d = Math.abs(d);
+//
+//            if(d == 0.0) {
+//                answer.append("0.0p0");
+//            }
+//            else {
+//                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
+//
+//                // Isolate significand bits and OR in a high-order bit
+//                // so that the string representation has a known
+//                // length.
+//                long signifBits = (Double.doubleToLongBits(d)
+//                                   & DoubleConsts.SIGNIF_BIT_MASK) |
+//                    0x1000000000000000L;
+//
+//                // Subnormal values have a 0 implicit bit; normal
+//                // values have a 1 implicit bit.
+//                answer.append(subnormal ? "0." : "1.");
+//
+//                // Isolate the low-order 13 digits of the hex
+//                // representation.  If all the digits are zero,
+//                // replace with a single 0; otherwise, remove all
+//                // trailing zeros.
+//                String signif = Long.toHexString(signifBits).substring(3,16);
+//                answer.append(signif.equals("0000000000000") ? // 13 zeros
+//                              "0":
+//                              signif.replaceFirst("0{1,12}$", ""));
+//
+//                // If the value is subnormal, use the E_min exponent
+//                // value for double; otherwise, extract and report d's
+//                // exponent (the representation of a subnormal uses
+//                // E_min -1).
+//                answer.append("p" + (subnormal ?
+//                               DoubleConsts.MIN_EXPONENT:
+//                               FpUtils.getExponent(d) ));
+//            }
+//            return answer.toString();
+//        }
     }
 
     /**
@@ -501,7 +498,8 @@
      *             parsable number.
      */
     public static Double valueOf(String s) throws NumberFormatException {
-        return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());
+        throw new UnsupportedOperationException();
+//        return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());
     }
 
     /**
@@ -537,7 +535,8 @@
      * @since 1.2
      */
     public static double parseDouble(String s) throws NumberFormatException {
-        return FloatingDecimal.readJavaFormatString(s).doubleValue();
+        throw new UnsupportedOperationException();
+//        return FloatingDecimal.readJavaFormatString(s).doubleValue();
     }
 
     /**
@@ -805,14 +804,15 @@
      * @return the bits that represent the floating-point number.
      */
     public static long doubleToLongBits(double value) {
-        long result = doubleToRawLongBits(value);
-        // Check for NaN based on values of bit fields, maximum
-        // exponent and nonzero significand.
-        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
-              DoubleConsts.EXP_BIT_MASK) &&
-             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
-            result = 0x7ff8000000000000L;
-        return result;
+        throw new UnsupportedOperationException();
+//        long result = doubleToRawLongBits(value);
+//        // Check for NaN based on values of bit fields, maximum
+//        // exponent and nonzero significand.
+//        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
+//              DoubleConsts.EXP_BIT_MASK) &&
+//             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
+//            result = 0x7ff8000000000000L;
+//        return result;
     }
 
     /**
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Enum.java
--- a/emul/src/main/java/java/lang/Enum.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Enum.java	Sun Sep 30 18:29:37 2012 -0700
@@ -27,9 +27,6 @@
 
 import java.io.Serializable;
 import java.io.IOException;
-import java.io.InvalidObjectException;
-import java.io.ObjectInputStream;
-import java.io.ObjectStreamException;
 
 /**
  * This is the common base class of all Java language enumeration types.
@@ -228,13 +225,14 @@
      */
     public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                 String name) {
-        T result = enumType.enumConstantDirectory().get(name);
-        if (result != null)
-            return result;
-        if (name == null)
-            throw new NullPointerException("Name is null");
-        throw new IllegalArgumentException(
-            "No enum constant " + enumType.getCanonicalName() + "." + name);
+        throw new UnsupportedOperationException();
+//        T result = enumType.enumConstantDirectory().get(name);
+//        if (result != null)
+//            return result;
+//        if (name == null)
+//            throw new NullPointerException("Name is null");
+//        throw new IllegalArgumentException(
+//            "No enum constant " + enumType.getCanonicalName() + "." + name);
     }
 
     /**
@@ -245,12 +243,12 @@
     /**
      * prevent default deserialization
      */
-    private void readObject(ObjectInputStream in) throws IOException,
-        ClassNotFoundException {
-        throw new InvalidObjectException("can't deserialize enum");
-    }
-
-    private void readObjectNoData() throws ObjectStreamException {
-        throw new InvalidObjectException("can't deserialize enum");
-    }
+//    private void readObject(ObjectInputStream in) throws IOException,
+//        ClassNotFoundException {
+//        throw new InvalidObjectException("can't deserialize enum");
+//    }
+//
+//    private void readObjectNoData() throws ObjectStreamException {
+//        throw new InvalidObjectException("can't deserialize enum");
+//    }
 }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Float.java
--- a/emul/src/main/java/java/lang/Float.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Float.java	Sun Sep 30 18:29:37 2012 -0700
@@ -25,11 +25,6 @@
 
 package java.lang;
 
-import sun.misc.FloatingDecimal;
-import sun.misc.FpUtils;
-import sun.misc.FloatConsts;
-import sun.misc.DoubleConsts;
-
 /**
  * The {@code Float} class wraps a value of primitive type
  * {@code float} in an object. An object of type
@@ -196,7 +191,8 @@
      * @return a string representation of the argument.
      */
     public static String toString(float f) {
-        return new FloatingDecimal(f).toJavaFormatString();
+        throw new UnsupportedOperationException();
+//        return new FloatingDecimal(f).toJavaFormatString();
     }
 
     /**
@@ -274,19 +270,20 @@
      * @author Joseph D. Darcy
      */
     public static String toHexString(float f) {
-        if (Math.abs(f) < FloatConsts.MIN_NORMAL
-            &&  f != 0.0f ) {// float subnormal
-            // Adjust exponent to create subnormal double, then
-            // replace subnormal double exponent with subnormal float
-            // exponent
-            String s = Double.toHexString(FpUtils.scalb((double)f,
-                                                        /* -1022+126 */
-                                                        DoubleConsts.MIN_EXPONENT-
-                                                        FloatConsts.MIN_EXPONENT));
-            return s.replaceFirst("p-1022$", "p-126");
-        }
-        else // double string will be the same as float string
-            return Double.toHexString(f);
+        throw new UnsupportedOperationException();
+//        if (Math.abs(f) < FloatConsts.MIN_NORMAL
+//            &&  f != 0.0f ) {// float subnormal
+//            // Adjust exponent to create subnormal double, then
+//            // replace subnormal double exponent with subnormal float
+//            // exponent
+//            String s = Double.toHexString(FpUtils.scalb((double)f,
+//                                                        /* -1022+126 */
+//                                                        DoubleConsts.MIN_EXPONENT-
+//                                                        FloatConsts.MIN_EXPONENT));
+//            return s.replaceFirst("p-1022$", "p-126");
+//        }
+//        else // double string will be the same as float string
+//            return Double.toHexString(f);
     }
 
     /**
@@ -414,7 +411,8 @@
      *          parsable number.
      */
     public static Float valueOf(String s) throws NumberFormatException {
-        return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
+        throw new UnsupportedOperationException();
+//        return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
     }
 
     /**
@@ -449,7 +447,8 @@
      * @since 1.2
      */
     public static float parseFloat(String s) throws NumberFormatException {
-        return FloatingDecimal.readJavaFormatString(s).floatValue();
+        throw new UnsupportedOperationException();
+//        return FloatingDecimal.readJavaFormatString(s).floatValue();
     }
 
     /**
@@ -710,14 +709,15 @@
      * @return the bits that represent the floating-point number.
      */
     public static int floatToIntBits(float value) {
-        int result = floatToRawIntBits(value);
-        // Check for NaN based on values of bit fields, maximum
-        // exponent and nonzero significand.
-        if ( ((result & FloatConsts.EXP_BIT_MASK) ==
-              FloatConsts.EXP_BIT_MASK) &&
-             (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
-            result = 0x7fc00000;
-        return result;
+        throw new UnsupportedOperationException();
+//        int result = floatToRawIntBits(value);
+//        // Check for NaN based on values of bit fields, maximum
+//        // exponent and nonzero significand.
+//        if ( ((result & FloatConsts.EXP_BIT_MASK) ==
+//              FloatConsts.EXP_BIT_MASK) &&
+//             (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
+//            result = 0x7fc00000;
+//        return result;
     }
 
     /**
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Integer.java
--- a/emul/src/main/java/java/lang/Integer.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Integer.java	Sun Sep 30 18:29:37 2012 -0700
@@ -25,8 +25,6 @@
 
 package java.lang;
 
-import java.util.Properties;
-
 /**
  * The {@code Integer} class wraps a value of the primitive type
  * {@code int} in an object. An object of type {@code Integer}
@@ -602,7 +600,7 @@
             // high value may be configured by property
             int h = 127;
             String integerCacheHighPropValue =
-                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+                String.getProperty("java.lang.Integer.IntegerCache.high");
             if (integerCacheHighPropValue != null) {
                 int i = parseInt(integerCacheHighPropValue);
                 i = Math.max(i, 127);
@@ -884,7 +882,7 @@
     public static Integer getInteger(String nm, Integer val) {
         String v = null;
         try {
-            v = System.getProperty(nm);
+            v = String.getProperty(nm);
         } catch (IllegalArgumentException e) {
         } catch (NullPointerException e) {
         }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Long.java
--- a/emul/src/main/java/java/lang/Long.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Long.java	Sun Sep 30 18:29:37 2012 -0700
@@ -923,7 +923,7 @@
     public static Long getLong(String nm, Long val) {
         String v = null;
         try {
-            v = System.getProperty(nm);
+            v = String.getProperty(nm);
         } catch (IllegalArgumentException e) {
         } catch (NullPointerException e) {
         }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/Math.java
--- a/emul/src/main/java/java/lang/Math.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/Math.java	Sun Sep 30 18:29:37 2012 -0700
@@ -24,7 +24,6 @@
  */
 
 package java.lang;
-import java.util.Random;
 
 
 /**
@@ -680,12 +679,12 @@
             return 0;
     }
 
-    private static Random randomNumberGenerator;
-
-    private static synchronized Random initRNG() {
-        Random rnd = randomNumberGenerator;
-        return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;
-    }
+//    private static Random randomNumberGenerator;
+//
+//    private static synchronized Random initRNG() {
+//        Random rnd = randomNumberGenerator;
+//        return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;
+//    }
 
     /**
      * Returns a {@code double} value with a positive sign, greater
@@ -711,9 +710,7 @@
      * @see Random#nextDouble()
      */
     public static double random() {
-        Random rnd = randomNumberGenerator;
-        if (rnd == null) rnd = initRNG();
-        return rnd.nextDouble();
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -962,9 +959,9 @@
      * @author Joseph D. Darcy
      * @since 1.5
      */
-    public static double ulp(double d) {
-        return sun.misc.FpUtils.ulp(d);
-    }
+//    public static double ulp(double d) {
+//        return sun.misc.FpUtils.ulp(d);
+//    }
 
     /**
      * Returns the size of an ulp of the argument.  An ulp of a
@@ -989,9 +986,9 @@
      * @author Joseph D. Darcy
      * @since 1.5
      */
-    public static float ulp(float f) {
-        return sun.misc.FpUtils.ulp(f);
-    }
+//    public static float ulp(float f) {
+//        return sun.misc.FpUtils.ulp(f);
+//    }
 
     /**
      * Returns the signum function of the argument; zero if the argument
@@ -1010,9 +1007,9 @@
      * @author Joseph D. Darcy
      * @since 1.5
      */
-    public static double signum(double d) {
-        return sun.misc.FpUtils.signum(d);
-    }
+//    public static double signum(double d) {
+//        return sun.misc.FpUtils.signum(d);
+//    }
 
     /**
      * Returns the signum function of the argument; zero if the argument
@@ -1031,9 +1028,9 @@
      * @author Joseph D. Darcy
      * @since 1.5
      */
-    public static float signum(float f) {
-        return sun.misc.FpUtils.signum(f);
-    }
+//    public static float signum(float f) {
+//        return sun.misc.FpUtils.signum(f);
+//    }
 
     /**
      * Returns the hyperbolic sine of a {@code double} value.
@@ -1251,9 +1248,9 @@
      * and the sign of {@code sign}.
      * @since 1.6
      */
-    public static double copySign(double magnitude, double sign) {
-        return sun.misc.FpUtils.rawCopySign(magnitude, sign);
-    }
+//    public static double copySign(double magnitude, double sign) {
+//        return sun.misc.FpUtils.rawCopySign(magnitude, sign);
+//    }
 
     /**
      * Returns the first floating-point argument with the sign of the
@@ -1270,9 +1267,9 @@
      * and the sign of {@code sign}.
      * @since 1.6
      */
-    public static float copySign(float magnitude, float sign) {
-        return sun.misc.FpUtils.rawCopySign(magnitude, sign);
-    }
+//    public static float copySign(float magnitude, float sign) {
+//        return sun.misc.FpUtils.rawCopySign(magnitude, sign);
+//    }
 
     /**
      * Returns the unbiased exponent used in the representation of a
@@ -1288,9 +1285,9 @@
      * @return the unbiased exponent of the argument
      * @since 1.6
      */
-    public static int getExponent(float f) {
-        return sun.misc.FpUtils.getExponent(f);
-    }
+//    public static int getExponent(float f) {
+//        return sun.misc.FpUtils.getExponent(f);
+//    }
 
     /**
      * Returns the unbiased exponent used in the representation of a
@@ -1306,9 +1303,9 @@
      * @return the unbiased exponent of the argument
      * @since 1.6
      */
-    public static int getExponent(double d) {
-        return sun.misc.FpUtils.getExponent(d);
-    }
+//    public static int getExponent(double d) {
+//        return sun.misc.FpUtils.getExponent(d);
+//    }
 
     /**
      * Returns the floating-point number adjacent to the first
@@ -1350,9 +1347,9 @@
      * direction of {@code direction}.
      * @since 1.6
      */
-    public static double nextAfter(double start, double direction) {
-        return sun.misc.FpUtils.nextAfter(start, direction);
-    }
+//    public static double nextAfter(double start, double direction) {
+//        return sun.misc.FpUtils.nextAfter(start, direction);
+//    }
 
     /**
      * Returns the floating-point number adjacent to the first
@@ -1393,9 +1390,9 @@
      * direction of {@code direction}.
      * @since 1.6
      */
-    public static float nextAfter(float start, double direction) {
-        return sun.misc.FpUtils.nextAfter(start, direction);
-    }
+//    public static float nextAfter(float start, double direction) {
+//        return sun.misc.FpUtils.nextAfter(start, direction);
+//    }
 
     /**
      * Returns the floating-point value adjacent to {@code d} in
@@ -1422,9 +1419,9 @@
      * infinity.
      * @since 1.6
      */
-    public static double nextUp(double d) {
-        return sun.misc.FpUtils.nextUp(d);
-    }
+//    public static double nextUp(double d) {
+//        return sun.misc.FpUtils.nextUp(d);
+//    }
 
     /**
      * Returns the floating-point value adjacent to {@code f} in
@@ -1451,9 +1448,9 @@
      * infinity.
      * @since 1.6
      */
-    public static float nextUp(float f) {
-        return sun.misc.FpUtils.nextUp(f);
-    }
+//    public static float nextUp(float f) {
+//        return sun.misc.FpUtils.nextUp(f);
+//    }
 
 
     /**
@@ -1486,9 +1483,9 @@
      * @return {@code d} &times; 2<sup>{@code scaleFactor}</sup>
      * @since 1.6
      */
-    public static double scalb(double d, int scaleFactor) {
-        return sun.misc.FpUtils.scalb(d, scaleFactor);
-    }
+//    public static double scalb(double d, int scaleFactor) {
+//        return sun.misc.FpUtils.scalb(d, scaleFactor);
+//    }
 
     /**
      * Return {@code f} &times;
@@ -1520,7 +1517,7 @@
      * @return {@code f} &times; 2<sup>{@code scaleFactor}</sup>
      * @since 1.6
      */
-    public static float scalb(float f, int scaleFactor) {
-        return sun.misc.FpUtils.scalb(f, scaleFactor);
-    }
+//    public static float scalb(float f, int scaleFactor) {
+//        return sun.misc.FpUtils.scalb(f, scaleFactor);
+//    }
 }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/StrictMath.java
--- a/emul/src/main/java/java/lang/StrictMath.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/StrictMath.java	Sun Sep 30 18:29:37 2012 -0700
@@ -24,9 +24,6 @@
  */
 
 package java.lang;
-import java.util.Random;
-import sun.misc.FpUtils;
-import sun.misc.DoubleConsts;
 
 /**
  * The class {@code StrictMath} contains methods for performing basic
@@ -352,7 +349,7 @@
                                       double negativeBoundary,
                                       double positiveBoundary,
                                       double sign) {
-        int exponent = Math.getExponent(a);
+        int exponent = getExponent(a);
 
         if (exponent < 0) {
             /*
@@ -373,7 +370,7 @@
         assert exponent >= 0 && exponent <= 51;
 
         long doppel = Double.doubleToRawLongBits(a);
-        long mask   = DoubleConsts.SIGNIF_BIT_MASK >> exponent;
+        long mask   = 0; // DoubleConsts.SIGNIF_BIT_MASK >> exponent;
 
         if ( (mask & doppel) == 0L )
             return a; // integral value
@@ -402,6 +399,7 @@
      * @author Joseph D. Darcy
      */
     public static double rint(double a) {
+        throw new UnsupportedOperationException();
         /*
          * If the absolute value of a is not less than 2^52, it
          * is either a finite integer (the double format does not have
@@ -427,15 +425,15 @@
          * last multiply in the return statement is by plus or minus
          * 1.0, which is exact too.
          */
-        double twoToThe52 = (double)(1L << 52); // 2^52
-        double sign = FpUtils.rawCopySign(1.0, a); // preserve sign info
-        a = Math.abs(a);
-
-        if (a < twoToThe52) { // E_min <= ilogb(a) <= 51
-            a = ((twoToThe52 + a ) - twoToThe52);
-        }
-
-        return sign * a; // restore original sign
+//        double twoToThe52 = (double)(1L << 52); // 2^52
+//        double sign = FpUtils.rawCopySign(1.0, a); // preserve sign info
+//        a = Math.abs(a);
+//
+//        if (a < twoToThe52) { // E_min <= ilogb(a) <= 51
+//            a = ((twoToThe52 + a ) - twoToThe52);
+//        }
+//
+//        return sign * a; // restore original sign
     }
 
     /**
@@ -659,13 +657,6 @@
         return Math.round(a);
     }
 
-    private static Random randomNumberGenerator;
-
-    private static synchronized Random initRNG() {
-        Random rnd = randomNumberGenerator;
-        return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;
-    }
-
     /**
      * Returns a {@code double} value with a positive sign, greater
      * than or equal to {@code 0.0} and less than {@code 1.0}.
@@ -690,9 +681,7 @@
      * @see Random#nextDouble()
      */
     public static double random() {
-        Random rnd = randomNumberGenerator;
-        if (rnd == null) rnd = initRNG();
-        return rnd.nextDouble();
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -955,7 +944,7 @@
      * @since 1.5
      */
     public static double ulp(double d) {
-        return sun.misc.FpUtils.ulp(d);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -982,7 +971,7 @@
      * @since 1.5
      */
     public static float ulp(float f) {
-        return sun.misc.FpUtils.ulp(f);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1003,7 +992,7 @@
      * @since 1.5
      */
     public static double signum(double d) {
-        return sun.misc.FpUtils.signum(d);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1024,7 +1013,7 @@
      * @since 1.5
      */
     public static float signum(float f) {
-        return sun.misc.FpUtils.signum(f);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1202,7 +1191,7 @@
      * @since 1.6
      */
     public static double copySign(double magnitude, double sign) {
-        return sun.misc.FpUtils.copySign(magnitude, sign);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1218,7 +1207,7 @@
      * @since 1.6
      */
     public static float copySign(float magnitude, float sign) {
-        return sun.misc.FpUtils.copySign(magnitude, sign);
+        throw new UnsupportedOperationException();
     }
     /**
      * Returns the unbiased exponent used in the representation of a
@@ -1234,7 +1223,7 @@
      * @since 1.6
      */
     public static int getExponent(float f) {
-        return sun.misc.FpUtils.getExponent(f);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1251,7 +1240,7 @@
      * @since 1.6
      */
     public static int getExponent(double d) {
-        return sun.misc.FpUtils.getExponent(d);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1294,7 +1283,7 @@
      * @since 1.6
      */
     public static double nextAfter(double start, double direction) {
-        return sun.misc.FpUtils.nextAfter(start, direction);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1336,7 +1325,7 @@
      * @since 1.6
      */
     public static float nextAfter(float start, double direction) {
-        return sun.misc.FpUtils.nextAfter(start, direction);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1365,7 +1354,7 @@
      * @since 1.6
      */
     public static double nextUp(double d) {
-        return sun.misc.FpUtils.nextUp(d);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1394,7 +1383,7 @@
      * @since 1.6
      */
     public static float nextUp(float f) {
-        return sun.misc.FpUtils.nextUp(f);
+        throw new UnsupportedOperationException();
     }
 
 
@@ -1429,7 +1418,7 @@
      * @since 1.6
      */
     public static double scalb(double d, int scaleFactor) {
-        return sun.misc.FpUtils.scalb(d, scaleFactor);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -1463,6 +1452,6 @@
      * @since 1.6
      */
     public static float scalb(float f, int scaleFactor) {
-        return sun.misc.FpUtils.scalb(f, scaleFactor);
+        throw new UnsupportedOperationException();
     }
 }
diff -r 89b2cb4068fc -r d65b3a2fbfaf emul/src/main/java/java/lang/String.java
--- a/emul/src/main/java/java/lang/String.java	Sun Sep 30 17:42:21 2012 -0700
+++ b/emul/src/main/java/java/lang/String.java	Sun Sep 30 18:29:37 2012 -0700
@@ -3054,5 +3054,8 @@
             dst[dstBegin++] = value[srcBegin++];
         }
     }
-
+    // access system property
+    static String getProperty(String nm) {
+        return null;
+    }
 }