From 855dd2bcff9e32e053bf66e336405ded26e9c927 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Wed, 8 Feb 2006 18:06:11 +0000 Subject: re PR java/22578 (should inline floatToIntBits et al) gcc/java PR java/22578: * check-init.c (check_init): Handle VIEW_CONVERT_EXPR. * builtins.c (convert_real): New function. (java_builtins): Handle Float.intBitsToFloat, Float.floatToRawIntBits, Double.longBitsToDouble, Double.doubleToRawLongBits. libjava PR java/22578: * gcj/javaprims.h: Updated. * sources.am, Makefile.in: Rebuilt. * java/lang/natDouble.cc (doubleToLongBits): Moved to VMDouble. (doubleToRawLongBits): Likewise. (longBitsToDouble): Likewise. (toString): Likewise. (parseDouble): Likewise. * java/lang/natFloat.cc (floatToIntBits): Moved to VMFloat. (floatToRawIntBits): Likewise. (intBitsToFloat): Likewise. * java/lang/VMDouble.java: New file. * java/lang/VMFloat.java: New file. * java/lang/Float.java, java/lang/Double.java: Removed. From-SVN: r110759 --- libjava/java/lang/Double.java | 546 ------------------------------------------ 1 file changed, 546 deletions(-) delete mode 100644 libjava/java/lang/Double.java (limited to 'libjava/java/lang/Double.java') diff --git a/libjava/java/lang/Double.java b/libjava/java/lang/Double.java deleted file mode 100644 index 92f8a230822..00000000000 --- a/libjava/java/lang/Double.java +++ /dev/null @@ -1,546 +0,0 @@ -/* Double.java -- object wrapper for double - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 - Free Software Foundation, Inc. - -This file is part of GNU Classpath. - -GNU Classpath is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU Classpath is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU Classpath; see the file COPYING. If not, write to the -Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301 USA. - -Linking this library statically or dynamically with other modules is -making a combined work based on this library. Thus, the terms and -conditions of the GNU General Public License cover the whole -combination. - -As a special exception, the copyright holders of this library give you -permission to link this library with independent modules to produce an -executable, regardless of the license terms of these independent -modules, and to copy and distribute the resulting executable under -terms of your choice, provided that you also meet, for each linked -independent module, the terms and conditions of the license of that -module. An independent module is a module which is not derived from -or based on this library. If you modify this library, you may extend -this exception to your version of the library, but you are not -obligated to do so. If you do not wish to do so, delete this -exception statement from your version. */ - -package java.lang; - - -/** - * Instances of class Double represent primitive - * double values. - * - * Additionally, this class provides various helper functions and variables - * related to doubles. - * - * @author Paul Fisher - * @author Andrew Haley (aph@cygnus.com) - * @author Eric Blake (ebb9@email.byu.edu) - * @since 1.0 - * @status updated to 1.4 - */ -public final class Double extends Number implements Comparable -{ - /** - * Compatible with JDK 1.0+. - */ - private static final long serialVersionUID = -9172774392245257468L; - - /** - * The maximum positive value a double may represent - * is 1.7976931348623157e+308. - */ - public static final double MAX_VALUE = 1.7976931348623157e+308; - - /** - * The minimum positive value a double may represent - * is 5e-324. - */ - public static final double MIN_VALUE = 5e-324; - - /** - * The value of a double representation -1.0/0.0, negative - * infinity. - */ - public static final double NEGATIVE_INFINITY = -1.0 / 0.0; - - /** - * The value of a double representing 1.0/0.0, positive infinity. - */ - public static final double POSITIVE_INFINITY = 1.0 / 0.0; - - /** - * All IEEE 754 values of NaN have the same value in Java. - */ - public static final double NaN = 0.0 / 0.0; - - /** - * The number of bits needed to represent a double. - * @since 1.5 - */ - public static final int SIZE = 64; - - /** - * The primitive type double is represented by this - * Class object. - * @since 1.1 - */ - public static final Class TYPE = VMClassLoader.getPrimitiveClass('D'); - - /** - * The immutable value of this Double. - * - * @serial the wrapped double - */ - private final double value; - - /** - * Create a Double from the primitive double - * specified. - * - * @param value the double argument - */ - public Double(double value) - { - this.value = value; - } - - /** - * Create a Double from the specified String. - * This method calls Double.parseDouble(). - * - * @param s the String to convert - * @throws NumberFormatException if s cannot be parsed as a - * double - * @throws NullPointerException if s is null - * @see #parseDouble(String) - */ - public Double(String s) - { - value = parseDouble(s); - } - - /** - * Convert the double to a String. - * Floating-point string representation is fairly complex: here is a - * rundown of the possible values. "[-]" indicates that a - * negative sign will be printed if the value (or exponent) is negative. - * "<number>" means a string of digits ('0' to '9'). - * "<digit>" means a single digit ('0' to '9').
- * - * - * - * - * - * - * - * - * - * - *
Value of DoubleString Representation
[+-] 0 [-]0.0
Between [+-] 10-3 and 107, exclusive[-]number.number
Other numeric value[-]<digit>.<number> - * E[-]<number>
[+-] infinity [-]Infinity
NaN NaN
- * - * Yes, negative zero is a possible value. Note that there is - * always a . and at least one digit printed after - * it: even if the number is 3, it will be printed as 3.0. - * After the ".", all digits will be printed except trailing zeros. The - * result is rounded to the shortest decimal number which will parse back - * to the same double. - * - *

To create other output formats, use {@link java.text.NumberFormat}. - * - * @XXX specify where we are not in accord with the spec. - * - * @param d the double to convert - * @return the String representing the double - */ - public static String toString(double d) - { - return toString(d, false); - } - - /** - * Returns a Double object wrapping the value. - * In contrast to the Double constructor, this method - * may cache some values. It is used by boxing conversion. - * - * @param val the value to wrap - * @return the Double - * - * @since 1.5 - */ - public static Double valueOf(double val) - { - // We don't actually cache, but we could. - return new Double(val); - } - - /** - * Create a new Double object using the String. - * - * @param s the String to convert - * @return the new Double - * @throws NumberFormatException if s cannot be parsed as a - * double - * @throws NullPointerException if s is null. - * @see #parseDouble(String) - */ - public static Double valueOf(String s) - { - return new Double(parseDouble(s)); - } - - /** - * Parse the specified String as a double. The - * extended BNF grammar is as follows:
- * 

-   * DecodableString:
-   *      ( [ - | + ] NaN )
-   *    | ( [ - | + ] Infinity )
-   *    | ( [ - | + ] FloatingPoint
-   *              [ f | F | d
-   *                | D] )
-   * FloatingPoint:
-   *      ( { Digit }+ [ . { Digit } ]
-   *              [ Exponent ] )
-   *    | ( . { Digit }+ [ Exponent ] )
-   * Exponent:
-   *      ( ( e | E )
-   *              [ - | + ] { Digit }+ )
-   * Digit: '0' through '9'
-   *
- * - *

NaN and infinity are special cases, to allow parsing of the output - * of toString. Otherwise, the result is determined by calculating - * n * 10exponent to infinite precision, then rounding - * to the nearest double. Remember that many numbers cannot be precisely - * represented in floating point. In case of overflow, infinity is used, - * and in case of underflow, signed zero is used. Unlike Integer.parseInt, - * this does not accept Unicode digits outside the ASCII range. - * - *

If an unexpected character is found in the String, a - * NumberFormatException will be thrown. Leading and trailing - * 'whitespace' is ignored via String.trim(), but spaces - * internal to the actual number are not allowed. - * - *

To parse numbers according to another format, consider using - * {@link java.text.NumberFormat}. - * - * @XXX specify where/how we are not in accord with the spec. - * - * @param str the String to convert - * @return the double value of s - * @throws NumberFormatException if s cannot be parsed as a - * double - * @throws NullPointerException if s is null - * @see #MIN_VALUE - * @see #MAX_VALUE - * @see #POSITIVE_INFINITY - * @see #NEGATIVE_INFINITY - * @since 1.2 - */ - public static native double parseDouble(String str); - - /** - * Return true if the double has the same - * value as NaN, otherwise return false. - * - * @param v the double to compare - * @return whether the argument is NaN. - */ - public static boolean isNaN(double v) - { - // This works since NaN != NaN is the only reflexive inequality - // comparison which returns true. - return v != v; - } - - /** - * Return true if the double has a value - * equal to either NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. - * - * @param v the double to compare - * @return whether the argument is (-/+) infinity. - */ - public static boolean isInfinite(double v) - { - return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY; - } - - /** - * Return true if the value of this Double - * is the same as NaN, otherwise return false. - * - * @return whether this Double is NaN - */ - public boolean isNaN() - { - return isNaN(value); - } - - /** - * Return true if the value of this Double - * is the same as NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. - * - * @return whether this Double is (-/+) infinity - */ - public boolean isInfinite() - { - return isInfinite(value); - } - - /** - * Convert the double value of this Double - * to a String. This method calls - * Double.toString(double) to do its dirty work. - * - * @return the String representation - * @see #toString(double) - */ - public String toString() - { - return toString(value); - } - - /** - * Return the value of this Double as a byte. - * - * @return the byte value - * @since 1.1 - */ - public byte byteValue() - { - return (byte) value; - } - - /** - * Return the value of this Double as a short. - * - * @return the short value - * @since 1.1 - */ - public short shortValue() - { - return (short) value; - } - - /** - * Return the value of this Double as an int. - * - * @return the int value - */ - public int intValue() - { - return (int) value; - } - - /** - * Return the value of this Double as a long. - * - * @return the long value - */ - public long longValue() - { - return (long) value; - } - - /** - * Return the value of this Double as a float. - * - * @return the float value - */ - public float floatValue() - { - return (float) value; - } - - /** - * Return the value of this Double. - * - * @return the double value - */ - public double doubleValue() - { - return value; - } - - /** - * Return a hashcode representing this Object. Double's hash - * code is calculated by:
- * long v = Double.doubleToLongBits(doubleValue());
- * int hash = (int)(v^(v>>32)). - * - * @return this Object's hash code - * @see #doubleToLongBits(double) - */ - public int hashCode() - { - long v = doubleToLongBits(value); - return (int) (v ^ (v >>> 32)); - } - - /** - * Returns true if obj is an instance of - * Double and represents the same double value. Unlike comparing - * two doubles with ==, this treats two instances of - * Double.NaN as equal, but treats 0.0 and - * -0.0 as unequal. - * - *

Note that d1.equals(d2) is identical to - * doubleToLongBits(d1.doubleValue()) == - * doubleToLongBits(d2.doubleValue()). - * - * @param obj the object to compare - * @return whether the objects are semantically equal - */ - public boolean equals(Object obj) - { - if (! (obj instanceof Double)) - return false; - - double d = ((Double) obj).value; - - // Avoid call to native method. However, some implementations, like gcj, - // are better off using floatToIntBits(value) == floatToIntBits(f). - // Check common case first, then check NaN and 0. - if (value == d) - return (value != 0) || (1 / value == 1 / d); - return isNaN(value) && isNaN(d); - } - - /** - * Convert the double to the IEEE 754 floating-point "double format" bit - * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 - * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 - * (masked by 0x000fffffffffffffL) are the mantissa. This function - * collapses all versions of NaN to 0x7ff8000000000000L. The result of this - * function can be used as the argument to - * Double.longBitsToDouble(long) to obtain the original - * double value. - * - * @param value the double to convert - * @return the bits of the double - * @see #longBitsToDouble(long) - */ - // GCJ LOCAL: We diverge from Classpath for efficiency. - public static native long doubleToLongBits(double value); - // END GCJ LOCAL - - /** - * Convert the double to the IEEE 754 floating-point "double format" bit - * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 - * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 - * (masked by 0x000fffffffffffffL) are the mantissa. This function - * leaves NaN alone, rather than collapsing to a canonical value. The - * result of this function can be used as the argument to - * Double.longBitsToDouble(long) to obtain the original - * double value. - * - * @param value the double to convert - * @return the bits of the double - * @see #longBitsToDouble(long) - */ - // GCJ LOCAL: We diverge from Classpath for efficiency. - public static native long doubleToRawLongBits(double value); - // END GCJ LOCAL - - /** - * Convert the argument in IEEE 754 floating-point "double format" bit - * layout to the corresponding float. Bit 63 (the most significant) is the - * sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the - * exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa. - * This function leaves NaN alone, so that you can recover the bit pattern - * with Double.doubleToRawLongBits(double). - * - * @param bits the bits to convert - * @return the double represented by the bits - * @see #doubleToLongBits(double) - * @see #doubleToRawLongBits(double) - */ - // GCJ LOCAL: We diverge from Classpath for efficiency. - public static native double longBitsToDouble(long bits); - // END GCJ LOCAL - - /** - * Compare two Doubles numerically by comparing their double - * values. The result is positive if the first is greater, negative if the - * second is greater, and 0 if the two are equal. However, this special - * cases NaN and signed zero as follows: NaN is considered greater than - * all other doubles, including POSITIVE_INFINITY, and positive - * zero is considered greater than negative zero. - * - * @param d the Double to compare - * @return the comparison - * @since 1.2 - */ - public int compareTo(Double d) - { - return compare(value, d.value); - } - - /** - * Behaves like compareTo(Double) unless the Object - * is not an Double. - * - * @param o the object to compare - * @return the comparison - * @throws ClassCastException if the argument is not a Double - * @see #compareTo(Double) - * @see Comparable - * @since 1.2 - */ - public int compareTo(Object o) - { - return compare(value, ((Double) o).value); - } - - /** - * Behaves like new Double(x).compareTo(new Double(y)); in - * other words this compares two doubles, special casing NaN and zero, - * without the overhead of objects. - * - * @param x the first double to compare - * @param y the second double to compare - * @return the comparison - * @since 1.4 - */ - public static int compare(double x, double y) - { - if (isNaN(x)) - return isNaN(y) ? 0 : 1; - if (isNaN(y)) - return -1; - // recall that 0.0 == -0.0, so we convert to infinites and try again - if (x == 0 && y == 0) - return (int) (1 / x - 1 / y); - if (x == y) - return 0; - - return x > y ? 1 : -1; - } - - /** - * Helper method to convert to string. - * - * @param d the double to convert - * @param isFloat true if the conversion is requested by Float (results in - * fewer digits) - */ - // Package visible for use by Float. - static native String toString(double d, boolean isFloat); -} -- cgit v1.2.3