Support for floating point conversions and tests

Floats and doubles can now be read from strings, using the C standard library
functions for this purpose (strtof and strtod).  The code also relies on
standard library functions to implement isNaN() and isInfinite()

classpath/java-lang.cpp

@@ -431,6 +431,70 @@ Java_java_lang_System_doMapLibraryName(JNIEnv* e, jclass, jstring name)
   return r;
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_java_lang_Double_isInfinite(JNIEnv*, jclass, jdouble val)
+{
+  return !isfinite(val);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_java_lang_Double_isNaN(JNIEnv*, jclass, jdouble val)
+{
+  return isnan(val);
+}
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_java_lang_Double_doubleFromString(JNIEnv*e, jclass, jstring s,
+				       jintArray numDoublesRead)
+{
+  const char* chars = e->GetStringUTFChars(s, 0);
+  double d = 0.0;
+  int numRead = 0;
+
+  if (chars) {
+    char* lastRead;
+    d = strtod(chars, &lastRead);
+    if ((lastRead != chars) && ((chars + strlen(chars)) == lastRead)) {
+      numRead = 1;
+    }
+    e->ReleaseStringUTFChars(s, chars);
+  }
+  e->SetIntArrayRegion(numDoublesRead, 0, 1, &numRead);
+  return d;
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_java_lang_Float_isInfinite(JNIEnv*, jclass, jfloat val)
+{
+  return !isfinite(val);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_java_lang_Float_isNaN(JNIEnv*, jclass, jfloat val)
+{
+  return isnan(val);
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_java_lang_Float_floatFromString(JNIEnv*e, jclass, jstring s,
+				     jintArray numFloatsRead)
+{
+  const char* chars = e->GetStringUTFChars(s, 0);
+  float f = 0.0;
+  int numRead = 0;
+
+  if (chars) {
+    char* lastRead;
+    f = strtof(chars, &lastRead);
+    if ((lastRead != chars) && ((chars + strlen(chars)) == lastRead)) {
+      numRead = 1;
+    }
+    e->ReleaseStringUTFChars(s, chars);
+  }
+  e->SetIntArrayRegion(numFloatsRead, 0, 1, &numRead);
+  return f;
+}
+
 extern "C" JNIEXPORT jdouble JNICALL
 Java_java_lang_Math_sin(JNIEnv*, jclass, jdouble val)
 {

classpath/java/lang/Double.java

@@ -31,6 +31,10 @@ public final class Double extends Number {
     return new Double(value);
   }
 
+  public static Double valueOf(String s) {
+    return new Double(s);
+  }
+
   public boolean equals(Object o) {
     return o instanceof Double && ((Double) o).value == value;
   }
@@ -74,10 +78,23 @@ public final class Double extends Number {
     return value;
   }
 
+  public boolean isInfinite() {
+    return isInfinite(value);
+  }
+
+  public boolean isNaN() {
+    return isNaN(value);
+  }
+
   public static double parseDouble(String s) {
-    // todo
+    int[] numRead = new int[1];
+    double d = doubleFromString(s, numRead);
+    if (numRead[0] == 1) {
+      return d;
+    } else {
       throw new NumberFormatException(s);
     }
+  }
 
   public static native int fillBufferWithDouble(double value, byte[] buffer,
                                                 int charCount);
@@ -85,4 +102,10 @@ public final class Double extends Number {
   public static native long doubleToRawLongBits(double value);
 
   public static native double longBitsToDouble(long bits);
+
+  public static native boolean isInfinite(double value);
+
+  public static native boolean isNaN(double value);
+
+  public static native double doubleFromString(String s, int[] numRead);
 }

classpath/java/lang/Float.java

@@ -15,6 +15,10 @@ public final class Float extends Number {
 
   private final float value;
 
+  public Float(String value) {
+    this.value = parseFloat(value);
+  }
+
   public Float(float value) {
     this.value = value;
   }
@@ -23,6 +27,10 @@ public final class Float extends Number {
     return new Float(value);
   }
 
+  public static Float valueOf(String s) {
+    return new Float(s);
+  }
+
   public boolean equals(Object o) {
     return o instanceof Float && ((Float) o).value == value;
   }
@@ -63,12 +71,31 @@ public final class Float extends Number {
     return (double) value;
   }
 
+  public boolean isInfinite() {
+    return isInfinite(value);
+  }
+
+  public boolean isNaN() {
+    return isNaN(value);
+  }
+
   public static float parseFloat(String s) {
-    // todo
+    int[] numRead = new int[1];
+    float f = floatFromString(s, numRead);
+    if (numRead[0] == 1) {
+      return f;
+    } else {
       throw new NumberFormatException(s);
     }
+  }
 
   public static native int floatToRawIntBits(float value);
 
   public static native float intBitsToFloat(int bits);
+
+  public static native boolean isInfinite(float value);
+
+  public static native boolean isNaN(float value);
+
+  public static native float floatFromString(String s, int[] numRead);
 }