+2002-06-13 Tom Tromey <tromey@redhat.com>
+
+ * java/lang/natString.cc (init): Handle case where DONT_COPY is
+ true and OFFSET!=0.
+ * java/lang/String.java (String(char[],int,int,boolean): New
+ constructor.
+ * java/lang/Long.java: Imported new version from Classpath.
+ * java/lang/Number.java: Likewise.
+ * java/lang/Integer.java: Likewise.
+ * java/lang/Long.java: Likewise.
+ * java/lang/Float.java: Likewise.
+ * java/lang/Boolean.java: Likewise.
+ * java/lang/Double.java: Likewise.
+ * java/lang/Void.java: Likewise.
+
2002-06-12 Tom Tromey <tromey@redhat.com>
* java/io/natFilePosix.cc (getCanonicalPath): Treat "" like ".".
/* Boolean.java -- object wrapper for boolean
- Copyright (C) 1998, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
import java.io.Serializable;
/**
- * Instances of class <code>Boolean</code> represent primitive
+ * Instances of class <code>Boolean</code> represent primitive
* <code>boolean</code> values.
*
* @author Paul Fisher
- * @since JDK1.0
- */
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
+ */
public final class Boolean implements Serializable
{
- static final long serialVersionUID = -3665804199014368530L;
-
- /**
- * This field is a <code>Boolean</code> object representing the
- * primitive value <code>true</code>. This instance is returned
- * by the static <code>valueOf()</code> methods if they return
- * a <code>Boolean</code> representing <code>true</code>.
- */
- public static final Boolean TRUE = new Boolean(true);
-
- /**
- * This field is a <code>Boolean</code> object representing the
- * primitive value <code>false</code>. This instance is returned
- * by the static <code>valueOf()</code> methods if they return
- * a <code>Boolean</code> representing <code>false</code>.
- */
- public static final Boolean FALSE = new Boolean(false);
-
- /**
- * The primitive type <code>boolean</code> is represented by this
- * <code>Class</code> object.
- */
- public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
-
- /**
- * The immutable value of this Boolean.
- */
- private final boolean value;
-
- /**
- * Create a <code>Boolean</code> object representing the value of the
- * argument <code>value</code>. In general the use of the static
- * method <code>valueof(boolean)</code> is more efficient since it will
- * not create a new object.
- *
- * @param value the primitive value of this <code>Boolean</code>
- */
- public Boolean(boolean value) {
- this.value = value;
- }
-
- /**
- * Creates a <code>Boolean</code> object representing the primitive
- * <code>true</code> if and only if <code>s</code> matches
- * the string "true" ignoring case, otherwise the object will represent
- * the primitive <code>false</code>. In general the use of the static
- * method <code>valueof(String)</code> is more efficient since it will
- * not create a new object.
- *
- * @param s the <code>String</code> representation of <code>true</code>
- * or false
- */
- public Boolean(String s) {
- value = "true".equalsIgnoreCase(s);
- }
-
- /**
- * Return the primitive <code>boolean</code> value of this
- * <code>Boolean</code> object.
- */
- public boolean booleanValue() {
- return value;
- }
-
- /**
- * Returns the Boolean <code>TRUE</code> if the given boolean is
- * <code>true</code>, otherwise it will return the Boolean
- * <code>FALSE</code>.
- *
- * @since 1.4
- */
- public static Boolean valueOf(boolean b) {
- return b ? TRUE : FALSE;
- }
-
- /**
- * Returns the Boolean <code>TRUE</code> if and only if the given
- * String is equal, ignoring case, to the the String "true", otherwise
- * it will return the Boolean <code>FALSE</code>.
- */
- public static Boolean valueOf(String s) {
- return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
- }
-
- /**
- * Returns the integer <code>1231</code> if this object represents
- * the primitive <code>true</code> and the integer <code>1237</code>
- * otherwise.
- */
- public int hashCode() {
- return (value) ? 1231 : 1237;
- }
-
- /**
- * If the <code>obj</code> is an instance of <code>Boolean</code> and
- * has the same primitive value as this object then <code>true</code>
- * is returned. In all other cases, including if the <code>obj</code>
- * is <code>null</code>, <code>false</code> is returned.
- *
- * @param obj possibly an instance of any <code>Class</code>
- * @return <code>false</code> is <code>obj</code> is an instance of
- * <code>Boolean</code> and has the same primitive value as this
- * object.
- */
- public boolean equals(Object obj) {
- return (obj instanceof Boolean && value == ((Boolean)obj).value);
- }
-
- /**
- * If the value of the system property <code>name</code> matches
- * "true" ignoring case then the function returns <code>true</code>.
- */
- public static boolean getBoolean(String name) {
- String val = System.getProperty(name);
- return ("true".equalsIgnoreCase(val));
- }
-
- /**
- * Returns "true" if the value of the give boolean is <code>true</code> and
- * returns "false" if the value of the given boolean is <code>false</code>.
- *
- * @since 1.4
- */
- public static String toString(boolean b)
- {
- return b ? "true" : "false";
- }
-
- /**
- * Returns "true" if the value of this object is <code>true</code> and
- * returns "false" if the value of this object is <code>false</code>.
- */
- public String toString()
- {
- return (value) ? "true" : "false";
- }
+ /**
+ * Compatible with JDK 1.0.2+.
+ */
+ private static final long serialVersionUID = -3665804199014368530L;
+
+ /**
+ * This field is a <code>Boolean</code> object representing the
+ * primitive value <code>true</code>. This instance is returned
+ * by the static <code>valueOf()</code> methods if they return
+ * a <code>Boolean</code> representing <code>true</code>.
+ */
+ public static final Boolean TRUE = new Boolean(true);
+
+ /**
+ * This field is a <code>Boolean</code> object representing the
+ * primitive value <code>false</code>. This instance is returned
+ * by the static <code>valueOf()</code> methods if they return
+ * a <code>Boolean</code> representing <code>false</code>.
+ */
+ public static final Boolean FALSE = new Boolean(false);
+
+ /**
+ * The primitive type <code>boolean</code> is represented by this
+ * <code>Class</code> object.
+ *
+ * @since 1.1
+ */
+ public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
+
+ /**
+ * The immutable value of this Boolean.
+ * @serial the wrapped value
+ */
+ private final boolean value;
+
+ /**
+ * Create a <code>Boolean</code> object representing the value of the
+ * argument <code>value</code>. In general the use of the static
+ * method <code>valueof(boolean)</code> is more efficient since it will
+ * not create a new object.
+ *
+ * @param value the primitive value of this <code>Boolean</code>
+ * @see #valueOf(boolean)
+ */
+ public Boolean(boolean value)
+ {
+ this.value = value;
+ }
+
+ /**
+ * Creates a <code>Boolean</code> object representing the primitive
+ * <code>true</code> if and only if <code>s</code> matches
+ * the string "true" ignoring case, otherwise the object will represent
+ * the primitive <code>false</code>. In general the use of the static
+ * method <code>valueof(String)</code> is more efficient since it will
+ * not create a new object.
+ *
+ * @param s the <code>String</code> representation of <code>true</code>
+ * or false
+ */
+ public Boolean(String s)
+ {
+ value = "true".equalsIgnoreCase(s);
+ }
+
+ /**
+ * Return the primitive <code>boolean</code> value of this
+ * <code>Boolean</code> object.
+ *
+ * @return true or false, depending on the value of this Boolean
+ */
+ public boolean booleanValue()
+ {
+ return value;
+ }
+
+ /**
+ * Returns the Boolean <code>TRUE</code> if the given boolean is
+ * <code>true</code>, otherwise it will return the Boolean
+ * <code>FALSE</code>.
+ *
+ * @param b the boolean to wrap
+ * @return the wrapper object
+ * @see #TRUE
+ * @see #FALSE
+ * @since 1.4
+ */
+ public static Boolean valueOf(boolean b)
+ {
+ return b ? TRUE : FALSE;
+ }
+
+ /**
+ * Returns the Boolean <code>TRUE</code> if and only if the given
+ * String is equal, ignoring case, to the the String "true", otherwise
+ * it will return the Boolean <code>FALSE</code>.
+ *
+ * @param s the string to convert
+ * @return a wrapped boolean from the string
+ */
+ public static Boolean valueOf(String s)
+ {
+ return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
+ }
+
+ /**
+ * Returns "true" if the value of the give boolean is <code>true</code> and
+ * returns "false" if the value of the given boolean is <code>false</code>.
+ *
+ * @param b the boolean to convert
+ * @return the string representation of the boolean
+ * @since 1.4
+ */
+ public static String toString(boolean b)
+ {
+ return b ? "true" : "false";
+ }
+
+ /**
+ * Returns "true" if the value of this object is <code>true</code> and
+ * returns "false" if the value of this object is <code>false</code>.
+ *
+ * @return the string representation of this
+ */
+ public String toString()
+ {
+ return value ? "true" : "false";
+ }
+
+ /**
+ * Returns the integer <code>1231</code> if this object represents
+ * the primitive <code>true</code> and the integer <code>1237</code>
+ * otherwise.
+ *
+ * @return the hash code
+ */
+ public int hashCode()
+ {
+ return value ? 1231 : 1237;
+ }
+
+ /**
+ * If the <code>obj</code> is an instance of <code>Boolean</code> and
+ * has the same primitive value as this object then <code>true</code>
+ * is returned. In all other cases, including if the <code>obj</code>
+ * is <code>null</code>, <code>false</code> is returned.
+ *
+ * @param obj possibly an instance of any <code>Class</code>
+ * @return true if <code>obj</code> equals this
+ */
+ public boolean equals(Object obj)
+ {
+ return obj instanceof Boolean && value == ((Boolean) obj).value;
+ }
+
+ /**
+ * If the value of the system property <code>name</code> matches
+ * "true" ignoring case then the function returns <code>true</code>.
+ *
+ * @param name the property name to look up
+ * @return true if the property resulted in "true"
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ */
+ public static boolean getBoolean(String name)
+ {
+ if (name == null || "".equals(name))
+ return false;
+ return "true".equalsIgnoreCase(System.getProperty(name));
+ }
}
-/* Double.java -- object wrapper for double primitive
+/* Double.java -- object wrapper for double
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
import gnu.classpath.Configuration;
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
- * "The Java Language Specification", ISBN 0-201-63451-1
- * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct.
- */
-
/**
* Instances of class <code>Double</code> represent primitive
* <code>double</code> values.
*
* @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com>
- * @since JDK 1.0
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
*/
public final class Double extends Number implements Comparable
{
/**
- * The minimum positive value a <code>double</code> may represent
- * is 5e-324.
+ * Compatible with JDK 1.0+.
*/
- public static final double MIN_VALUE = 5e-324;
+ private static final long serialVersionUID = -9172774392245257468L;
/**
* The maximum positive value a <code>double</code> may represent
*/
public static final double MAX_VALUE = 1.7976931348623157e+308;
+ /**
+ * The minimum positive value a <code>double</code> 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.
+ * infinity.
*/
- public static final double NEGATIVE_INFINITY = -1.0d/0.0d;
+ 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.0d/0.0d;
+ 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.0d/0.0d;
+ public static final double NaN = 0.0 / 0.0;
/**
* The primitive type <code>double</code> is represented by this
* <code>Class</code> 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;
- private static final long serialVersionUID = -9172774392245257468L;
-
/**
- * Load native routines necessary for this class.
+ * Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
- System.loadLibrary ("javalang");
- initIDs ();
+ System.loadLibrary("javalang");
+ initIDs();
}
}
*
* @param value the <code>double</code> argument
*/
- public Double (double value)
+ public Double(double value)
{
this.value = value;
}
/**
- * Create a <code>Double</code> from the specified
- * <code>String</code>.
- *
+ * Create a <code>Double</code> from the specified <code>String</code>.
* This method calls <code>Double.parseDouble()</code>.
*
- * @exception NumberFormatException when the <code>String</code> cannot
- * be parsed into a <code>Float</code>.
* @param s the <code>String</code> to convert
- * @see #parseDouble(java.lang.String)
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>double</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @see #parseDouble(String)
*/
- public Double (String s) throws NumberFormatException
+ public Double(String s)
{
- value = parseDouble (s);
+ value = parseDouble(s);
}
/**
- * Convert the <code>double</code> value of this <code>Double</code>
- * to a <code>String</code>. This method calls
- * <code>Double.toString(double)</code> to do its dirty work.
+ * Convert the <code>double</code> to a <code>String</code>.
+ * Floating-point string representation is fairly complex: here is a
+ * rundown of the possible values. "<code>[-]</code>" indicates that a
+ * negative sign will be printed if the value (or exponent) is negative.
+ * "<code><number></code>" means a string of digits ('0' to '9').
+ * "<code><digit></code>" means a single digit ('0' to '9').<br>
*
- * @return the <code>String</code> representation of this <code>Double</code>.
- * @see #toString(double)
+ * <table border=1>
+ * <tr><th>Value of Double</th><th>String Representation</th></tr>
+ * <tr><td>[+-] 0</td> <td><code>[-]0.0</code></td></tr>
+ * <tr><td>Between [+-] 10<sup>-3</sup> and 10<sup>7</sup>, exclusive</td>
+ * <td><code>[-]number.number</code></td></tr>
+ * <tr><td>Other numeric value</td>
+ * <td><code>[-]<digit>.<number>
+ * E[-]<number></code></td></tr>
+ * <tr><td>[+-] infinity</td> <td><code>[-]Infinity</code></td></tr>
+ * <tr><td>NaN</td> <td><code>NaN</code></td></tr>
+ * </table>
+ *
+ * Yes, negative zero <em>is</em> a possible value. Note that there is
+ * <em>always</em> a <code>.</code> and at least one digit printed after
+ * it: even if the number is 3, it will be printed as <code>3.0</code>.
+ * 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.
+ *
+ * <p>To create other output formats, use {@link java.text.NumberFormat}.
+ *
+ * @XXX specify where we are not in accord with the spec.
+ *
+ * @param d the <code>double</code> to convert
+ * @return the <code>String</code> representing the <code>double</code>
*/
- public String toString ()
+ public static String toString(double d)
{
- return toString (value);
+ return toString(d, false);
}
/**
- * If the <code>Object</code> is not <code>null</code>, is an
- * <code>instanceof</code> <code>Double</code>, and represents
- * the same primitive <code>double</code> value return
- * <code>true</code>. Otherwise <code>false</code> is returned.
- * <p>
- * Note that there are two differences between <code>==</code> and
- * <code>equals()</code>. <code>0.0d == -0.0d</code> returns <code>true</code>
- * but <code>new Double(0.0d).equals(new Double(-0.0d))</code> returns
- * <code>false</code>. And <code>Double.NaN == Double.NaN</code> returns
- * <code>false</code>, but
- * <code>new Double(Double.NaN).equals(new Double(Double.NaN))</code> returns
- * <code>true</code>.
+ * Create a new <code>Double</code> object using the <code>String</code>.
*
- * @param obj the object to compare to
- * @return whether the objects are semantically equal.
+ * @param s the <code>String</code> to convert
+ * @return the new <code>Double</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>double</code>
+ * @throws NullPointerException if <code>s</code> is null.
+ * @see #parseDouble(String)
*/
- public boolean equals (Object obj)
+ public static Double valueOf(String s)
{
- if (!(obj instanceof Double))
- return false;
-
- double d = ((Double) obj).value;
-
- // GCJ LOCAL: this implementation is probably faster than
- // Classpath's, especially once we inline doubleToLongBits.
- return doubleToLongBits (value) == doubleToLongBits (d);
- // END GCJ LOCAL
+ // XXX just call new Double(parseDouble(s));
+ if (s == null)
+ throw new NullPointerException();
+ return new Double(s);
}
/**
- * The hashcode is the value of the expression: <br>
- * <br>
- * <code>(int)(v^(v>>>32))</code><br>
- * <br>
- * where v is defined by: <br>
- * <code>long v = Double.doubleToLongBits(this.longValue());</code><br>
+ * Parse the specified <code>String</code> as a <code>double</code>. The
+ * extended BNF grammar is as follows:<br>
+ * <pre>
+ * <em>DecodableString</em>:
+ * ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
+ * | ( [ <code>-</code> | <code>+</code> ] <code>Infinity</code> )
+ * | ( [ <code>-</code> | <code>+</code> ] <em>FloatingPoint</em>
+ * [ <code>f</code> | <code>F</code> | <code>d</code>
+ * | <code>D</code>] )
+ * <em>FloatingPoint</em>:
+ * ( { <em>Digit</em> }+ [ <code>.</code> { <em>Digit</em> } ]
+ * [ <em>Exponent</em> ] )
+ * | ( <code>.</code> { <em>Digit</em> }+ [ <em>Exponent</em> ] )
+ * <em>Exponent</em>:
+ * ( ( <code>e</code> | <code>E</code> )
+ * [ <code>-</code> | <code>+</code> ] { <em>Digit</em> }+ )
+ * <em>Digit</em>: <em><code>'0'</code> through <code>'9'</code></em>
+ * </pre>
+ *
+ * <p>NaN and infinity are special cases, to allow parsing of the output
+ * of toString. Otherwise, the result is determined by calculating
+ * <em>n * 10<sup>exponent</sup></em> 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.
+ *
+ * <p>If an unexpected character is found in the <code>String</code>, a
+ * <code>NumberFormatException</code> will be thrown. Leading and trailing
+ * 'whitespace' is ignored via <code>String.trim()</code>, but spaces
+ * internal to the actual number are not allowed.
+ *
+ * <p>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 <code>String</code> to convert
+ * @return the <code>double</code> value of <code>s</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>double</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @see #MIN_VALUE
+ * @see #MAX_VALUE
+ * @see #POSITIVE_INFINITY
+ * @see #NEGATIVE_INFINITY
+ * @since 1.2
*/
- public int hashCode ()
- {
- long v = doubleToLongBits (value);
- return (int) (v ^ (v >>> 32));
- }
+ public static native double parseDouble(String s);
/**
- * Return the value of this <code>Double</code> when cast to an
- * <code>int</code>.
+ * Return <code>true</code> if the <code>double</code> has the same
+ * value as <code>NaN</code>, otherwise return <code>false</code>.
+ *
+ * @param v the <code>double</code> to compare
+ * @return whether the argument is <code>NaN</code>.
*/
- public int intValue ()
+ public static boolean isNaN(double v)
{
- return (int) value;
+ // This works since NaN != NaN is the only reflexive inequality
+ // comparison which returns true.
+ return v != v;
}
/**
- * Return the value of this <code>Double</code> when cast to a
- * <code>long</code>.
+ * Return <code>true</code> if the <code>double</code> has a value
+ * equal to either <code>NEGATIVE_INFINITY</code> or
+ * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ *
+ * @param v the <code>double</code> to compare
+ * @return whether the argument is (-/+) infinity.
*/
- public long longValue ()
+ public static boolean isInfinite(double v)
{
- return (long) value;
+ return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
}
/**
- * Return the value of this <code>Double</code> when cast to a
- * <code>float</code>.
+ * Return <code>true</code> if the value of this <code>Double</code>
+ * is the same as <code>NaN</code>, otherwise return <code>false</code>.
+ *
+ * @return whether this <code>Double</code> is <code>NaN</code>
*/
- public float floatValue ()
+ public boolean isNaN()
{
- return (float) value;
+ return isNaN(value);
}
/**
- * Return the primitive <code>double</code> value represented by this
- * <code>Double</code>.
+ * Return <code>true</code> if the value of this <code>Double</code>
+ * is the same as <code>NEGATIVE_INFINITY</code> or
+ * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ *
+ * @return whether this <code>Double</code> is (-/+) infinity
*/
- public double doubleValue ()
+ public boolean isInfinite()
{
- return value;
+ return isInfinite(value);
}
/**
- * Return the result of calling <code>new Double(java.lang.String)</code>.
- *
- * @param s the <code>String</code> to convert to a <code>Double</code>.
- * @return a new <code>Double</code> representing the <code>String</code>'s
- * numeric value.
+ * Convert the <code>double</code> value of this <code>Double</code>
+ * to a <code>String</code>. This method calls
+ * <code>Double.toString(double)</code> to do its dirty work.
*
- * @exception NullPointerException thrown if <code>String</code> is
- * <code>null</code>.
- * @exception NumberFormatException thrown if <code>String</code> cannot
- * be parsed as a <code>double</code>.
- * @see #Double(java.lang.String)
- * @see #parseDouble(java.lang.String)
+ * @return the <code>String</code> representation
+ * @see #toString(double)
*/
- public static Double valueOf (String s) throws NumberFormatException
+ public String toString()
{
- return new Double (s);
+ return toString(value);
}
/**
- * Return <code>true</code> if the value of this <code>Double</code>
- * is the same as <code>NaN</code>, otherwise return <code>false</code>.
- * @return whether this <code>Double</code> is <code>NaN</code>.
+ * Return the value of this <code>Double</code> as a <code>byte</code>.
+ *
+ * @return the byte value
+ * @since 1.1
*/
- public boolean isNaN ()
+ public byte byteValue()
{
- return isNaN (value);
+ return (byte) value;
}
/**
- * Return <code>true</code> if the <code>double</code> has the same
- * value as <code>NaN</code>, otherwise return <code>false</code>.
+ * Return the value of this <code>Double</code> as a <code>short</code>.
*
- * @param v the <code>double</code> to compare
- * @return whether the argument is <code>NaN</code>.
+ * @return the short value
+ * @since 1.1
*/
- public static boolean isNaN (double v)
+ public short shortValue()
{
- // This works since NaN != NaN is the only reflexive inequality
- // comparison which returns true.
- return v != v;
+ return (short) value;
}
/**
- * Return <code>true</code> if the value of this <code>Double</code>
- * is the same as <code>NEGATIVE_INFINITY</code> or
- * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ * Return the value of this <code>Double</code> as an <code>int</code>.
*
- * @return whether this <code>Double</code> is (-/+) infinity.
+ * @return the int value
*/
- public boolean isInfinite ()
+ public int intValue()
{
- return isInfinite (value);
+ return (int) value;
}
/**
- * Return <code>true</code> if the <code>double</code> has a value
- * equal to either <code>NEGATIVE_INFINITY</code> or
- * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ * Return the value of this <code>Double</code> as a <code>long</code>.
*
- * @param v the <code>double</code> to compare
- * @return whether the argument is (-/+) infinity.
+ * @return the long value
*/
- public static boolean isInfinite (double v)
+ public long longValue()
{
- return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY);
+ return (long) value;
}
/**
- * Returns 0 if the <code>double</code> value of the argument is
- * equal to the value of this <code>Double</code>. Returns a number
- * less than zero if the value of this <code>Double</code> is less
- * than the <code>double</code> value of the argument, and returns a
- * number greater than zero if the value of this <code>Double</code>
- * is greater than the <code>double</code> value of the argument.
- * <br>
- * <code>Double.NaN</code> is greater than any number other than itself,
- * even <code>Double.POSITIVE_INFINITY</code>.
- * <br>
- * <code>0.0d</code> is greater than <code>-0.0d</code>.
- *
- * @param d the Double to compare to.
- * @return 0 if the <code>Double</code>s are the same, < 0 if this
- * <code>Double</code> is less than the <code>Double</code> in
- * in question, or > 0 if it is greater.
- * @since 1.2
+ * Return the value of this <code>Double</code> as a <code>float</code>.
+ *
+ * @return the float value
*/
- public int compareTo (Double d)
+ public float floatValue()
{
- return compare (value, d.value);
+ return (float) value;
}
/**
- * Returns 0 if the first argument is equal to the second argument.
- * Returns a number less than zero if the first argument is less than the
- * second argument, and returns a number greater than zero if the first
- * argument is greater than the second argument.
- * <br>
- * <code>Double.NaN</code> is greater than any number other than itself,
- * even <code>Double.POSITIVE_INFINITY</code>.
- * <br>
- * <code>0.0d</code> is greater than <code>-0.0d</code>.
- *
- * @param x the first double to compare.
- * @param y the second double to compare.
- * @return 0 if the arguments are the same, < 0 if the
- * first argument is less than the second argument in
- * in question, or > 0 if it is greater.
- * @since 1.4
+ * Return the value of this <code>Double</code>.
+ *
+ * @return the double value
*/
- public static int compare (double x, double y)
+ public double doubleValue()
{
- 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;
+ return value;
}
/**
- * Compares the specified <code>Object</code> to this <code>Double</code>
- * if and only if the <code>Object</code> is an instanceof
- * <code>Double</code>.
+ * Return a hashcode representing this Object. <code>Double</code>'s hash
+ * code is calculated by:<br>
+ * <code>long v = Double.doubleToLongBits(doubleValue());<br>
+ * int hash = (int)(v^(v>>32))</code>.
*
- * @param o the Object to compare to.
- * @return 0 if the <code>Double</code>s are the same, < 0 if this
- * <code>Double</code> is less than the <code>Double</code> in
- * in question, or > 0 if it is greater.
- * @throws ClassCastException if the argument is not a <code>Double</code>
+ * @return this Object's hash code
+ * @see #doubleToLongBits(double)
*/
- public int compareTo (Object o)
+ public int hashCode()
{
- return compareTo ((Double) o);
+ long v = doubleToLongBits(value);
+ return (int) (v ^ (v >>> 32));
}
/**
- * Convert the <code>double</code> to a <code>String</code>.
- * <P>
- *
- * Floating-point string representation is fairly complex: here is a
- * rundown of the possible values. "<CODE>[-]</CODE>" indicates that a
- * negative sign will be printed if the value (or exponent) is negative.
- * "<CODE><number></CODE>" means a string of digits (0-9).
- * "<CODE><digit></CODE>" means a single digit (0-9).
- * <P>
- *
- * <TABLE BORDER=1>
- * <TR><TH>Value of Float</TH><TH>String Representation</TH></TR>
- * <TR>
- * <TD>[+-] 0</TD>
- * <TD>[<CODE>-</CODE>]<CODE>0.0</CODE></TD>
- * </TR>
- * <TR>
- * <TD>Between [+-] 10<SUP>-3</SUP> and 10<SUP>7</SUP></TD>
- * <TD><CODE>[-]number.number</CODE></TD>
- * </TR>
- * <TR>
- * <TD>Other numeric value</TD>
- * <TD><CODE>[-]<digit>.<number>E[-]<number></CODE></TD>
- * </TR>
- * <TR>
- * <TD>[+-] infinity</TD>
- * <TD><CODE>[-]Infinity</CODE></TD>
- * </TR>
- * <TR>
- * <TD>NaN</TD>
- * <TD><CODE>NaN</CODE></TD>
- * </TR>
- * </TABLE>
- *
- * Yes, negative zero <EM>is</EM> a possible value. Note that there is
- * <EM>always</EM> a <CODE>.</CODE> and at least one digit printed after
- * it: even if the number is 3, it will be printed as <CODE>3.0</CODE>.
- * After the ".", all digits will be printed except trailing zeros. No
- * truncation or rounding is done by this function.
- *
+ * Returns <code>true</code> if <code>obj</code> is an instance of
+ * <code>Double</code> and represents the same double value. Unlike comparing
+ * two doubles with <code>==</code>, this treats two instances of
+ * <code>Double.NaN</code> as equal, but treats <code>0.0</code> and
+ * <code>-0.0</code> as unequal.
*
- * @XXX specify where we are not in accord with the spec.
+ * <p>Note that <code>d1.equals(d2)<code> is identical to
+ * <code>doubleToLongBits(d1.doubleValue()) ==
+ * doubleToLongBits(d2.doubleValue())<code>.
*
- * @param d the <code>double</code> to convert
- * @return the <code>String</code> representing the <code>double</code>.
+ * @param obj the object to compare
+ * @return whether the objects are semantically equal
*/
- public static String toString (double d)
+ public boolean equals(Object obj)
{
- return toString (d, false);
- }
+ if (! (obj instanceof Double))
+ return false;
- static native String toString (double d, boolean isFloat);
+ 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);
+ }
/**
- * Return the long bits of the specified <code>double</code>.
- * The result of this function can be used as the argument to
- * <code>Double.longBitsToDouble(long)</code> to obtain the
- * original <code>double</code> value.
+ * 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
+ * <code>Double.longBitsToDouble(long)</code> to obtain the original
+ * <code>double</code> value.
*
* @param value the <code>double</code> to convert
- * @return the bits of the <code>double</code>.
+ * @return the bits of the <code>double</code>
+ * @see #longBitsToDouble(long)
*/
- public static native long doubleToLongBits (double value);
+ public static native long doubleToLongBits(double value);
/**
- * Return the long bits of the specified <code>double</code>.
- * The result of this function can be used as the argument to
- * <code>Double.longBitsToDouble(long)</code> to obtain the
- * original <code>double</code> value. This method differs from
- * <code>doubleToLongBits</code> in that it does not collapse
- * NaN values.
+ * 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
+ * <code>Double.longBitsToDouble(long)</code> to obtain the original
+ * <code>double</code> value.
*
* @param value the <code>double</code> to convert
- * @return the bits of the <code>double</code>.
- */
- public static native long doubleToRawLongBits (double value);
-
- /**
- * Return the <code>double</code> represented by the long
- * bits specified.
- *
- * @param bits the long bits representing a <code>double</code>
- * @return the <code>double</code> represented by the bits.
- */
- public static native double longBitsToDouble (long bits);
-
- /**
- * Parse the specified <code>String</code> as a <code>double</code>.
- *
- * The number is really read as <em>n * 10<sup>exponent</sup></em>. The
- * first number is <em>n</em>, and if there is an "<code>E</code>"
- * ("<code>e</code>" is also acceptable), then the integer after that is
- * the exponent.
- * <P>
- * Here are the possible forms the number can take:
- * <BR>
- * <TABLE BORDER=1>
- * <TR><TH>Form</TH><TH>Examples</TH></TR>
- * <TR><TD><CODE>[+-]<number>[.]</CODE></TD><TD>345., -10, 12</TD></TR>
- * <TR><TD><CODE>[+-]<number>.<number></CODE></TD><TD>40.2, 80.00, -12.30</TD></TR>
- * <TR><TD><CODE>[+-]<number>[.]E[+-]<number></CODE></TD><TD>80E12, -12e+7, 4.E-123</TD></TR>
- * <TR><TD><CODE>[+-]<number>.<number>E[+-]<number></CODE></TD><TD>6.02e-22, -40.2E+6, 12.3e9</TD></TR>
- * </TABLE>
- *
- * "<code>[+-]</code>" means either a plus or minus sign may go there, or
- * neither, in which case + is assumed.
- * <BR>
- * "<code>[.]</code>" means a dot may be placed here, but is optional.
- * <BR>
- * "<code><number></code>" means a string of digits (0-9), basically
- * an integer. "<code><number>.<number></code>" is basically
- * a real number, a floating-point value.
- * <P>
- *
- * Remember that a <code>double</code> has a limited range. If the
- * number you specify is greater than <code>Double.MAX_VALUE</code> or less
- * than <code>-Double.MAX_VALUE</code>, it will be set at
- * <code>Double.POSITIVE_INFINITY</code> or
- * <code>Double.NEGATIVE_INFINITY</code>, respectively.
- * <P>
- * Note also that <code>double</code> does not have perfect precision. Many
- * numbers cannot be precisely represented. The number you specify
- * will be rounded to the nearest representable value.
- * <code>Double.MIN_VALUE</code> is the margin of error for
- * <code>double</code> values.
- * <P>
- * If an unexpected character is found in the <code>String</code>, a
- * <code>NumberFormatException</code> will be thrown. Spaces are not
- * allowed, and will cause the same exception.
+ * @return the bits of the <code>double</code>
+ * @see #longBitsToDouble(long)
+ */
+ public static native long doubleToRawLongBits(double value);
+
+ /**
+ * 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 <code>Double.doubleToRawLongBits(double)</code>.
*
- * @XXX specify where/how we are not in accord with the spec.
+ * @param bits the bits to convert
+ * @return the <code>double</code> represented by the bits
+ * @see #doubleToLongBits(double)
+ * @see #doubleToRawLongBits(double)
+ */
+ public static native double longBitsToDouble(long bits);
+
+ /**
+ * Compare two Doubles numerically by comparing their <code>double</code>
+ * 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 <code>POSITIVE_INFINITY</code>, and positive
+ * zero is considered greater than negative zero.
*
- * @param str the <code>String</code> to convert
- * @return the value of the <code>String</code> as a <code>double</code>.
- * @exception NumberFormatException when the string cannot be parsed to a
- * <code>double</code>.
- * @exception NullPointerException when the string is null.
- * @see #MIN_VALUE
- * @see #MAX_VALUE
- * @see #POSITIVE_INFINITY
- * @see #NEGATIVE_INFINITY
+ * @param d the Double to compare
+ * @return the comparison
+ * @since 1.2
+ */
+ public int compareTo(Double d)
+ {
+ return compare(value, d.value);
+ }
+
+ /**
+ * Behaves like <code>compareTo(Double)</code> unless the Object
+ * is not an <code>Double</code>.
+ *
+ * @param o the object to compare
+ * @return the comparison
+ * @throws ClassCastException if the argument is not a <code>Double</code>
+ * @see #compareTo(Double)
+ * @see Comparable
* @since 1.2
*/
- public static native double parseDouble (String s)
- throws NumberFormatException;
+ public int compareTo(Object o)
+ {
+ return compare(value, ((Double) o).value);
+ }
+
+ /**
+ * Behaves like <code>new Double(x).compareTo(new Double(y))</code>; 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);
/**
- * Initialize JNI cache. This method is called only by the
+ * Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
- private static native void initIDs ();
+ private static native void initIDs();
}
-/* java.lang.Float
+/* Float.java -- object wrapper for float
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
import gnu.classpath.Configuration;
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
- * "The Java Language Specification", ISBN 0-201-63451-1
- * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct.
- */
-
/**
* Instances of class <code>Float</code> represent primitive
* <code>float</code> values.
*
* @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com>
- * @since JDK 1.0
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
*/
public final class Float extends Number implements Comparable
{
+ /**
+ * Compatible with JDK 1.0+.
+ */
+ private static final long serialVersionUID = -2671257302660747028L;
+
/**
* The maximum positive value a <code>double</code> may represent
* is 3.4028235e+38f.
/**
* The value of a float representation -1.0/0.0, negative infinity.
*/
- public static final float NEGATIVE_INFINITY = -1.0f/0.0f;
+ public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
/**
* The value of a float representation 1.0/0.0, positive infinity.
*/
- public static final float POSITIVE_INFINITY = 1.0f/0.0f;
+ public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
/**
* All IEEE 754 values of NaN have the same value in Java.
*/
- public static final float NaN = 0.0f/0.0f;
+ public static final float NaN = 0.0f / 0.0f;
/**
- * The primitive type <code>float</code> is represented by this
+ * The primitive type <code>float</code> is represented by this
* <code>Class</code> object.
+ * @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('F');
/**
* The immutable value of this Float.
+ *
+ * @serial the wrapped float
*/
private final float value;
- private static final long serialVersionUID = -2671257302660747028L;
-
+ /**
+ * Load native routines necessary for this class.
+ */
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
- System.loadLibrary ("javalang");
+ System.loadLibrary("javalang");
}
}
/**
- * Create a <code>float</code> from the primitive <code>Float</code>
+ * Create a <code>Float</code> from the primitive <code>float</code>
* specified.
*
- * @param value the <code>Float</code> argument
+ * @param value the <code>float</code> argument
*/
- public Float (float value)
+ public Float(float value)
{
this.value = value;
}
*
* @param value the <code>double</code> argument
*/
- public Float (double value)
+ public Float(double value)
{
- this.value = (float)value;
+ this.value = (float) value;
}
/**
* Create a <code>Float</code> from the specified <code>String</code>.
- *
* This method calls <code>Float.parseFloat()</code>.
*
- * @exception NumberFormatException when the <code>String</code> cannot
- * be parsed into a <code>Float</code>.
* @param s the <code>String</code> to convert
- * @see #parseFloat(java.lang.String)
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>float</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @see #parseFloat(String)
+ */
+ public Float(String s)
+ {
+ value = parseFloat(s);
+ }
+
+ /**
+ * Convert the <code>float</code> to a <code>String</code>.
+ * Floating-point string representation is fairly complex: here is a
+ * rundown of the possible values. "<code>[-]</code>" indicates that a
+ * negative sign will be printed if the value (or exponent) is negative.
+ * "<code><number></code>" means a string of digits ('0' to '9').
+ * "<code><digit></code>" means a single digit ('0' to '9').<br>
+ *
+ * <table border=1>
+ * <tr><th>Value of Float</th><th>String Representation</th></tr>
+ * <tr><td>[+-] 0</td> <td><code>[-]0.0</code></td></tr>
+ * <tr><td>Between [+-] 10<sup>-3</sup> and 10<sup>7</sup>, exclusive</td>
+ * <td><code>[-]number.number</code></td></tr>
+ * <tr><td>Other numeric value</td>
+ * <td><code>[-]<digit>.<number>
+ * E[-]<number></code></td></tr>
+ * <tr><td>[+-] infinity</td> <td><code>[-]Infinity</code></td></tr>
+ * <tr><td>NaN</td> <td><code>NaN</code></td></tr>
+ * </table>
+ *
+ * Yes, negative zero <em>is</em> a possible value. Note that there is
+ * <em>always</em> a <code>.</code> and at least one digit printed after
+ * it: even if the number is 3, it will be printed as <code>3.0</code>.
+ * 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 float.
+ *
+ * <p>To create other output formats, use {@link java.text.NumberFormat}.
+ *
+ * @XXX specify where we are not in accord with the spec.
+ *
+ * @param f the <code>float</code> to convert
+ * @return the <code>String</code> representing the <code>float</code>
+ */
+ public static String toString(float f)
+ {
+ return Double.toString(f, true);
+ }
+
+ /**
+ * Creates a new <code>Float</code> object using the <code>String</code>.
+ *
+ * @param s the <code>String</code> to convert
+ * @return the new <code>Float</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>float</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @see #parseFloat(String)
*/
- public Float (String s) throws NumberFormatException
+ public static Float valueOf(String s)
{
- this.value = parseFloat (s);
+ return new Float(parseFloat(s));
}
/**
- * Parse the specified <code>String</code> as a <code>float</code>.
- *
- * The number is really read as <em>n * 10<sup>exponent</sup></em>. The
- * first number is <em>n</em>, and if there is an "<code>E</code>"
- * ("<code>e</code>" is also acceptable), then the integer after that is
- * the exponent.
- * <P>
- * Here are the possible forms the number can take:
- * <BR>
- * <TABLE BORDER=1>
- * <TR><TH>Form</TH><TH>Examples</TH></TR>
- * <TR><TD><CODE>[+-]<number>[.]</CODE></TD><TD>345., -10, 12</TD></TR>
- * <TR><TD><CODE>[+-]<number>.<number></CODE></TD><TD>40.2, 80.00, -12.30</TD></TR>
- * <TR><TD><CODE>[+-]<number>[.]E[+-]<number></CODE></TD><TD>80E12, -12e+7, 4.E-123</TD></TR>
- * <TR><TD><CODE>[+-]<number>.<number>E[+-]<number></CODE></TD><TD>6.02e-22, -40.2E+6, 12.3e9</TD></TR>
- * </TABLE>
- *
- * "<code>[+-]</code>" means either a plus or minus sign may go there, or
- * neither, in which case + is assumed.
- * <BR>
- * "<code>[.]</code>" means a dot may be placed here, but is optional.
- * <BR>
- * "<code><number></code>" means a string of digits (0-9), basically
- * an integer. "<code><number>.<number></code>" is basically
- * a real number, a floating-point value.
- * <P>
- * Remember that a <code>float</code> has a limited range. If the
- * number you specify is greater than <code>Float.MAX_VALUE</code> or less
- * than <code>-Float.MAX_VALUE</code>, it will be set at
- * <code>Float.POSITIVE_INFINITY</code> or
- * <code>Float.NEGATIVE_INFINITY</code>, respectively.
- * <P>
- *
- * Note also that <code>float</code> does not have perfect precision. Many
- * numbers cannot be precisely represented. The number you specify
- * will be rounded to the nearest representable value.
- * <code>Float.MIN_VALUE</code> is the margin of error for <code>float</code>
- * values.
- * <P>
- * If an unexpected character is found in the <code>String</code>, a
- * <code>NumberFormatException</code> will be thrown. Spaces are not
- * allowed and will cause this exception to be thrown.
+ * Parse the specified <code>String</code> as a <code>float</code>. The
+ * extended BNF grammar is as follows:<br>
+ * <pre>
+ * <em>DecodableString</em>:
+ * ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
+ * | ( [ <code>-</code> | <code>+</code> ] <code>Infinity</code> )
+ * | ( [ <code>-</code> | <code>+</code> ] <em>FloatingPoint</em>
+ * [ <code>f</code> | <code>F</code> | <code>d</code>
+ * | <code>D</code>] )
+ * <em>FloatingPoint</em>:
+ * ( { <em>Digit</em> }+ [ <code>.</code> { <em>Digit</em> } ]
+ * [ <em>Exponent</em> ] )
+ * | ( <code>.</code> { <em>Digit</em> }+ [ <em>Exponent</em> ] )
+ * <em>Exponent</em>:
+ * ( ( <code>e</code> | <code>E</code> )
+ * [ <code>-</code> | <code>+</code> ] { <em>Digit</em> }+ )
+ * <em>Digit</em>: <em><code>'0'</code> through <code>'9'</code></em>
+ * </pre>
+ *
+ * <p>NaN and infinity are special cases, to allow parsing of the output
+ * of toString. Otherwise, the result is determined by calculating
+ * <em>n * 10<sup>exponent</sup></em> to infinite precision, then rounding
+ * to the nearest float. 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.
+ *
+ * <p>If an unexpected character is found in the <code>String</code>, a
+ * <code>NumberFormatException</code> will be thrown. Leading and trailing
+ * 'whitespace' is ignored via <code>String.trim()</code>, but spaces
+ * internal to the actual number are not allowed.
+ *
+ * <p>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 <code>String</code> to convert
- * @return the value of the <code>String</code> as a <code>float</code>.
- * @exception NumberFormatException when the string cannot be parsed to a
- * <code>float</code>.
- * @since JDK 1.2
+ * @return the <code>float</code> value of <code>s</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>float</code>
+ * @throws NullPointerException if <code>s</code> is null
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
+ * @since 1.2
*/
- public static float parseFloat (String s) throws NumberFormatException
+ public static float parseFloat(String s)
{
- // The spec says that parseFloat() should work like
- // Double.valueOf(). This is equivalent, in our implementation,
- // but more efficient.
- return (float) Double.parseDouble (s);
+ // XXX Rounding parseDouble() causes some errors greater than 1 ulp from
+ // the infinitely precise decimal.
+ return (float) Double.parseDouble(s);
}
/**
- * Convert the <code>float</code> value of this <code>Float</code>
- * to a <code>String</code>. This method calls
- * <code>Float.toString(float)</code> to do its dirty work.
+ * Return <code>true</code> if the <code>float</code> has the same
+ * value as <code>NaN</code>, otherwise return <code>false</code>.
*
- * @return the <code>String</code> representation of this <code>Float</code>.
- * @see #toString(float)
+ * @param v the <code>float</code> to compare
+ * @return whether the argument is <code>NaN</code>
*/
- public String toString ()
+ public static boolean isNaN(float v)
{
- return toString (value);
+ // This works since NaN != NaN is the only reflexive inequality
+ // comparison which returns true.
+ return v != v;
}
/**
- * If the <code>Object</code> is not <code>null</code>, is an
- * <code>instanceof</code> <code>Float</code>, and represents
- * the same primitive <code>float</code> value return
- * <code>true</code>. Otherwise <code>false</code> is returned.
- * <p>
- * Note that there are two differences between <code>==</code> and
- * <code>equals()</code>. <code>0.0f == -0.0f</code> returns <code>true</code>
- * but <code>new Float(0.0f).equals(new Float(-0.0f))</code> returns
- * <code>false</code>. And <code>Float.NaN == Float.NaN</code> returns
- * <code>false</code>, but
- * <code>new Float(Float.NaN).equals(new Float(Float.NaN))</code> returns
- * <code>true</code>.
+ * Return <code>true</code> if the <code>float</code> has a value
+ * equal to either <code>NEGATIVE_INFINITY</code> or
+ * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
- * @param obj the object to compare to
- * @return whether the objects are semantically equal.
+ * @param v the <code>float</code> to compare
+ * @return whether the argument is (-/+) infinity
*/
- public boolean equals (Object obj)
+ public static boolean isInfinite(float v)
{
- if (!(obj instanceof Float))
- return false;
-
- float f = ((Float) obj).value;
-
- // GCJ LOCAL: this implementation is probably faster than
- // Classpath's, especially once we inline floatToIntBits.
- return floatToIntBits (value) == floatToIntBits (f);
- // END GCJ LOCAL
+ return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
}
/**
- * Return a hashcode representing this Object.
- * <code>Float</code>'s hash code is calculated by calling the
- * <code>floatToIntBits()</code> function.
- * @return this Object's hash code.
- * @see java.lang.Float.floatToIntBits(float)
+ * Return <code>true</code> if the value of this <code>Float</code>
+ * is the same as <code>NaN</code>, otherwise return <code>false</code>.
+ *
+ * @return whether this <code>Float</code> is <code>NaN</code>
*/
- public int hashCode ()
+ public boolean isNaN()
{
- return floatToIntBits (value);
+ return isNaN(value);
}
/**
- * Return the value of this <code>Double</code> when cast to an
- * <code>int</code>.
+ * Return <code>true</code> if the value of this <code>Float</code>
+ * is the same as <code>NEGATIVE_INFINITY</code> or
+ * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ *
+ * @return whether this <code>Float</code> is (-/+) infinity
*/
- public int intValue ()
+ public boolean isInfinite()
{
- return (int) value;
+ return isInfinite(value);
}
/**
- * Return the value of this <code>Double</code> when cast to a
- * <code>long</code>.
+ * Convert the <code>float</code> value of this <code>Float</code>
+ * to a <code>String</code>. This method calls
+ * <code>Float.toString(float)</code> to do its dirty work.
+ *
+ * @return the <code>String</code> representation
+ * @see #toString(float)
*/
- public long longValue ()
+ public String toString()
{
- return (long) value;
+ return toString(value);
}
/**
- * Return the value of this <code>Double</code> when cast to a
- * <code>float</code>.
+ * Return the value of this <code>Float</code> as a <code>byte</code>.
+ *
+ * @return the byte value
+ * @since 1.1
*/
- public float floatValue ()
+ public byte byteValue()
{
- return (float) value;
+ return (byte) value;
}
/**
- * Return the primitive <code>double</code> value represented by this
- * <code>Double</code>.
+ * Return the value of this <code>Float</code> as a <code>short</code>.
+ *
+ * @return the short value
+ * @since 1.1
*/
- public double doubleValue ()
+ public short shortValue()
{
- return (double) value;
+ return (short) value;
}
/**
- * Convert the <code>float</code> to a <code>String</code>.
- * <P>
+ * Return the value of this <code>Integer</code> as an <code>int</code>.
*
- * Floating-point string representation is fairly complex: here is a
- * rundown of the possible values. "<CODE>[-]</CODE>" indicates that a
- * negative sign will be printed if the value (or exponent) is negative.
- * "<CODE><number></CODE>" means a string of digits (0-9).
- * "<CODE><digit></CODE>" means a single digit (0-9).
- * <P>
- *
- * <TABLE BORDER=1>
- * <TR><TH>Value of Float</TH><TH>String Representation</TH></TR>
- * <TR>
- * <TD>[+-] 0</TD>
- * <TD>[<CODE>-</CODE>]<CODE>0.0</CODE></TD>
- * </TR>
- * <TR>
- * <TD>Between [+-] 10<SUP>-3</SUP> and 10<SUP>7</SUP></TD>
- * <TD><CODE>[-]number.number</CODE></TD>
- * </TR>
- * <TR>
- * <TD>Other numeric value</TD>
- * <TD><CODE>[-]<digit>.<number>E[-]<number></CODE></TD>
- * </TR>
- * <TR>
- * <TD>[+-] infinity</TD>
- * <TD><CODE>[-]Infinity</CODE></TD>
- * </TR>
- * <TR>
- * <TD>NaN</TD>
- * <TD><CODE>NaN</CODE></TD>
- * </TR>
- * </TABLE>
- *
- * Yes, negative zero <EM>is</EM> a possible value. Note that there is
- * <EM>always</EM> a <CODE>.</CODE> and at least one digit printed after
- * it: even if the number is 3, it will be printed as <CODE>3.0</CODE>.
- * After the ".", all digits will be printed except trailing zeros. No
- * truncation or rounding is done by this function.
- *
- * @XXX specify where we are not in accord with the spec.
- *
- * @param f the <code>float</code> to convert
- * @return the <code>String</code> representing the <code>float</code>.
+ * @return the int value
*/
- public static String toString (float f)
+ public int intValue()
{
- return Double.toString ((double) f, true);
+ return (int) value;
}
/**
- * Return the result of calling <code>new Float(java.lang.String)</code>.
- *
- * @param s the <code>String</code> to convert to a <code>Float</code>.
- * @return a new <code>Float</code> representing the <code>String</code>'s
- * numeric value.
+ * Return the value of this <code>Integer</code> as a <code>long</code>.
*
- * @exception NumberFormatException thrown if <code>String</code> cannot
- * be parsed as a <code>double</code>.
- * @see #Float(java.lang.String)
- * @see #parseFloat(java.lang.String)
+ * @return the long value
*/
- public static Float valueOf (String s) throws NumberFormatException
+ public long longValue()
{
- return new Float (s);
+ return (long) value;
}
/**
- * Return <code>true</code> if the value of this <code>Float</code>
- * is the same as <code>NaN</code>, otherwise return <code>false</code>.
- * @return whether this <code>Float</code> is <code>NaN</code>.
+ * Return the value of this <code>Float</code>.
+ *
+ * @return the float value
*/
- public boolean isNaN ()
+ public float floatValue()
{
- return isNaN (value);
+ return value;
}
/**
- * Return <code>true</code> if the <code>float</code> has the same
- * value as <code>NaN</code>, otherwise return <code>false</code>.
+ * Return the value of this <code>Float</code> as a <code>double</code>
*
- * @param v the <code>float</code> to compare
- * @return whether the argument is <code>NaN</code>.
+ * @return the double value
*/
- public static boolean isNaN (float v)
+ public double doubleValue()
{
- // This works since NaN != NaN is the only reflexive inequality
- // comparison which returns true.
- return v != v;
+ return value;
}
/**
- * Return <code>true</code> if the value of this <code>Float</code>
- * is the same as <code>NEGATIVE_INFINITY</code> or
- * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ * Return a hashcode representing this Object. <code>Float</code>'s hash
+ * code is calculated by calling <code>floatToIntBits(floatValue())</code>.
*
- * @return whether this <code>Float</code> is (-/+) infinity.
+ * @return this Object's hash code
+ * @see #floatToIntBits(float)
*/
- public boolean isInfinite ()
+ public int hashCode()
{
- return isInfinite (value);
+ return floatToIntBits(value);
}
/**
- * Return <code>true</code> if the <code>float</code> has a value
- * equal to either <code>NEGATIVE_INFINITY</code> or
- * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
+ * Returns <code>true</code> if <code>obj</code> is an instance of
+ * <code>Float</code> and represents the same float value. Unlike comparing
+ * two floats with <code>==</code>, this treats two instances of
+ * <code>Float.NaN</code> as equal, but treats <code>0.0</code> and
+ * <code>-0.0</code> as unequal.
*
- * @param v the <code>float</code> to compare
- * @return whether the argument is (-/+) infinity.
+ * <p>Note that <code>f1.equals(f2)<code> is identical to
+ * <code>floatToIntBits(f1.floatValue()) ==
+ * floatToIntBits(f2.floatValue())<code>.
+ *
+ * @param obj the object to compare
+ * @return whether the objects are semantically equal
*/
- public static boolean isInfinite (float v)
+ public boolean equals(Object obj)
{
- return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY);
+ if (! (obj instanceof Float))
+ return false;
+
+ float f = ((Float) 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 == f)
+ return (value != 0) || (1 / value == 1 / f);
+ return isNaN(value) && isNaN(f);
}
/**
- * Return the int bits of the specified <code>float</code>.
- * The result of this function can be used as the argument to
- * <code>Float.intBitsToFloat(long)</code> to obtain the
+ * Convert the float to the IEEE 754 floating-point "single format" bit
+ * layout. Bit 31 (the most significant) is the sign bit, bits 30-23
+ * (masked by 0x7f800000) represent the exponent, and bits 22-0
+ * (masked by 0x007fffff) are the mantissa. This function collapses all
+ * versions of NaN to 0x7fc00000. The result of this function can be used
+ * as the argument to <code>Float.intBitsToFloat(int)</code> to obtain the
* original <code>float</code> value.
*
* @param value the <code>float</code> to convert
- * @return the bits of the <code>float</code>.
+ * @return the bits of the <code>float</code>
+ * @see #intBitsToFloat(int)
*/
- public static native int floatToIntBits (float value);
+ public static native int floatToIntBits(float value);
/**
- * Return the int bits of the specified <code>float</code>.
- * The result of this function can be used as the argument to
- * <code>Float.intBitsToFloat(long)</code> to obtain the
- * original <code>float</code> value. The difference between
- * this function and <code>floatToIntBits</code> is that this
- * function does not collapse NaN values.
+ * Convert the float to the IEEE 754 floating-point "single format" bit
+ * layout. Bit 31 (the most significant) is the sign bit, bits 30-23
+ * (masked by 0x7f800000) represent the exponent, and bits 22-0
+ * (masked by 0x007fffff) 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 <code>Float.intBitsToFloat(int)</code> to
+ * obtain the original <code>float</code> value.
*
* @param value the <code>float</code> to convert
- * @return the bits of the <code>float</code>.
+ * @return the bits of the <code>float</code>
+ * @see #intBitsToFloat(int)
*/
- public static native int floatToRawIntBits (float value);
+ public static native int floatToRawIntBits(float value);
/**
- * Return the <code>float</code> represented by the long
- * bits specified.
+ * Convert the argument in IEEE 754 floating-point "single format" bit
+ * layout to the corresponding float. Bit 31 (the most significant) is the
+ * sign bit, bits 30-23 (masked by 0x7f800000) represent the exponent, and
+ * bits 22-0 (masked by 0x007fffff) are the mantissa. This function leaves
+ * NaN alone, so that you can recover the bit pattern with
+ * <code>Float.floatToRawIntBits(float)</code>.
*
- * @param bits the long bits representing a <code>double</code>
- * @return the <code>float</code> represented by the bits.
+ * @param bits the bits to convert
+ * @return the <code>float</code> represented by the bits
+ * @see #floatToIntBits(float)
+ * @see #floatToRawIntBits(float)
*/
- public static native float intBitsToFloat (int bits);
+ public static native float intBitsToFloat(int bits);
/**
- * Returns 0 if the <code>float</code> value of the argument is
- * equal to the value of this <code>Float</code>. Returns a number
- * less than zero if the value of this <code>Float</code> is less
- * than the <code>Float</code> value of the argument, and returns a
- * number greater than zero if the value of this <code>Float</code>
- * is greater than the <code>float</code> value of the argument.
- * <br>
- * <code>Float.NaN</code> is greater than any number other than itself,
- * even <code>Float.POSITIVE_INFINITY</code>.
- * <br>
- * <code>0.0</code> is greater than <code>-0.0</code>.
+ * Compare two Floats numerically by comparing their <code>float</code>
+ * 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 floats, including <code>POSITIVE_INFINITY</code>, and positive
+ * zero is considered greater than negative zero.
*
- * @param f the Float to compare to.
- * @return 0 if the <code>Float</code>s are the same, < 0 if this
- * <code>Float</code> is less than the <code>Float</code> in
- * in question, or > 0 if it is greater.
+ * @param f the Float to compare
+ * @return the comparison
+ * @since 1.2
+ */
+ public int compareTo(Float f)
+ {
+ return compare(value, f.value);
+ }
+
+ /**
+ * Behaves like <code>compareTo(Float)</code> unless the Object
+ * is not an <code>Float</code>.
*
+ * @param o the object to compare
+ * @return the comparison
+ * @throws ClassCastException if the argument is not a <code>Float</code>
+ * @see #compareTo(Float)
+ * @see Comparable
* @since 1.2
*/
- public int compareTo (Float f)
+ public int compareTo(Object o)
{
- return compare (value, f.value);
+ return compare(value, ((Float) o).value);
}
/**
- * Returns 0 if the first argument is equal to the second argument.
- * Returns a number less than zero if the first argument is less than the
- * second argument, and returns a number greater than zero if the first
- * argument is greater than the second argument.
- * <br>
- * <code>Float.NaN</code> is greater than any number other than itself,
- * even <code>Float.POSITIVE_INFINITY</code>.
- * <br>
- * <code>0.0</code> is greater than <code>-0.0</code>.
- *
- * @param x the first float to compare.
- * @param y the second float to compare.
- * @return 0 if the arguments are the same, < 0 if the
- * first argument is less than the second argument in
- * in question, or > 0 if it is greater.
+ * Behaves like <code>new Float(x).compareTo(new Float(y))</code>; in
+ * other words this compares two floats, special casing NaN and zero,
+ * without the overhead of objects.
+ *
+ * @param x the first float to compare
+ * @param y the second float to compare
+ * @return the comparison
* @since 1.4
*/
- public static int compare (float x, float y)
+ public static int compare(float x, float y)
{
- if (isNaN (x))
- return isNaN (y) ? 0 : 1;
- if (isNaN (y))
+ if (isNaN(x))
+ return isNaN(y) ? 0 : 1;
+ if (isNaN(y))
return -1;
// recall that 0.0 == -0.0, so we convert to infinities and try again
if (x == 0 && y == 0)
return x > y ? 1 : -1;
}
-
- /**
- * Compares the specified <code>Object</code> to this <code>Float</code>
- * if and only if the <code>Object</code> is an instanceof
- * <code>Float</code>.
- * Otherwise it throws a <code>ClassCastException</code>
- *
- * @param o the Object to compare to.
- * @return 0 if the <code>Float</code>s are the same, < 0 if this
- * <code>Float</code> is less than the <code>Float</code> in
- * in question, or > 0 if it is greater.
- * @throws ClassCastException if the argument is not a <code>Float</code>
- *
- * @since 1.2
- */
- public int compareTo (Object o)
- {
- return compareTo ((Float) o);
- }
}
-/* java.lang.Integer
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+/* Integer.java -- object wrapper for int
+ Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
- * @since JDK 1.0
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
*/
public final class Integer extends Number implements Comparable
{
- // compatible with JDK 1.0.2+
+ /**
+ * Compatible with JDK 1.0.2+.
+ */
private static final long serialVersionUID = 1360826667806852920L;
/**
- * The minimum value an <code>int</code> can represent is -2147483648.
+ * The minimum value an <code>int</code> can represent is -2147483648 (or
+ * -2<sup>31</sup>).
*/
public static final int MIN_VALUE = 0x80000000;
/**
- * The maximum value an <code>int</code> can represent is 2147483647.
+ * The maximum value an <code>int</code> can represent is 2147483647 (or
+ * 2<sup>31</sup> - 1).
*/
public static final int MAX_VALUE = 0x7fffffff;
/**
- * The primitive type <code>int</code> is represented by this
+ * The primitive type <code>int</code> is represented by this
* <code>Class</code> object.
+ * @since 1.1
*/
- public static final Class TYPE = VMClassLoader.getPrimitiveClass ('I');
+ public static final Class TYPE = VMClassLoader.getPrimitiveClass('I');
/**
* The immutable value of this Integer.
+ *
+ * @serial the wrapped int
*/
private final int value;
/**
- * Create an <code>Integer</code> object representing the value of the
+ * Create an <code>Integer</code> object representing the value of the
* <code>int</code> argument.
*
* @param value the value to use
}
/**
- * Create an <code>Integer</code> object representing the value of the
+ * Create an <code>Integer</code> object representing the value of the
* argument after conversion to an <code>int</code>.
*
- * @param s the string to convert.
+ * @param s the string to convert
+ * @throws NumberFormatException if the String does not contain an int
+ * @see #valueOf(String)
*/
- public Integer(String s) throws NumberFormatException
+ public Integer(String s)
{
- value = parseInt(s, 10);
+ value = parseInt(s, 10, false);
}
/**
- * Return a hashcode representing this Object.
- *
- * <code>Integer</code>'s hash code is calculated by simply returning its
- * value.
- *
- * @return this Object's hash code.
- */
- public int hashCode()
- {
- return value;
- }
-
- /**
- * If the <code>Object</code> is not <code>null</code>, is an
- * <code>instanceof</code> <code>Integer</code>, and represents
- * the same primitive <code>int</code> value return
- * <code>true</code>. Otherwise <code>false</code> is returned.
- */
- public boolean equals(Object obj)
- {
- return obj instanceof Integer && value == ((Integer)obj).value;
- }
-
- /**
- * Get the specified system property as an <code>Integer</code>.
- *
- * The <code>decode()</code> method will be used to interpret the value of
- * the property.
- * @param nm the name of the system property
- * @return the system property as an <code>Integer</code>, or
- * <code>null</code> if the property is not found or cannot be
- * decoded as an <code>Integer</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see #decode(int)
- */
- public static Integer getInteger(String nm)
- {
- return getInteger(nm, null);
- }
-
- /**
- * Get the specified system property as an <code>Integer</code>, or use a
- * default <code>int</code> value if the property is not found or is not
- * decodable.
- *
- * The <code>decode()</code> method will be used to interpret the value of
- * the property.
+ * Converts the <code>int</code> to a <code>String</code> using
+ * the specified radix (base). If the radix exceeds
+ * <code>Character.MIN_RADIX</code> or <code>Character.MAX_RADIX</code>, 10
+ * is used instead. If the result is negative, the leading character is
+ * '-' ('\\u002D'). The remaining characters come from
+ * <code>Character.forDigit(digit, radix)</code> ('0'-'9','a'-'z').
*
- * @param nm the name of the system property
- * @param val the default value to use if the property is not found or not
- * a number.
- * @return the system property as an <code>Integer</code>, or the default
- * value if the property is not found or cannot be decoded as an
- * <code>Integer</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see #decode(int)
- * @see #getInteger(java.lang.String,java.lang.Integer)
+ * @param num the <code>int</code> to convert to <code>String</code>
+ * @param radix the radix (base) to use in the conversion
+ * @return the <code>String</code> representation of the argument
*/
- public static Integer getInteger(String nm, int val)
+ public static String toString(int num, int radix)
{
- Integer result = getInteger(nm, null);
- return (result == null) ? new Integer(val) : result;
- }
+ if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
+ radix = 10;
- /**
- * Get the specified system property as an <code>Integer</code>, or use a
- * default <code>Integer</code> value if the property is not found or is
- * not decodable.
- *
- * The <code>decode()</code> method will be used to interpret the value of
- * the property.
- *
- * @param nm the name of the system property
- * @param val the default value to use if the property is not found or not
- * a number.
- * @return the system property as an <code>Integer</code>, or the default
- * value if the property is not found or cannot be decoded as an
- * <code>Integer</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see #decode(int)
- * @see #getInteger(java.lang.String,int)
- */
- public static Integer getInteger(String nm, Integer def)
- {
- String val = System.getProperty(nm);
- if (val == null) return def;
- try
- {
- return decode(val);
- }
- catch (NumberFormatException e)
+ // For negative numbers, print out the absolute value w/ a leading '-'.
+ // Use an array large enough for a binary number.
+ char[] buffer = new char[33];
+ int i = 33;
+ boolean isNeg = false;
+ if (num < 0)
{
- return def;
+ isNeg = true;
+ num = -num;
+
+ // When the value is MIN_VALUE, it overflows when made positive
+ if (num < 0)
+ {
+ buffer[--i] = digits[(int) (-(num + radix) % radix)];
+ num = -(num / radix);
+ }
}
- }
- private static String toUnsignedString(int num, int exp)
- {
- // Use an array large enough for a binary number.
- int radix = 1 << exp;
- int mask = radix - 1;
- char[] buffer = new char[32];
- int i = 32;
do
{
- buffer[--i] = Character.forDigit(num & mask, radix);
- num = num >>> exp;
+ buffer[--i] = digits[num % radix];
+ num /= radix;
}
- while (num != 0);
+ while (num > 0);
- return String.valueOf(buffer, i, 32-i);
+ if (isNeg)
+ buffer[--i] = '-';
+
+ // Package constructor avoids an array copy.
+ return new String(buffer, i, 33 - i, true);
}
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 16.
+ *
* @param i the <code>int</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * @return the <code>String</code> representation of the argument
*/
public static String toHexString(int i)
{
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 8.
+ *
* @param i the <code>int</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * @return the <code>String</code> representation of the argument
*/
public static String toOctalString(int i)
{
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 2.
+ *
* @param i the <code>int</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * @return the <code>String</code> representation of the argument
*/
public static String toBinaryString(int i)
{
/**
* Converts the <code>int</code> to a <code>String</code> and assumes
* a radix of 10.
+ *
* @param i the <code>int</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * @return the <code>String</code> representation of the argument
+ * @see #toString(int, int)
*/
public static String toString(int i)
{
// This is tricky: in libgcj, String.valueOf(int) is a fast native
// implementation. In Classpath it just calls back to
- // Integer.toString(int,int).
- return String.valueOf (i);
+ // Integer.toString(int, int).
+ return String.valueOf(i);
}
/**
- * Converts the <code>Integer</code> value to a <code>String</code> and
- * assumes a radix of 10.
- * @return the <code>String</code> representation of this <code>Integer</code>.
- */
- public String toString()
- {
- return toString (value);
- }
-
- /**
- * Converts the <code>int</code> to a <code>String</code> using
- * the specified radix (base).
- * @param i the <code>int</code> to convert to <code>String</code>.
- * @param radix the radix (base) to use in the conversion.
- * @return the <code>String</code> representation of the argument.
+ * Converts the specified <code>String</code> into an <code>int</code>
+ * using the specified radix (base). The string must not be <code>null</code>
+ * or empty. It may begin with an optional '-', which will negate the answer,
+ * provided that there are also valid digits. Each digit is parsed as if by
+ * <code>Character.digit(d, radix)</code>, and must be in the range
+ * <code>0</code> to <code>radix - 1</code>. Finally, the result must be
+ * within <code>MIN_VALUE</code> to <code>MAX_VALUE</code>, inclusive.
+ * Unlike Double.parseDouble, you may not have a leading '+'.
+ *
+ * @param s the <code>String</code> to convert
+ * @param radix the radix (base) to use in the conversion
+ * @return the <code>String</code> argument converted to </code>int</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as an
+ * <code>int</code>
*/
- public static String toString(int num, int radix)
+ public static int parseInt(String str, int radix)
{
- if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
- radix = 10;
-
- // For negative numbers, print out the absolute value w/ a leading '-'.
- // Use an array large enough for a binary number.
- char[] buffer = new char[33];
- int i = 33;
- boolean isNeg;
- if (num < 0)
- {
- isNeg = true;
- num = -(num);
-
- // When the value is MIN_VALUE, it overflows when made positive
- if (num < 0)
- {
- buffer[--i] = Character.forDigit(-(num + radix) % radix, radix);
- num = -(num / radix);
- }
- }
- else
- isNeg = false;
-
- do
- {
- buffer[--i] = Character.forDigit(num % radix, radix);
- num /= radix;
- }
- while (num > 0);
-
- if (isNeg)
- buffer[--i] = '-';
-
- return String.valueOf(buffer, i, 33-i);
+ return parseInt(str, radix, false);
}
/**
- * Creates a new <code>Integer</code> object using the <code>String</code>,
- * assuming a radix of 10.
- * @param s the <code>String</code> to convert.
- * @return the new <code>Integer</code>.
- * @see #Integer(java.lang.String)
- * @see #parseInt(java.lang.String)
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as an <code>int</code>.
- */
- public static Integer valueOf(String s) throws NumberFormatException
+ * Converts the specified <code>String</code> into an <code>int</code>.
+ * This function assumes a radix of 10.
+ *
+ * @param s the <code>String</code> to convert
+ * @return the <code>int</code> value of <code>s</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as an
+ * <code>int</code>
+ * @see #parseInt(String, int)
+ */
+ public static int parseInt(String s)
{
- return new Integer(parseInt(s));
+ return parseInt(s, 10, false);
}
/**
* Creates a new <code>Integer</code> object using the <code>String</code>
* and specified radix (base).
- * @param s the <code>String</code> to convert.
- * @param radix the radix (base) to convert with.
- * @return the new <code>Integer</code>.
- * @see #parseInt(java.lang.String,int)
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as an <code>int</code>.
+ *
+ * @param s the <code>String</code> to convert
+ * @param radix the radix (base) to convert with
+ * @return the new <code>Integer</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as an
+ * <code>int</code>
+ * @see #parseInt(String, int)
*/
public static Integer valueOf(String s, int radix)
- throws NumberFormatException
{
- return new Integer(parseInt(s, radix));
+ return new Integer(parseInt(s, radix, false));
}
/**
- * Converts the specified <code>String</code> into an <code>int</code>.
- * This function assumes a radix of 10.
+ * Creates a new <code>Integer</code> object using the <code>String</code>,
+ * assuming a radix of 10.
*
* @param s the <code>String</code> to convert
- * @return the <code>int</code> value of the <code>String</code>
- * argument.
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as an <code>int</code>.
+ * @return the new <code>Integer</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as an
+ * <code>int</code>
+ * @see #Integer(String)
+ * @see #parseInt(String)
*/
- public static int parseInt(String s) throws NumberFormatException
+ public static Integer valueOf(String s)
{
- return parseInt(s, 10);
+ return new Integer(parseInt(s, 10, false));
}
/**
- * Converts the specified <code>String</code> into an <code>int</code>
- * using the specified radix (base).
+ * Return the value of this <code>Integer</code> as a <code>byte</code>.
*
- * @param s the <code>String</code> to convert
- * @param radix the radix (base) to use in the conversion
- * @return the <code>String</code> argument converted to </code>int</code>.
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as a <code>int</code>.
+ * @return the byte value
*/
- public static int parseInt(String str, int radix)
- throws NumberFormatException
+ public byte byteValue()
{
- final int len;
-
- if (str == null)
- throw new NumberFormatException ();
-
- if ((len = str.length()) == 0 ||
- radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
- throw new NumberFormatException();
-
- boolean isNeg = false;
- int index = 0;
- if (str.charAt(index) == '-')
- if (len > 1)
- {
- isNeg = true;
- index++;
- }
- else
- throw new NumberFormatException();
-
- return parseInt(str, index, len, isNeg, radix);
+ return (byte) value;
}
- private static int parseInt(String str, int index, int len, boolean isNeg,
- int radix)
- throws NumberFormatException
+ /**
+ * Return the value of this <code>Integer</code> as a <code>short</code>.
+ *
+ * @return the short value
+ */
+ public short shortValue()
{
- int val = 0;
- int digval;
-
- int max = MAX_VALUE / radix;
- // We can't directly write `max = (MAX_VALUE + 1) / radix'.
- // So instead we fake it.
- if (isNeg && MAX_VALUE % radix == radix - 1)
- ++max;
-
- for ( ; index < len; index++)
- {
- if (val < 0 || val > max)
- throw new NumberFormatException();
-
- if ((digval = Character.digit(str.charAt(index), radix)) < 0)
- throw new NumberFormatException();
-
- // Throw an exception for overflow if result is negative.
- // However, we special-case the most negative value.
- val = val * radix + digval;
- if (val < 0 && (! isNeg || val != MIN_VALUE))
- throw new NumberFormatException();
- }
+ return (short) value;
+ }
- return isNeg ? -(val) : val;
+ /**
+ * Return the value of this <code>Integer</code>.
+ * @return the int value
+ */
+ public int intValue()
+ {
+ return value;
}
/**
- * Convert the specified <code>String</code> into an <code>Integer</code>.
- * The <code>String</code> may represent decimal, hexadecimal, or
- * octal numbers.
- *
- * The <code>String</code> argument is interpreted based on the leading
- * characters. Depending on what the String begins with, the base will be
- * interpreted differently:
+ * Return the value of this <code>Integer</code> as a <code>long</code>.
*
- * <table border=1>
- * <tr><th>Leading<br>Characters</th><th>Base</th></tr>
- * <tr><td>#</td><td>16</td></tr>
- * <tr><td>0x</td><td>16</td></tr>
- * <tr><td>0X</td><td>16</td></tr>
- * <tr><td>0</td><td>8</td></tr>
- * <tr><td>Anything<br>Else</td><td>10</td></tr>
- * </table>
- *
- * @param str the <code>String</code> to interpret.
- * @return the value of the String as an <code>Integer</code>.
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as an <code>int</code>.
+ * @return the long value
*/
- public static Integer decode(String str) throws NumberFormatException
+ public long longValue()
{
- boolean isNeg = false;
- int index = 0;
- int radix = 10;
- final int len;
-
- if (str == null || (len = str.length()) == 0)
- throw new NumberFormatException("string null or empty");
-
- // Negative numbers are always radix 10.
- if (str.charAt(index) == '-')
- {
- radix = 10;
- index++;
- isNeg = true;
- }
- else if (str.charAt(index) == '#')
- {
- radix = 16;
- index++;
- }
- else if (str.charAt(index) == '0')
- {
- // Check if str is just "0"
- if (len == 1)
- return new Integer(0);
+ return value;
+ }
- index++;
- if (str.charAt(index) == 'x' || str.charAt(index) == 'X')
- {
- radix = 16;
- index++;
- }
- else
- radix = 8;
- }
+ /**
+ * Return the value of this <code>Integer</code> as a <code>float</code>.
+ *
+ * @return the float value
+ */
+ public float floatValue()
+ {
+ return value;
+ }
- if (index >= len)
- throw new NumberFormatException("empty value");
+ /**
+ * Return the value of this <code>Integer</code> as a <code>double</code>.
+ *
+ * @return the double value
+ */
+ public double doubleValue()
+ {
+ return value;
+ }
- return new Integer(parseInt(str, index, len, isNeg, radix));
+ /**
+ * Converts the <code>Integer</code> value to a <code>String</code> and
+ * assumes a radix of 10.
+ *
+ * @return the <code>String</code> representation
+ */
+ public String toString()
+ {
+ return String.valueOf(value);
}
- /** Return the value of this <code>Integer</code> as a <code>byte</code>.
- ** @return the value of this <code>Integer</code> as a <code>byte</code>.
- **/
- public byte byteValue()
+ /**
+ * Return a hashcode representing this Object. <code>Integer</code>'s hash
+ * code is simply its value.
+ *
+ * @return this Object's hash code
+ */
+ public int hashCode()
{
- return (byte) value;
+ return value;
}
- /** Return the value of this <code>Integer</code> as a <code>short</code>.
- ** @return the value of this <code>Integer</code> as a <code>short</code>.
- **/
- public short shortValue()
+ /**
+ * Returns <code>true</code> if <code>obj</code> is an instance of
+ * <code>Integer</code> and represents the same int value.
+ *
+ * @param obj the object to compare
+ * @return whether these Objects are semantically equal
+ */
+ public boolean equals(Object obj)
{
- return (short) value;
+ return obj instanceof Integer && value == ((Integer) obj).value;
}
- /** Return the value of this <code>Integer</code> as an <code>int</code>.
- ** @return the value of this <code>Integer</code> as an <code>int</code>.
- **/
- public int intValue()
+ /**
+ * Get the specified system property as an <code>Integer</code>. The
+ * <code>decode()</code> method will be used to interpret the value of
+ * the property.
+ *
+ * @param nm the name of the system property
+ * @return the system property as an <code>Integer</code>, or null if the
+ * property is not found or cannot be decoded
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Integer getInteger(String nm)
{
- return value;
+ return getInteger(nm, null);
}
- /** Return the value of this <code>Integer</code> as a <code>long</code>.
- ** @return the value of this <code>Integer</code> as a <code>long</code>.
- **/
- public long longValue()
+ /**
+ * Get the specified system property as an <code>Integer</code>, or use a
+ * default <code>int</code> value if the property is not found or is not
+ * decodable. The <code>decode()</code> method will be used to interpret
+ * the value of the property.
+ *
+ * @param nm the name of the system property
+ * @param val the default value
+ * @return the value of the system property, or the default
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Integer getInteger(String nm, int val)
{
- return value;
+ Integer result = getInteger(nm, null);
+ return result == null ? new Integer(val) : result;
}
- /** Return the value of this <code>Integer</code> as a <code>float</code>.
- ** @return the value of this <code>Integer</code> as a <code>float</code>.
- **/
- public float floatValue()
+ /**
+ * Get the specified system property as an <code>Integer</code>, or use a
+ * default <code>Integer</code> value if the property is not found or is
+ * not decodable. The <code>decode()</code> method will be used to
+ * interpret the value of the property.
+ *
+ * @param nm the name of the system property
+ * @param val the default value
+ * @return the value of the system property, or the default
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Integer getInteger(String nm, Integer def)
{
- return value;
+ if (nm == null || "".equals(nm))
+ return def;
+ nm = System.getProperty(nm);
+ if (nm == null)
+ return def;
+ try
+ {
+ return decode(nm);
+ }
+ catch (NumberFormatException e)
+ {
+ return def;
+ }
}
- /** Return the value of this <code>Integer</code> as a <code>double</code>.
- ** @return the value of this <code>Integer</code> as a <code>double</code>.
- **/
- public double doubleValue()
+ /**
+ * Convert the specified <code>String</code> into an <code>Integer</code>.
+ * The <code>String</code> may represent decimal, hexadecimal, or
+ * octal numbers.
+ *
+ * <p>The extended BNF grammar is as follows:<br>
+ * <pre>
+ * <em>DecodableString</em>:
+ * ( [ <code>-</code> ] <em>DecimalNumber</em> )
+ * | ( [ <code>-</code> ] ( <code>0x</code> | <code>0X</code>
+ * | <code>#</code> ) <em>HexDigit</em> { <em>HexDigit</em> } )
+ * | ( [ <code>-</code> ] <code>0</code> { <em>OctalDigit</em> } )
+ * <em>DecimalNumber</em>:
+ * <em>DecimalDigit except '0'</em> { <em>DecimalDigit</em> }
+ * <em>DecimalDigit</em>:
+ * <em>Character.digit(d, 10) has value 0 to 9</em>
+ * <em>OctalDigit</em>:
+ * <em>Character.digit(d, 8) has value 0 to 7</em>
+ * <em>DecimalDigit</em>:
+ * <em>Character.digit(d, 16) has value 0 to 15</em>
+ * </pre>
+ * Finally, the value must be in the range <code>MIN_VALUE</code> to
+ * <code>MAX_VALUE</code>, or an exception is thrown.
+ *
+ * @param s the <code>String</code> to interpret
+ * @return the value of the String as an <code>Integer</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>int</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @since 1.2
+ */
+ public static Integer decode(String str)
{
- return value;
+ return new Integer(parseInt(str, 10, true));
}
/**
- * Compare two Integers numerically by comparing their
- * <code>int</code> values.
- * @return a positive value if this <code>Integer</code> is greater
- * in value than the argument <code>Integer</code>; a negative value
- * if this <code>Integer</code> is smaller in value than the argument
- * <code>Integer</code>; and <code>0</code>, zero, if this
- * <code>Integer</code> is equal in value to the argument
- * <code>Integer</code>.
+ * Compare two Integers numerically by comparing their <code>int</code>
+ * values. The result is positive if the first is greater, negative if the
+ * second is greater, and 0 if the two are equal.
*
+ * @param i the Integer to compare
+ * @return the comparison
* @since 1.2
*/
public int compareTo(Integer i)
{
- if (this.value == i.value)
+ if (value == i.value)
return 0;
-
// Returns just -1 or 1 on inequality; doing math might overflow.
- if (this.value > i.value)
- return 1;
-
- return -1;
+ return value > i.value ? 1 : -1;
}
/**
- * Behaves like <code>compareTo(java.lang.Integer)</code> unless the Object
- * is not a <code>Integer</code>. Then it throws a
- * <code>ClassCastException</code>.
- * @exception ClassCastException if the argument is not a
- * <code>Integer</code>.
+ * Behaves like <code>compareTo(Integer)</code> unless the Object
+ * is not an <code>Integer</code>.
*
+ * @param o the object to compare
+ * @return the comparison
+ * @throws ClassCastException if the argument is not an <code>Integer</code>
+ * @see #compareTo(Integer)
+ * @see Comparable
* @since 1.2
*/
public int compareTo(Object o)
{
- return compareTo((Integer)o);
+ return compareTo((Integer) o);
+ }
+
+ /**
+ * Helper for converting unsigned numbers to String.
+ *
+ * @param num the number
+ * @param exp log2(digit) (ie. 1, 3, or 4 for binary, oct, hex)
+ */
+ // Package visible for use by Long.
+ static String toUnsignedString(int num, int exp)
+ {
+ // Use an array large enough for a binary number.
+ int mask = (1 << exp) - 1;
+ char[] buffer = new char[32];
+ int i = 32;
+ do
+ {
+ buffer[--i] = digits[num & mask];
+ num >>>= exp;
+ }
+ while (num != 0);
+
+ // Package constructor avoids an array copy.
+ return new String(buffer, i, 32 - i, true);
+ }
+
+ /**
+ * Helper for parsing ints, used by Integer, Short, and Byte.
+ *
+ * @param str the string to parse
+ * @param radix the radix to use, must be 10 if decode is true
+ * @param decode if called from decode
+ * @return the parsed int value
+ * @throws NumberFormatException if there is an error
+ * @throws NullPointerException if decode is true and str if null
+ * @see #parseInt(String, int)
+ * @see #decode(String)
+ * @see Byte#parseInt(String, int)
+ * @see Short#parseInt(String, int)
+ */
+ static int parseInt(String str, int radix, boolean decode)
+ {
+ if (! decode && str == null)
+ throw new NumberFormatException();
+ int index = 0;
+ int len = str.length();
+ boolean isNeg = false;
+ if (len == 0)
+ throw new NumberFormatException();
+ int ch = str.charAt(index);
+ if (ch == '-')
+ {
+ if (len == 1)
+ throw new NumberFormatException();
+ isNeg = true;
+ ch = str.charAt(++index);
+ }
+ if (decode)
+ {
+ if (ch == '0')
+ {
+ if (++index == len)
+ return 0;
+ if ((str.charAt(index) & ~('x' ^ 'X')) == 'X')
+ {
+ radix = 16;
+ index++;
+ }
+ else
+ radix = 8;
+ }
+ else if (ch == '#')
+ {
+ radix = 16;
+ index++;
+ }
+ }
+ if (index == len)
+ throw new NumberFormatException();
+
+ int max = MAX_VALUE / radix;
+ // We can't directly write `max = (MAX_VALUE + 1) / radix'.
+ // So instead we fake it.
+ if (isNeg && MAX_VALUE % radix == radix - 1)
+ ++max;
+
+ int val = 0;
+ while (index < len)
+ {
+ if (val < 0 || val > max)
+ throw new NumberFormatException();
+
+ ch = Character.digit(str.charAt(index++), radix);
+ val = val * radix + ch;
+ if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))
+ throw new NumberFormatException();
+ }
+ return isNeg ? -val : val;
}
}
-/* java.lang.Long
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+/* Long.java -- object wrapper for long
+ Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
package java.lang;
/**
- * Instances of class <code>Double</code> represent primitive
- * <code>double</code> values.
+ * Instances of class <code>Long</code> represent primitive
+ * <code>long</code> values.
*
* Additionally, this class provides various helper functions and variables
* related to longs.
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
- * @since JDK 1.0
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
*/
public final class Long extends Number implements Comparable
{
- // compatible with JDK 1.0.2+
- static final long serialVersionUID = 4290774380558885855L;
+ /**
+ * Compatible with JDK 1.0.2+.
+ */
+ private static final long serialVersionUID = 4290774380558885855L;
/**
* The minimum value a <code>long</code> can represent is
- * -9223372036854775808.
+ * -9223372036854775808L (or -2<sup>63</sup>).
*/
public static final long MIN_VALUE = 0x8000000000000000L;
/**
* The maximum value a <code>long</code> can represent is
- * 9223372036854775807.
+ * 9223372036854775807 (or 2<sup>63</sup> - 1).
*/
public static final long MAX_VALUE = 0x7fffffffffffffffL;
/**
- * The primitive type <code>long</code> is represented by this
+ * The primitive type <code>long</code> is represented by this
* <code>Class</code> object.
+ * @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass ('J');
/**
* The immutable value of this Long.
+ *
+ * @serial the wrapped long
*/
private final long value;
/**
- * Create a <code>Long</code> object representing the value of the
+ * Create a <code>Long</code> object representing the value of the
* <code>long</code> argument.
*
* @param value the value to use
}
/**
- * Create a <code>Long</code> object representing the value of the
+ * Create a <code>Long</code> object representing the value of the
* argument after conversion to a <code>long</code>.
*
- * @param s the string to convert.
+ * @param s the string to convert
+ * @throws NumberFormatException if the String does not contain a long
+ * @see #valueOf(String)
*/
- public Long(String s) throws NumberFormatException
+ public Long(String s)
{
- value = parseLong(s, 10);
+ value = parseLong(s, 10, false);
}
/**
- * If the <code>Object</code> is not <code>null</code>, is an
- * <code>instanceof</code> <code>Long</code>, and represents
- * the same primitive <code>long</code> value return
- * <code>true</code>. Otherwise <code>false</code> is returned.
+ * Converts the <code>long</code> to a <code>String</code> using
+ * the specified radix (base). If the radix exceeds
+ * <code>Character.MIN_RADIX</code> or <code>Character.MAX_RADIX</code>, 10
+ * is used instead. If the result is negative, the leading character is
+ * '-' ('\\u002D'). The remaining characters come from
+ * <code>Character.forDigit(digit, radix)</code> ('0'-'9','a'-'z').
+ *
+ * @param num the <code>long</code> to convert to <code>String</code>
+ * @param radix the radix (base) to use in the conversion
+ * @return the <code>String</code> representation of the argument
*/
- public boolean equals(Object obj)
+ public static String toString(long num, int radix)
{
- return obj instanceof Long && ((Long)obj).value == value;
+ // Use the Integer toString for efficiency if possible.
+ if ((int) num == num)
+ return Integer.toString((int) num, radix);
+
+ if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
+ radix = 10;
+
+ // For negative numbers, print out the absolute value w/ a leading '-'.
+ // Use an array large enough for a binary number.
+ char[] buffer = new char[65];
+ int i = 65;
+ boolean isNeg = false;
+ if (num < 0)
+ {
+ isNeg = true;
+ num = -num;
+
+ // When the value is MIN_VALUE, it overflows when made positive
+ if (num < 0)
+ {
+ buffer[--i] = digits[(int) (-(num + radix) % radix)];
+ num = -(num / radix);
+ }
+ }
+
+ do
+ {
+ buffer[--i] = digits[(int) (num % radix)];
+ num /= radix;
+ }
+ while (num > 0);
+
+ if (isNeg)
+ buffer[--i] = '-';
+
+ // Package constructor avoids an array copy.
+ return new String(buffer, i, 65 - i, true);
}
/**
- * Return a hashcode representing this Object.
+ * Converts the <code>long</code> to a <code>String</code> assuming it is
+ * unsigned in base 16.
*
- * <code>Long</code>'s hash code is calculated by simply returning its
- * value.
+ * @param l the <code>long</code> to convert to <code>String</code>
+ * @return the <code>String</code> representation of the argument
+ */
+ public static String toHexString(long l)
+ {
+ return toUnsignedString(l, 4);
+ }
+
+ /**
+ * Converts the <code>long</code> to a <code>String</code> assuming it is
+ * unsigned in base 8.
*
- * @return this Object's hash code.
+ * @param l the <code>long</code> to convert to <code>String</code>
+ * @return the <code>String</code> representation of the argument
*/
- public int hashCode()
+ public static String toOctalString(long l)
{
- return (int)(value^(value>>>32));
+ return toUnsignedString(l, 3);
}
/**
- * Get the specified system property as a <code>Long</code>.
+ * Converts the <code>long</code> to a <code>String</code> assuming it is
+ * unsigned in base 2.
*
- * A method similar to <code>Integer</code>'s <code>decode()</code> will be
- * used to interpret the value of the property.
- *
- * @param nm the name of the system property
- * @return the system property as an <code>Long</code>, or
- * <code>null</code> if the property is not found or cannot be
- * decoded as a <code>Long</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see java.lang.Integer#decode(int)
+ * @param l the <code>long</code> to convert to <code>String</code>
+ * @return the <code>String</code> representation of the argument
*/
- public static Long getLong(String nm)
+ public static String toBinaryString(long l)
{
- return getLong(nm, null);
+ return toUnsignedString(l, 1);
}
/**
- * Get the specified system property as an <code>Long</code>, or use a
- * default <code>long</code> value if the property is not found or is not
- * decodable.
- *
- * A method similar to <code>Integer</code>'s <code>decode()</code> will be
- * used to interpret the value of the property.
- *
- * @param nm the name of the system property
- * @param val the default value to use if the property is not found or not
- * a number.
- * @return the system property as a <code>Long</code>, or the default
- * value if the property is not found or cannot be decoded as a
- * <code>Long</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see java.lang.Integer#decode(int)
- * @see #getLong(java.lang.String,java.lang.Long)
+ * Converts the <code>long</code> to a <code>String</code> and assumes
+ * a radix of 10.
+ *
+ * @param num the <code>long</code> to convert to <code>String</code>
+ * @return the <code>String</code> representation of the argument
+ * @see #toString(long, int)
*/
- public static Long getLong(String nm, long val)
+ public static String toString(long num)
{
- Long result = getLong(nm, null);
- return (result == null) ? new Long(val) : result;
+ return toString(num, 10);
}
/**
- * Get the specified system property as an <code>Long</code>, or use a
- * default <code>Long</code> value if the property is not found or is
- * not decodable.
- *
- * The <code>decode()</code> method will be used to interpret the value of
- * the property.
+ * Converts the specified <code>String</code> into an <code>int</code>
+ * using the specified radix (base). The string must not be <code>null</code>
+ * or empty. It may begin with an optional '-', which will negate the answer,
+ * provided that there are also valid digits. Each digit is parsed as if by
+ * <code>Character.digit(d, radix)</code>, and must be in the range
+ * <code>0</code> to <code>radix - 1</code>. Finally, the result must be
+ * within <code>MIN_VALUE</code> to <code>MAX_VALUE</code>, inclusive.
+ * Unlike Double.parseDouble, you may not have a leading '+'; and 'l' or
+ * 'L' as the last character is only valid in radices 22 or greater, where
+ * it is a digit and not a type indicator.
*
- * @param nm the name of the system property
- * @param val the default value to use if the property is not found or not
- * a number.
- * @return the system property as an <code>Long</code>, or the default
- * value if the property is not found or cannot be decoded as an
- * <code>Long</code>.
- * @see java.lang.System#getProperty(java.lang.String)
- * @see java.lang.Integer#decode(int)
- * @see #getLong(java.lang.String,long)
+ * @param s the <code>String</code> to convert
+ * @param radix the radix (base) to use in the conversion
+ * @return the <code>String</code> argument converted to </code>long</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>long</code>
*/
- public static Long getLong(String nm, Long def)
+ public static long parseLong(String str, int radix)
{
- String val = System.getProperty(nm);
- if (val == null)
- return def;
- try
- {
- return decode(nm);
- }
- catch (NumberFormatException e)
- {
- return def;
- }
+ return parseLong(str, radix, false);
}
- private static String toUnsignedString(long num, int exp)
+ /**
+ * Converts the specified <code>String</code> into a <code>long</code>.
+ * This function assumes a radix of 10.
+ *
+ * @param s the <code>String</code> to convert
+ * @return the <code>int</code> value of <code>s</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>long</code>
+ * @see #parseLong(String, int)
+ */
+ public static long parseLong(String s)
{
- // Use an array large enough for a binary number.
- int radix = 1 << exp;
- int mask = radix - 1;
- char[] buffer = new char[64];
- int i = 64;
- do
- {
- buffer[--i] = Character.forDigit((int) num & mask, radix);
- num = num >>> exp;
- }
- while (num != 0);
+ return parseLong(s, 10, false);
+ }
- return String.valueOf(buffer, i, 64-i);
+ /**
+ * Creates a new <code>Long</code> object using the <code>String</code>
+ * and specified radix (base).
+ *
+ * @param s the <code>String</code> to convert
+ * @param radix the radix (base) to convert with
+ * @return the new <code>Long</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>long</code>
+ * @see #parseLong(String, int)
+ */
+ public static Long valueOf(String s, int radix)
+ {
+ return new Long(parseLong(s, radix, false));
}
/**
- * Converts the <code>long</code> to a <code>String</code> assuming it is
- * unsigned in base 16.
- * @param i the <code>long</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * Creates a new <code>Long</code> object using the <code>String</code>,
+ * assuming a radix of 10.
+ *
+ * @param s the <code>String</code> to convert
+ * @return the new <code>Long</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>long</code>
+ * @see #Long(String)
+ * @see #parseLong(String)
*/
- public static String toHexString(long i)
+ public static Long valueOf(String s)
{
- return toUnsignedString(i, 4);
+ return new Long(parseLong(s, 10, false));
}
/**
- * Converts the <code>long</code> to a <code>String</code> assuming it is
- * unsigned in base 8.
- * @param i the <code>long</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * Convert the specified <code>String</code> into a <code>Long</code>.
+ * The <code>String</code> may represent decimal, hexadecimal, or
+ * octal numbers.
+ *
+ * <p>The extended BNF grammar is as follows:<br>
+ * <pre>
+ * <em>DecodableString</em>:
+ * ( [ <code>-</code> ] <em>DecimalNumber</em> )
+ * | ( [ <code>-</code> ] ( <code>0x</code> | <code>0X</code>
+ * | <code>#</code> ) <em>HexDigit</em> { <em>HexDigit</em> } )
+ * | ( [ <code>-</code> ] <code>0</code> { <em>OctalDigit</em> } )
+ * <em>DecimalNumber</em>:
+ * <em>DecimalDigit except '0'</em> { <em>DecimalDigit</em> }
+ * <em>DecimalDigit</em>:
+ * <em>Character.digit(d, 10) has value 0 to 9</em>
+ * <em>OctalDigit</em>:
+ * <em>Character.digit(d, 8) has value 0 to 7</em>
+ * <em>DecimalDigit</em>:
+ * <em>Character.digit(d, 16) has value 0 to 15</em>
+ * </pre>
+ * Finally, the value must be in the range <code>MIN_VALUE</code> to
+ * <code>MAX_VALUE</code>, or an exception is thrown. Note that you cannot
+ * use a trailing 'l' or 'L', unlike in Java source code.
+ *
+ * @param s the <code>String</code> to interpret
+ * @return the value of the String as a <code>Long</code>
+ * @throws NumberFormatException if <code>s</code> cannot be parsed as a
+ * <code>long</code>
+ * @throws NullPointerException if <code>s</code> is null
+ * @since 1.2
*/
- public static String toOctalString(long i)
+ public static Long decode(String str)
{
- return toUnsignedString(i, 3);
+ return new Long(parseLong(str, 10, true));
}
/**
- * Converts the <code>long</code> to a <code>String</code> assuming it is
- * unsigned in base 2.
- * @param i the <code>long</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
+ * Return the value of this <code>Long</code> as a <code>byte</code>.
+ *
+ * @return the byte value
*/
- public static String toBinaryString(long i) {
- return toUnsignedString(i, 1);
+ public byte byteValue()
+ {
+ return (byte) value;
}
/**
- * Converts the <code>long</code> to a <code>String</code> and assumes
- * a radix of 10.
- * @param num the <code>long</code> to convert to <code>String</code>
- * @return the <code>String</code> representation of the argument.
- */
- public static String toString(long num)
+ * Return the value of this <code>Long</code> as a <code>short</code>.
+ *
+ * @return the short value
+ */
+ public short shortValue()
{
- // Use the Integer toString for efficiency if possible.
- if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE)
- return Integer.toString((int) num);
+ return (short) value;
+ }
- // Use an array large enough for "-9223372036854775808"; i.e. 20 chars.
- char[] buffer = new char[20];
- int i = 20;
- boolean isNeg;
- if (num < 0)
- {
- isNeg = true;
- num = -(num);
- if (num < 0)
- {
- // Must be MIN_VALUE, so handle this special case.
- buffer[--i] = '8';
- num = 922337203685477580L;
- }
- }
- else
- isNeg = false;
+ /**
+ * Return the value of this <code>Long</code> as an <code>int</code>.
+ *
+ * @return the int value
+ */
+ public int intValue()
+ {
+ return (int) value;
+ }
- do
- {
- buffer[--i] = (char) ((int) '0' + (num % 10));
- num /= 10;
- }
- while (num > 0);
+ /**
+ * Return the value of this <code>Long</code>.
+ *
+ * @return the long value
+ */
+ public long longValue()
+ {
+ return value;
+ }
- if (isNeg)
- buffer[--i] = '-';
+ /**
+ * Return the value of this <code>Long</code> as a <code>float</code>.
+ *
+ * @return the float value
+ */
+ public float floatValue()
+ {
+ return value;
+ }
- return String.valueOf(buffer, i, 20-i);
+ /**
+ * Return the value of this <code>Long</code> as a <code>double</code>.
+ *
+ * @return the double value
+ */
+ public double doubleValue()
+ {
+ return value;
}
/**
* Converts the <code>Long</code> value to a <code>String</code> and
* assumes a radix of 10.
- * @return the <code>String</code> representation of this <code>Long</code>.
- */
+ *
+ * @return the <code>String</code> representation
+ */
public String toString()
{
- return toString(value);
+ return toString(value, 10);
}
-
+
/**
- * Converts the <code>long</code> to a <code>String</code> using
- * the specified radix (base).
- * @param num the <code>long</code> to convert to <code>String</code>.
- * @param radix the radix (base) to use in the conversion.
- * @return the <code>String</code> representation of the argument.
+ * Return a hashcode representing this Object. <code>Long</code>'s hash
+ * code is calculated by <code>(int) (value ^ (value >> 32))</code>.
+ *
+ * @return this Object's hash code
*/
- public static String toString(long num, int radix)
+ public int hashCode()
{
- // Use optimized method for the typical case.
- if (radix == 10 ||
- radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
- return toString(num);
-
- // Use the Integer toString for efficiency if possible.
- if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE)
- return Integer.toString((int) num, radix);
-
- // For negative numbers, print out the absolute value w/ a leading '-'.
- // Use an array large enough for a binary number.
- char[] buffer = new char[65];
- int i = 65;
- boolean isNeg;
- if (num < 0)
- {
- isNeg = true;
- num = -(num);
-
- // When the value is MIN_VALUE, it overflows when made positive
- if (num < 0)
- {
- buffer[--i] = Character.forDigit((int) (-(num + radix) % radix),
- radix);
- num = -(num / radix);
- }
- }
- else
- isNeg = false;
+ return (int) (value ^ (value >>> 32));
+ }
- do
- {
- buffer[--i] = Character.forDigit((int) (num % radix), radix);
- num /= radix;
- }
- while (num > 0);
+ /**
+ * Returns <code>true</code> if <code>obj</code> is an instance of
+ * <code>Long</code> and represents the same long value.
+ *
+ * @param obj the object to compare
+ * @return whether these Objects are semantically equal
+ */
+ public boolean equals(Object obj)
+ {
+ return obj instanceof Long && value == ((Long) obj).value;
+ }
- if (isNeg)
- buffer[--i] = '-';
+ /**
+ * Get the specified system property as a <code>Long</code>. The
+ * <code>decode()</code> method will be used to interpret the value of
+ * the property.
+ *
+ * @param nm the name of the system property
+ * @return the system property as a <code>Long</code>, or null if the
+ * property is not found or cannot be decoded
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Long getLong(String nm)
+ {
+ return getLong(nm, null);
+ }
- return String.valueOf(buffer, i, 65-i);
+ /**
+ * Get the specified system property as a <code>Long</code>, or use a
+ * default <code>long</code> value if the property is not found or is not
+ * decodable. The <code>decode()</code> method will be used to interpret
+ * the value of the property.
+ *
+ * @param nm the name of the system property
+ * @param val the default value
+ * @return the value of the system property, or the default
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Long getLong(String nm, long val)
+ {
+ Long result = getLong(nm, null);
+ return result == null ? new Long(val) : result;
}
-
+
/**
- * Creates a new <code>Long</code> object using the <code>String</code>,
- * assuming a radix of 10.
- * @param s the <code>String</code> to convert.
- * @return the new <code>Long</code>.
- * @see #Long(java.lang.String)
- * @see #parseLong(java.lang.String)
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as a <code>long</code>.
- */
- public static Long valueOf(String s) throws NumberFormatException
+ * Get the specified system property as a <code>Long</code>, or use a
+ * default <code>Long</code> value if the property is not found or is
+ * not decodable. The <code>decode()</code> method will be used to
+ * interpret the value of the property.
+ *
+ * @param nm the name of the system property
+ * @param val the default value
+ * @return the value of the system property, or the default
+ * @throws SecurityException if accessing the system property is forbidden
+ * @see System#getProperty(String)
+ * @see #decode(String)
+ */
+ public static Long getLong(String nm, Long def)
{
- return new Long(parseLong(s));
+ if (nm == null || "".equals(nm))
+ return def;
+ nm = System.getProperty(nm);
+ if (nm == null)
+ return def;
+ try
+ {
+ return decode(nm);
+ }
+ catch (NumberFormatException e)
+ {
+ return def;
+ }
}
/**
- * Creates a new <code>Long</code> object using the <code>String</code>
- * and specified radix (base).
- * @param s the <code>String</code> to convert.
- * @param radix the radix (base) to convert with.
- * @return the new <code>Long</code>.
- * @see #parseLong(java.lang.String,int)
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as a <code>long</code>.
- */
- public static Long valueOf(String s, int radix) throws NumberFormatException
+ * Compare two Longs numerically by comparing their <code>long</code>
+ * values. The result is positive if the first is greater, negative if the
+ * second is greater, and 0 if the two are equal.
+ *
+ * @param l the Long to compare
+ * @return the comparison
+ * @since 1.2
+ */
+ public int compareTo(Long l)
{
- return new Long(parseLong(s, radix));
+ if (value == l.value)
+ return 0;
+ // Returns just -1 or 1 on inequality; doing math might overflow the long.
+ return value > l.value ? 1 : -1;
}
/**
- * Converts the specified <code>String</code> into a <code>long</code>.
- * This function assumes a radix of 10.
+ * Behaves like <code>compareTo(Long)</code> unless the Object
+ * is not a <code>Long</code>.
*
- * @param s the <code>String</code> to convert
- * @return the <code>long</code> value of the <code>String</code>
- * argument.
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as a <code>long</code>.
+ * @param o the object to compare
+ * @return the comparison
+ * @throws ClassCastException if the argument is not a <code>Long</code>
+ * @see #compareTo(Long)
+ * @see Comparable
+ * @since 1.2
*/
- public static long parseLong(String s) throws NumberFormatException
+ public int compareTo(Object o)
{
- return parseLong(s, 10);
+ return compareTo((Long) o);
}
/**
- * Converts the specified <code>String</code> into a <code>long</code>
- * using the specified radix (base).
+ * Helper for converting unsigned numbers to String.
*
- * @param s the <code>String</code> to convert
- * @param radix the radix (base) to use in the conversion
- * @return the <code>String</code> argument converted to </code>long</code>.
- * @exception NumberFormatException thrown if the <code>String</code>
- * cannot be parsed as a <code>long</code>.
+ * @param num the number
+ * @param exp log2(digit) (ie. 1, 3, or 4 for binary, oct, hex)
*/
- public static long parseLong(String str, int radix)
- throws NumberFormatException
+ private static String toUnsignedString(long num, int exp)
{
- final int len;
+ // Use the Integer toUnsignedString for efficiency if possible.
+ // If NUM<0 then this particular optimization doesn't work
+ // properly.
+ if (num >= 0 && (int) num == num)
+ return Integer.toUnsignedString((int) num, exp);
- if ((len = str.length()) == 0 || radix < Character.MIN_RADIX
- || radix > Character.MAX_RADIX)
- throw new NumberFormatException();
+ // Use an array large enough for a binary number.
+ int mask = (1 << exp) - 1;
+ char[] buffer = new char[64];
+ int i = 64;
+ do
+ {
+ buffer[--i] = digits[(int) num & mask];
+ num >>>= exp;
+ }
+ while (num != 0);
- boolean isNeg = false;
- int index = 0;
- if (str.charAt(index) == '-')
- if (len > 1)
- {
- isNeg = true;
- index++;
- }
- else
- throw new NumberFormatException();
-
- return parseLong(str, index, len, isNeg, radix);
+ // Package constructor avoids an array copy.
+ return new String(buffer, i, 64 - i, true);
}
- public static Long decode(String str) throws NumberFormatException
+ /**
+ * Helper for parsing longs.
+ *
+ * @param str the string to parse
+ * @param radix the radix to use, must be 10 if decode is true
+ * @param decode if called from decode
+ * @return the parsed long value
+ * @throws NumberFormatException if there is an error
+ * @throws NullPointerException if decode is true and str is null
+ * @see #parseLong(String, int)
+ * @see #decode(String)
+ */
+ private static long parseLong(String str, int radix, boolean decode)
{
- boolean isNeg = false;
+ if (! decode && str == null)
+ throw new NumberFormatException();
int index = 0;
- int radix = 10;
- final int len;
-
- if ((len = str.length()) == 0)
+ int len = str.length();
+ boolean isNeg = false;
+ if (len == 0)
throw new NumberFormatException();
-
- // Negative numbers are always radix 10.
- if (str.charAt(0) == '-')
+ int ch = str.charAt(index);
+ if (ch == '-')
{
- radix = 10;
- index++;
+ if (len == 1)
+ throw new NumberFormatException();
isNeg = true;
+ ch = str.charAt(++index);
}
- else if (str.charAt(index) == '#')
- {
- radix = 16;
- index++;
- }
- else if (str.charAt(index) == '0')
+ if (decode)
{
- // Check if str is just "0"
- if (len == 1)
- return new Long(0L);
-
- index++;
- if (str.charAt(index) == 'x')
+ if (ch == '0')
+ {
+ if (++index == len)
+ return 0;
+ if ((str.charAt(index) & ~('x' ^ 'X')) == 'X')
+ {
+ radix = 16;
+ index++;
+ }
+ else
+ radix = 8;
+ }
+ else if (ch == '#')
{
radix = 16;
index++;
}
- else
- radix = 8;
}
-
- if (index >= len)
+ if (index == len)
throw new NumberFormatException();
- return new Long(parseLong(str, index, len, isNeg, radix));
- }
-
- private static long parseLong(String str, int index, int len, boolean isNeg,
- int radix) throws NumberFormatException
- {
- long val = 0;
- int digval;
-
long max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
- for ( ; index < len; index++)
+ long val = 0;
+ while (index < len)
{
if (val < 0 || val > max)
throw new NumberFormatException();
- if ((digval = Character.digit(str.charAt(index), radix)) < 0)
+ ch = Character.digit(str.charAt(index++), radix);
+ val = val * radix + ch;
+ if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))
throw new NumberFormatException();
-
- // Throw an exception for overflow if result is negative.
- // However, we special-case the most negative value.
- val = val * radix + digval;
- if (val < 0 && (! isNeg || val != MIN_VALUE))
- throw new NumberFormatException();
}
-
- return isNeg ? -(val) : val;
- }
-
- /** Return the value of this <code>Long</code> as an <code>short</code>.
- ** @return the value of this <code>Long</code> as an <code>short</code>.
- **/
- public byte byteValue()
- {
- return (byte) value;
- }
-
- /** Return the value of this <code>Long</code> as an <code>short</code>.
- ** @return the value of this <code>Long</code> as an <code>short</code>.
- **/
- public short shortValue()
- {
- return (short) value;
- }
-
- /** Return the value of this <code>Long</code> as an <code>int</code>.
- ** @return the value of this <code>Long</code> as an <code>int</code>.
- **/
- public int intValue()
- {
- return (int) value;
- }
-
- /** Return the value of this <code>Long</code> as a <code>long</code>.
- ** @return the value of this <code>Long</code> as a <code>long</code>.
- **/
- public long longValue()
- {
- return value;
- }
-
- /** Return the value of this <code>Long</code> as a <code>float</code>.
- ** @return the value of this <code>Long</code> as a <code>float</code>.
- **/
- public float floatValue()
- {
- return value;
- }
-
- /** Return the value of this <code>Long</code> as a <code>double</code>.
- ** @return the value of this <code>Long</code> as a <code>double</code>.
- **/
- public double doubleValue()
- {
- return value;
- }
-
- /**
- * Compare two Longs numerically by comparing their
- * <code>long</code> values.
- * @return a positive value if this <code>Long</code> is greater
- * in value than the argument <code>Long</code>; a negative value
- * if this <code>Long</code> is smaller in value than the argument
- * <code>Long</code>; and <code>0</code>, zero, if this
- * <code>Long</code> is equal in value to the argument
- * <code>Long</code>.
- *
- * @since 1.2
- */
- public int compareTo(Long l)
- {
- if (this.value == l.value)
- return 0;
-
- // Returns just -1 or 1 on inequality; doing math might overflow the long.
- if (this.value > l.value)
- return 1;
-
- return -1;
- }
-
- /**
- * Behaves like <code>compareTo(java.lang.Long)</code> unless the Object
- * is not a <code>Long</code>. Then it throws a
- * <code>ClassCastException</code>.
- * @exception ClassCastException if the argument is not a
- * <code>Long</code>.
- *
- * @since 1.2
- */
- public int compareTo(Object o)
- {
- return compareTo((Long)o);
+ return isNeg ? -val : val;
}
}
-/* java.lang.Number
- Copyright (C) 1998, 2001 Free Software Foundation, Inc.
+/* Number.java =- abstract superclass of numeric objects
+ Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
import java.io.Serializable;
/**
- ** Number is a generic superclass of all the numeric classes, namely
- ** <code>Byte</code>, <code>Short</code>, <code>Integer</code>,
- ** <code>Long</code>, <code>Float</code>, and <code>Double</code>.
- **
- ** It provides ways to convert from any one value to any other.
- **
- ** @author Paul Fisher
- ** @author John Keiser
- ** @author Warren Levy
- ** @since JDK1.0
- **/
+ * Number is a generic superclass of all the numeric classes, including
+ * the wrapper classes {@link Byte}, {@link Short}, {@link Integer},
+ * {@link Long}, {@link Float}, and {@link Double}. Also worth mentioning
+ * are the classes in {@link java.math}.
+ *
+ * It provides ways to convert numeric objects to any primitive.
+ *
+ * @author Paul Fisher
+ * @author John Keiser
+ * @author Warren Levy
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.0
+ * @status updated to 1.4
+ */
public abstract class Number implements Serializable
{
- /** Return the value of this <code>Number</code> as a <code>byte</code>.
- ** @return the value of this <code>Number</code> as a <code>byte</code>.
- **/
- public byte byteValue()
- {
- return (byte) intValue();
- }
+ /**
+ * Compatible with JDK 1.1+.
+ */
+ private static final long serialVersionUID = -8742448824652078965L;
- /** Return the value of this <code>Number</code> as a <code>short</code>.
- ** @return the value of this <code>Number</code> as a <code>short</code>.
- **/
- public short shortValue()
+ /**
+ * Table for calculating digits, used in Character, Long, and Integer.
+ */
+ static final char[] digits = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+ 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+ 'u', 'v', 'w', 'x', 'y', 'z'
+ };
+
+ /**
+ * The basic constructor (often called implicitly).
+ */
+ public Number()
{
- return (short) intValue();
}
- /** Return the value of this <code>Number</code> as an <code>int</code>.
- ** @return the value of this <code>Number</code> as an <code>int</code>.
- **/
+ /**
+ * Return the value of this <code>Number</code> as an <code>int</code>.
+ *
+ * @return the int value
+ */
public abstract int intValue();
- /** Return the value of this <code>Number</code> as a <code>long</code>.
- ** @return the value of this <code>Number</code> as a <code>long</code>.
- **/
+ /**
+ * Return the value of this <code>Number</code> as a <code>long</code>.
+ *
+ * @return the long value
+ */
public abstract long longValue();
- /** Return the value of this <code>Number</code> as a <code>float</code>.
- ** @return the value of this <code>Number</code> as a <code>float</code>.
- **/
+ /**
+ * Return the value of this <code>Number</code> as a <code>float</code>.
+ *
+ * @return the float value
+ */
public abstract float floatValue();
- /** Return the value of this <code>Number</code> as a <code>float</code>.
- ** @return the value of this <code>Number</code> as a <code>float</code>.
- **/
+ /**
+ * Return the value of this <code>Number</code> as a <code>float</code>.
+ *
+ * @return the double value
+ */
public abstract double doubleValue();
- private static final long serialVersionUID = -8742448824652078965L;
+ /**
+ * Return the value of this <code>Number</code> as a <code>byte</code>.
+ *
+ * @return the byte value
+ * @since 1.1
+ */
+ public byte byteValue()
+ {
+ return (byte) intValue();
+ }
+
+ /**
+ * Return the value of this <code>Number</code> as a <code>short</code>.
+ *
+ * @return the short value
+ * @since 1.1
+ */
+ public short shortValue()
+ {
+ return (short) intValue();
+ }
}
-/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
This file is part of libgcj.
init(data, offset, count, false);
}
+ // This is used by Integer.toString(int,int).
+ String (char[] data, int offset, int count, boolean dont_copy)
+ {
+ init(data, offset, count, dont_copy);
+ }
+
public String (byte[] byteArray)
{
this (byteArray, 0, byteArray.length);
-/* java.lang.Void
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+/* Void.class - defines void.class
+ Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
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
package java.lang;
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Complete.
- */
-
/**
- * Void is a placeholder class so that the variable Void.TYPE can be
- * supported for reflection return types.
+ * Void is a placeholder class so that the variable <code>Void.TYPE</code>
+ * (also available as <code>void.class</code>) can be supported for
+ * reflection return types.
+ *
+ * <p>This class could be Serializable, but that is up to Sun.
*
* @author Paul Fisher
* @author John Keiser
- * @author Per Bothner <bothner@cygnus.com>
- * @since JDK1.1
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.1
+ * @status updated to 1.4
*/
public final class Void
{
/**
- * The return type <code>void</code> is represented by this
+ * The return type <code>void</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('V');
/**
- * Don't allow Void objects to be made.
+ * Void is non-instantiable.
*/
private Void() { }
}
}
else
{
- JvAssert (offset == 0);
array = chars;
- pdst = elements (array);
+ pdst = &(elements(array)[offset]);
}
data = array;