This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
Patch: FYI: Merge primitive wrapper classes
- From: Tom Tromey <tromey at redhat dot com>
- To: Java Patch List <java-patches at gcc dot gnu dot org>
- Date: 13 Jun 2002 12:29:15 -0600
- Subject: Patch: FYI: Merge primitive wrapper classes
- Reply-to: tromey at redhat dot com
I'm checking this in. This merges the primitive wrapper classes
(Byte, Long, etc) with Classpath.
I ran this against Mauve with no regressions. Well, there were
regressions, but I fixed them. This patch also found a Mauve bug.
String remains unmerged. I still have Eric's patch for this, but I
haven't looked at it yet.
Tom
Index: ChangeLog
from 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.
Index: java/lang/Boolean.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Boolean.java,v
retrieving revision 1.9
diff -u -r1.9 Boolean.java
--- java/lang/Boolean.java 22 Jan 2002 22:40:16 -0000 1.9
+++ java/lang/Boolean.java 13 Jun 2002 17:35:57 -0000
@@ -1,5 +1,5 @@
/* 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.
@@ -7,7 +7,7 @@
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
@@ -41,148 +41,184 @@
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));
+ }
}
Index: java/lang/Double.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Double.java,v
retrieving revision 1.15
diff -u -r1.15 Double.java
--- java/lang/Double.java 22 Jan 2002 22:40:16 -0000 1.15
+++ java/lang/Double.java 13 Jun 2002 17:35:57 -0000
@@ -1,4 +1,4 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -40,12 +40,6 @@
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.
@@ -55,15 +49,16 @@
*
* @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
@@ -72,43 +67,50 @@
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();
}
}
@@ -118,411 +120,421 @@
*
* @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.
- */
- public boolean equals (Object obj)
- {
- 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
+ * @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 static Double valueOf(String s)
+ {
+ // 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>.
+ * 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.
*
- * @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.
- *
- * @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>.
- *
- * @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 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>.
+ *
+ * @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.
- *
- *
- * @XXX specify where we are not in accord with the spec.
+ * 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.
+ *
+ * <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>.
+ * @return the bits of the <code>double</code>
+ * @see #longBitsToDouble(long)
*/
- public static native long doubleToRawLongBits (double value);
+ public static native long doubleToRawLongBits(double value);
/**
- * Return the <code>double</code> represented by the long
- * bits specified.
+ * 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>.
*
- * @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.
+ * @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.
*
- * @XXX specify where/how we are not in accord with the spec.
+ * @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 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 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();
}
Index: java/lang/Float.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Float.java,v
retrieving revision 1.13
diff -u -r1.13 Float.java
--- java/lang/Float.java 22 Jan 2002 22:40:16 -0000 1.13
+++ java/lang/Float.java 13 Jun 2002 17:35:57 -0000
@@ -1,4 +1,4 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -40,12 +40,6 @@
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.
@@ -55,11 +49,18 @@
*
* @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.
*/
@@ -74,46 +75,50 @@
/**
* 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;
}
@@ -124,379 +129,395 @@
*
* @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 Float (String s) throws NumberFormatException
+ public static String toString(float f)
{
- this.value = parseFloat (s);
+ return Double.toString(f, true);
}
/**
- * 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.
+ * 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 static Float valueOf(String s)
+ {
+ return new Float(parseFloat(s));
+ }
+
+ /**
+ * 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>
- *
- * 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.
+ * Return the value of this <code>Integer</code> as an <code>int</code>.
*
- * @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>.
+ * Return the value of this <code>Integer</code> as a <code>long</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.
- *
- * @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)
@@ -505,24 +526,5 @@
return 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);
}
}
Index: java/lang/Integer.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Integer.java,v
retrieving revision 1.13
diff -u -r1.13 Integer.java
--- java/lang/Integer.java 22 Jan 2002 22:40:16 -0000 1.13
+++ java/lang/Integer.java 13 Jun 2002 17:35:57 -0000
@@ -1,5 +1,5 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -48,36 +48,45 @@
* @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
@@ -88,135 +97,73 @@
}
/**
- * 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)
{
@@ -226,8 +173,9 @@
/**
* 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)
{
@@ -237,8 +185,9 @@
/**
* 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)
{
@@ -248,335 +197,410 @@
/**
* 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>.
+ * 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 Integer valueOf(String s) throws NumberFormatException
+ 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.
+ * Return the value of this <code>Integer</code> as a <code>long</code>.
*
- * 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:
- *
- * <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;
}
}
Index: java/lang/Long.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Long.java,v
retrieving revision 1.11
diff -u -r1.11 Long.java
--- java/lang/Long.java 22 Jan 2002 22:40:16 -0000 1.11
+++ java/lang/Long.java 13 Jun 2002 17:35:57 -0000
@@ -1,5 +1,5 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -39,8 +39,8 @@
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.
@@ -48,38 +48,45 @@
* @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
@@ -90,504 +97,518 @@
}
/**
- * 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;
-
- do
- {
- buffer[--i] = Character.forDigit((int) (num % radix), radix);
- num /= radix;
- }
- while (num > 0);
+ return (int) (value ^ (value >>> 32));
+ }
- if (isNeg)
- buffer[--i] = '-';
+ /**
+ * 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;
+ }
- return String.valueOf(buffer, i, 65-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);
}
-
+
/**
- * 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>.
+ * 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 valueOf(String s) throws NumberFormatException
+ public static Long getLong(String nm, long val)
{
- return new Long(parseLong(s));
+ Long result = getLong(nm, null);
+ return result == null ? new Long(val) : result;
}
/**
- * 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>.
+ * 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 valueOf(String s, int radix) throws NumberFormatException
+ public static Long getLong(String nm, Long def)
{
- return new Long(parseLong(s, radix));
+ 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;
+ }
}
/**
- * Converts the specified <code>String</code> into a <code>long</code>.
- * This function assumes a radix of 10.
+ * 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 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 l the Long to compare
+ * @return the comparison
+ * @since 1.2
*/
- public static long parseLong(String s) throws NumberFormatException
+ public int compareTo(Long l)
{
- return parseLong(s, 10);
+ 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>
- * using the specified radix (base).
+ * Behaves like <code>compareTo(Long)</code> unless the Object
+ * is not a <code>Long</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>long</code>.
- * @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 str, int radix)
- throws NumberFormatException
+ public int compareTo(Object o)
{
- final int len;
+ return compareTo((Long) o);
+ }
- if ((len = str.length()) == 0 || radix < Character.MIN_RADIX
- || radix > Character.MAX_RADIX)
- throw new NumberFormatException();
+ /**
+ * Helper for converting unsigned numbers to String.
+ *
+ * @param num the number
+ * @param exp log2(digit) (ie. 1, 3, or 4 for binary, oct, hex)
+ */
+ private static String toUnsignedString(long num, int exp)
+ {
+ // 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);
- boolean isNeg = false;
- int index = 0;
- if (str.charAt(index) == '-')
- if (len > 1)
- {
- isNeg = true;
- index++;
- }
- else
- 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);
- 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) == '#')
+ if (decode)
{
- radix = 16;
- index++;
- }
- else if (str.charAt(index) == '0')
- {
- // 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;
}
}
Index: java/lang/Number.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Number.java,v
retrieving revision 1.6
diff -u -r1.6 Number.java
--- java/lang/Number.java 22 Jan 2002 22:40:16 -0000 1.6
+++ java/lang/Number.java 13 Jun 2002 17:35:58 -0000
@@ -1,5 +1,5 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -41,54 +41,91 @@
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();
+ }
}
Index: java/lang/String.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/String.java,v
retrieving revision 1.17
diff -u -r1.17 String.java
--- java/lang/String.java 11 Dec 2001 18:01:40 -0000 1.17
+++ java/lang/String.java 13 Jun 2002 17:35:58 -0000
@@ -1,4 +1,4 @@
-/* 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.
@@ -110,6 +110,12 @@
public String (char[] data, int offset, int count)
{
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)
Index: java/lang/Void.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Void.java,v
retrieving revision 1.6
diff -u -r1.6 Void.java
--- java/lang/Void.java 22 Jan 2002 22:40:17 -0000 1.6
+++ java/lang/Void.java 13 Jun 2002 17:35:58 -0000
@@ -1,5 +1,5 @@
-/* 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.
@@ -7,7 +7,7 @@
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
@@ -38,30 +38,29 @@
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() { }
}
Index: java/lang/natString.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/natString.cc,v
retrieving revision 1.26
diff -u -r1.26 natString.cc
--- java/lang/natString.cc 7 May 2002 19:07:07 -0000 1.26
+++ java/lang/natString.cc 13 Jun 2002 17:35:59 -0000
@@ -456,9 +456,8 @@
}
else
{
- JvAssert (offset == 0);
array = chars;
- pdst = elements (array);
+ pdst = &(elements(array)[offset]);
}
data = array;