Skip to content

R
riscv-gcc-1
Commit 93f7aeea by Tom Tromey Committed by Tom Tromey
Options

natString.cc (init): Handle case where DONT_COPY is true and OFFSET!=0. 

	* 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.

From-SVN: r54595
parent a8fa30f3
Showing with 1544 additions and 1393 deletions
libjava/ChangeLog
2002-06-13 Tom Tromey <tromey@redhat.com>
* java/lang/natString.cc (init): Handle case where DONT_COPY is
true and OFFSET!=0.
* java/lang/String.java (String(char[],int,int,boolean): New
constructor.
* java/lang/Long.java: Imported new version from Classpath.
* java/lang/Number.java: Likewise.
* java/lang/Integer.java: Likewise.
* java/lang/Long.java: Likewise.
* java/lang/Float.java: Likewise.
* java/lang/Boolean.java: Likewise.
* java/lang/Double.java: Likewise.
* java/lang/Void.java: Likewise.
2002-06-12 Tom Tromey <tromey@redhat.com> 2002-06-12 Tom Tromey <tromey@redhat.com>
* java/io/natFilePosix.cc (getCanonicalPath): Treat "" like ".". * java/io/natFilePosix.cc (getCanonicalPath): Treat "" like ".".
......
libjava/java/lang/Boolean.java
/* Boolean.java -- object wrapper for boolean /* 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. This file is part of GNU Classpath.
...@@ -45,11 +45,16 @@ import java.io.Serializable; ...@@ -45,11 +45,16 @@ import java.io.Serializable;
* <code>boolean</code> values. * <code>boolean</code> values.
* *
* @author Paul Fisher * @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 public final class Boolean implements Serializable
{ {
static final long serialVersionUID = -3665804199014368530L; /**
* Compatible with JDK 1.0.2+.
*/
private static final long serialVersionUID = -3665804199014368530L;
/** /**
* This field is a <code>Boolean</code> object representing the * This field is a <code>Boolean</code> object representing the
...@@ -70,11 +75,14 @@ public final class Boolean implements Serializable ...@@ -70,11 +75,14 @@ public final class Boolean implements Serializable
/** /**
* The primitive type <code>boolean</code> is represented by this * The primitive type <code>boolean</code> is represented by this
* <code>Class</code> object. * <code>Class</code> object.
*
* @since 1.1
*/ */
public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z'); public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
/** /**
* The immutable value of this Boolean. * The immutable value of this Boolean.
* @serial the wrapped value
*/ */
private final boolean value; private final boolean value;
...@@ -85,8 +93,10 @@ public final class Boolean implements Serializable ...@@ -85,8 +93,10 @@ public final class Boolean implements Serializable
* not create a new object. * not create a new object.
* *
* @param value the primitive value of this <code>Boolean</code> * @param value the primitive value of this <code>Boolean</code>
* @see #valueOf(boolean)
*/ */
public Boolean(boolean value) { public Boolean(boolean value)
{
this.value = value; this.value = value;
} }
...@@ -101,15 +111,19 @@ public final class Boolean implements Serializable ...@@ -101,15 +111,19 @@ public final class Boolean implements Serializable
* @param s the <code>String</code> representation of <code>true</code> * @param s the <code>String</code> representation of <code>true</code>
* or false * or false
*/ */
public Boolean(String s) { public Boolean(String s)
{
value = "true".equalsIgnoreCase(s); value = "true".equalsIgnoreCase(s);
} }
/** /**
* Return the primitive <code>boolean</code> value of this * Return the primitive <code>boolean</code> value of this
* <code>Boolean</code> object. * <code>Boolean</code> object.
*
* @return true or false, depending on the value of this Boolean
*/ */
public boolean booleanValue() { public boolean booleanValue()
{
return value; return value;
} }
...@@ -118,9 +132,14 @@ public final class Boolean implements Serializable ...@@ -118,9 +132,14 @@ public final class Boolean implements Serializable
* <code>true</code>, otherwise it will return the Boolean * <code>true</code>, otherwise it will return the Boolean
* <code>FALSE</code>. * <code>FALSE</code>.
* *
* @param b the boolean to wrap
* @return the wrapper object
* @see #TRUE
* @see #FALSE
* @since 1.4 * @since 1.4
*/ */
public static Boolean valueOf(boolean b) { public static Boolean valueOf(boolean b)
{
return b ? TRUE : FALSE; return b ? TRUE : FALSE;
} }
...@@ -128,18 +147,49 @@ public final class Boolean implements Serializable ...@@ -128,18 +147,49 @@ public final class Boolean implements Serializable
* Returns the Boolean <code>TRUE</code> if and only if the given * Returns the Boolean <code>TRUE</code> if and only if the given
* String is equal, ignoring case, to the the String "true", otherwise * String is equal, ignoring case, to the the String "true", otherwise
* it will return the Boolean <code>FALSE</code>. * 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) { public static Boolean valueOf(String s)
{
return "true".equalsIgnoreCase(s) ? TRUE : FALSE; 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 * Returns the integer <code>1231</code> if this object represents
* the primitive <code>true</code> and the integer <code>1237</code> * the primitive <code>true</code> and the integer <code>1237</code>
* otherwise. * otherwise.
*
* @return the hash code
*/ */
public int hashCode() { public int hashCode()
return (value) ? 1231 : 1237; {
return value ? 1231 : 1237;
} }
/** /**
...@@ -149,40 +199,26 @@ public final class Boolean implements Serializable ...@@ -149,40 +199,26 @@ public final class Boolean implements Serializable
* is <code>null</code>, <code>false</code> is returned. * is <code>null</code>, <code>false</code> is returned.
* *
* @param obj possibly an instance of any <code>Class</code> * @param obj possibly an instance of any <code>Class</code>
* @return <code>false</code> is <code>obj</code> is an instance of * @return true if <code>obj</code> equals this
* <code>Boolean</code> and has the same primitive value as this
* object.
*/ */
public boolean equals(Object obj) { public boolean equals(Object obj)
return (obj instanceof Boolean && value == ((Boolean)obj).value); {
return obj instanceof Boolean && value == ((Boolean) obj).value;
} }
/** /**
* If the value of the system property <code>name</code> matches * If the value of the system property <code>name</code> matches
* "true" ignoring case then the function returns <code>true</code>. * "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 * @param name the property name to look up
*/ * @return true if the property resulted in "true"
public static String toString(boolean b) * @throws SecurityException if accessing the system property is forbidden
{ * @see System#getProperty(String)
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() public static boolean getBoolean(String name)
{ {
return (value) ? "true" : "false"; if (name == null || "".equals(name))
return false;
return "true".equalsIgnoreCase(System.getProperty(name));
} }
} }
libjava/java/lang/Double.java
/* Double.java -- object wrapper for double primitive /* Double.java -- object wrapper for double
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -40,12 +40,6 @@ package java.lang; ...@@ -40,12 +40,6 @@ package java.lang;
import gnu.classpath.Configuration; 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 * Instances of class <code>Double</code> represent primitive
* <code>double</code> values. * <code>double</code> values.
...@@ -55,15 +49,16 @@ import gnu.classpath.Configuration; ...@@ -55,15 +49,16 @@ import gnu.classpath.Configuration;
* *
* @author Paul Fisher * @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com> * @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 public final class Double extends Number implements Comparable
{ {
/** /**
* The minimum positive value a <code>double</code> may represent * Compatible with JDK 1.0+.
* is 5e-324.
*/ */
public static final double MIN_VALUE = 5e-324; private static final long serialVersionUID = -9172774392245257468L;
/** /**
* The maximum positive value a <code>double</code> may represent * The maximum positive value a <code>double</code> may represent
...@@ -72,34 +67,41 @@ public final class Double extends Number implements Comparable ...@@ -72,34 +67,41 @@ public final class Double extends Number implements Comparable
public static final double MAX_VALUE = 1.7976931348623157e+308; 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 * 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. * 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. * 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 * The primitive type <code>double</code> is represented by this
* <code>Class</code> object. * <code>Class</code> object.
* @since 1.1
*/ */
public static final Class TYPE = VMClassLoader.getPrimitiveClass('D'); public static final Class TYPE = VMClassLoader.getPrimitiveClass('D');
/** /**
* The immutable value of this Double. * The immutable value of this Double.
*
* @serial the wrapped double
*/ */
private final double value; private final double value;
private static final long serialVersionUID = -9172774392245257468L;
/** /**
* Load native routines necessary for this class. * Load native routines necessary for this class.
*/ */
...@@ -107,8 +109,8 @@ public final class Double extends Number implements Comparable ...@@ -107,8 +109,8 @@ public final class Double extends Number implements Comparable
{ {
if (Configuration.INIT_LOAD_LIBRARY) if (Configuration.INIT_LOAD_LIBRARY)
{ {
System.loadLibrary ("javalang"); System.loadLibrary("javalang");
initIDs (); initIDs();
} }
} }
...@@ -118,411 +120,421 @@ public final class Double extends Number implements Comparable ...@@ -118,411 +120,421 @@ public final class Double extends Number implements Comparable
* *
* @param value the <code>double</code> argument * @param value the <code>double</code> argument
*/ */
public Double (double value) public Double(double value)
{ {
this.value = value; this.value = value;
} }
/** /**
* Create a <code>Double</code> from the specified * Create a <code>Double</code> from the specified <code>String</code>.
* <code>String</code>.
*
* This method calls <code>Double.parseDouble()</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 * @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> * Convert the <code>double</code> to a <code>String</code>.
* to a <code>String</code>. This method calls * Floating-point string representation is fairly complex: here is a
* <code>Double.toString(double)</code> to do its dirty work. * rundown of the possible values. "<code>[-]</code>" indicates that a
* negative sign will be printed if the value (or exponent) is negative.
* "<code>&lt;number&gt;</code>" means a string of digits ('0' to '9').
* "<code>&lt;digit&gt;</code>" means a single digit ('0' to '9').<br>
* *
* @return the <code>String</code> representation of this <code>Double</code>. * <table border=1>
* @see #toString(double) * <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>[-]&lt;digit&gt;.&lt;number&gt;
* E[-]&lt;number&gt;</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 * Create a new <code>Double</code> object using the <code>String</code>.
* <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>.
* *
* @param obj the object to compare to * @param s the <code>String</code> to convert
* @return whether the objects are semantically equal. * @return the new <code>Double</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>double</code>
* @throws NullPointerException if <code>s</code> is null.
* @see #parseDouble(String)
*/ */
public boolean equals (Object obj) public static Double valueOf(String s)
{ {
if (!(obj instanceof Double)) // XXX just call new Double(parseDouble(s));
return false; if (s == null)
throw new NullPointerException();
double d = ((Double) obj).value; return new Double(s);
// GCJ LOCAL: this implementation is probably faster than
// Classpath's, especially once we inline doubleToLongBits.
return doubleToLongBits (value) == doubleToLongBits (d);
// END GCJ LOCAL
} }
/** /**
* The hashcode is the value of the expression: <br> * Parse the specified <code>String</code> as a <code>double</code>. The
* <br> * extended BNF grammar is as follows:<br>
* <code>(int)(v^(v>>>32))</code><br> * <pre>
* <br> * <em>DecodableString</em>:
* where v is defined by: <br> * ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
* <code>long v = Double.doubleToLongBits(this.longValue());</code><br> * | ( [ <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 () public static native double parseDouble(String s);
{
long v = doubleToLongBits (value);
return (int) (v ^ (v >>> 32));
}
/** /**
* Return the value of this <code>Double</code> when cast to an * Return <code>true</code> if the <code>double</code> has the same
* <code>int</code>. * 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 * Return <code>true</code> if the <code>double</code> has a value
* <code>long</code>. * 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 * Return <code>true</code> if the value of this <code>Double</code>
* <code>float</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 * Return <code>true</code> if the value of this <code>Double</code>
* <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
* @param s the <code>String</code> to convert to a <code>Double</code>. * <code>Double.toString(double)</code> to do its dirty work.
* @return a new <code>Double</code> representing the <code>String</code>'s
* numeric value.
* *
* @exception NullPointerException thrown if <code>String</code> is * @return the <code>String</code> representation
* <code>null</code>. * @see #toString(double)
* @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)
*/ */
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> * Return the value of this <code>Double</code> as a <code>byte</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 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 * Return the value of this <code>Double</code> as a <code>short</code>.
* value as <code>NaN</code>, otherwise return <code>false</code>.
* *
* @param v the <code>double</code> to compare * @return the short value
* @return whether the argument is <code>NaN</code>. * @since 1.1
*/ */
public static boolean isNaN (double v) public short shortValue()
{ {
// This works since NaN != NaN is the only reflexive inequality return (short) value;
// comparison which returns true.
return v != v;
} }
/** /**
* Return <code>true</code> if the value of this <code>Double</code> * Return the value of this <code>Double</code> as an <code>int</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. * @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 * Return the value of this <code>Double</code> as a <code>long</code>.
* 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 the long value
* @return whether the argument is (-/+) infinity.
*/ */
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 * Return the value of this <code>Double</code> as a <code>float</code>.
* 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 * @return the float value
* 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, &lt; 0 if this
* <code>Double</code> is less than the <code>Double</code> in
* in question, or &gt; 0 if it is greater.
* @since 1.2
*/ */
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. * Return the value of this <code>Double</code>.
* 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 * @return the double value
* 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, &lt; 0 if the
* first argument is less than the second argument in
* in question, or &gt; 0 if it is greater.
* @since 1.4
*/ */
public static int compare (double x, double y) public double doubleValue()
{ {
if (isNaN (x)) return value;
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;
} }
/** /**
* Compares the specified <code>Object</code> to this <code>Double</code> * Return a hashcode representing this Object. <code>Double</code>'s hash
* if and only if the <code>Object</code> is an instanceof * code is calculated by:<br>
* <code>Double</code>. * <code>long v = Double.doubleToLongBits(doubleValue());<br>
* int hash = (int)(v^(v&gt;&gt;32))</code>.
* *
* @param o the Object to compare to. * @return this Object's hash code
* @return 0 if the <code>Double</code>s are the same, &lt; 0 if this * @see #doubleToLongBits(double)
* <code>Double</code> is less than the <code>Double</code> in
* in question, or &gt; 0 if it is greater.
* @throws ClassCastException if the argument is not a <code>Double</code>
*/ */
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>. * Returns <code>true</code> if <code>obj</code> is an instance of
* <P> * <code>Double</code> and represents the same double value. Unlike comparing
* * two doubles with <code>==</code>, this treats two instances of
* Floating-point string representation is fairly complex: here is a * <code>Double.NaN</code> as equal, but treats <code>0.0</code> and
* rundown of the possible values. "<CODE>[-]</CODE>" indicates that a * <code>-0.0</code> as unequal.
* negative sign will be printed if the value (or exponent) is negative.
* "<CODE>&lt;number&gt;</CODE>" means a string of digits (0-9).
* "<CODE>&lt;digit&gt;</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>[-]&lt;digit&gt;.&lt;number&gt;E[-]&lt;number&gt;</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.
* *
* <p>Note that <code>d1.equals(d2)<code> is identical to
* <code>doubleToLongBits(d1.doubleValue()) ==
* doubleToLongBits(d2.doubleValue())<code>.
* *
* @XXX specify where we are not in accord with the spec. * @param obj the object to compare
* * @return whether the objects are semantically equal
* @param d the <code>double</code> to convert
* @return the <code>String</code> representing the <code>double</code>.
*/ */
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>. * Convert the double to the IEEE 754 floating-point "double format" bit
* The result of this function can be used as the argument to * layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* <code>Double.longBitsToDouble(long)</code> to obtain the * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* original <code>double</code> value. * (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 * @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>. * Convert the double to the IEEE 754 floating-point "double format" bit
* The result of this function can be used as the argument to * layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* <code>Double.longBitsToDouble(long)</code> to obtain the * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* original <code>double</code> value. This method differs from * (masked by 0x000fffffffffffffL) are the mantissa. This function
* <code>doubleToLongBits</code> in that it does not collapse * leaves NaN alone, rather than collapsing to a canonical value. The
* NaN values. * 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 * @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
* @param bits the long bits representing a <code>double</code> * sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the
* @return the <code>double</code> represented by the bits. * exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa.
*/ * This function leaves NaN alone, so that you can recover the bit pattern
public static native double longBitsToDouble (long bits); * with <code>Double.doubleToRawLongBits(double)</code>.
/**
* 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>[+-]&lt;number&gt;[.]</CODE></TD><TD>345., -10, 12</TD></TR>
* <TR><TD><CODE>[+-]&lt;number&gt;.&lt;number&gt;</CODE></TD><TD>40.2, 80.00, -12.30</TD></TR>
* <TR><TD><CODE>[+-]&lt;number&gt;[.]E[+-]&lt;number&gt;</CODE></TD><TD>80E12, -12e+7, 4.E-123</TD></TR>
* <TR><TD><CODE>[+-]&lt;number&gt;.&lt;number&gt;E[+-]&lt;number&gt;</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>&lt;number&gt;</code>" means a string of digits (0-9), basically
* an integer. "<code>&lt;number&gt;.&lt;number&gt;</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.
* *
* @XXX specify where/how we are not in accord with the spec. * @param bits the bits to convert
* @return the <code>double</code> represented by the bits
* @see #doubleToLongBits(double)
* @see #doubleToRawLongBits(double)
*/
public static native double longBitsToDouble(long bits);
/**
* Compare two Doubles numerically by comparing their <code>double</code>
* values. The result is positive if the first is greater, negative if the
* second is greater, and 0 if the two are equal. However, this special
* cases NaN and signed zero as follows: NaN is considered greater than
* all other doubles, including <code>POSITIVE_INFINITY</code>, and positive
* zero is considered greater than negative zero.
* *
* @param str the <code>String</code> to convert * @param d the Double to compare
* @return the value of the <code>String</code> as a <code>double</code>. * @return the comparison
* @exception NumberFormatException when the string cannot be parsed to a * @since 1.2
* <code>double</code>. */
* @exception NullPointerException when the string is null. public int compareTo(Double d)
* @see #MIN_VALUE {
* @see #MAX_VALUE return compare(value, d.value);
* @see #POSITIVE_INFINITY }
* @see #NEGATIVE_INFINITY
/**
* Behaves like <code>compareTo(Double)</code> unless the Object
* is not an <code>Double</code>.
*
* @param o the object to compare
* @return the comparison
* @throws ClassCastException if the argument is not a <code>Double</code>
* @see #compareTo(Double)
* @see Comparable
* @since 1.2 * @since 1.2
*/ */
public static native double parseDouble (String s) public int compareTo(Object o)
throws NumberFormatException; {
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. * static initializer when using JNI.
*/ */
private static native void initIDs (); private static native void initIDs();
} }
libjava/java/lang/Float.java
/* java.lang.Float /* Float.java -- object wrapper for float
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -40,12 +40,6 @@ package java.lang; ...@@ -40,12 +40,6 @@ package java.lang;
import gnu.classpath.Configuration; 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 * Instances of class <code>Float</code> represent primitive
* <code>float</code> values. * <code>float</code> values.
...@@ -55,11 +49,18 @@ import gnu.classpath.Configuration; ...@@ -55,11 +49,18 @@ import gnu.classpath.Configuration;
* *
* @author Paul Fisher * @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com> * @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 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 * The maximum positive value a <code>double</code> may represent
* is 3.4028235e+38f. * is 3.4028235e+38f.
*/ */
...@@ -74,46 +75,50 @@ public final class Float extends Number implements Comparable ...@@ -74,46 +75,50 @@ public final class Float extends Number implements Comparable
/** /**
* The value of a float representation -1.0/0.0, negative infinity. * 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. * 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. * 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. * <code>Class</code> object.
* @since 1.1
*/ */
public static final Class TYPE = VMClassLoader.getPrimitiveClass('F'); public static final Class TYPE = VMClassLoader.getPrimitiveClass('F');
/** /**
* The immutable value of this Float. * The immutable value of this Float.
*
* @serial the wrapped float
*/ */
private final float value; private final float value;
private static final long serialVersionUID = -2671257302660747028L; /**
* Load native routines necessary for this class.
*/
static static
{ {
if (Configuration.INIT_LOAD_LIBRARY) 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. * 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; this.value = value;
} }
...@@ -124,379 +129,395 @@ public final class Float extends Number implements Comparable ...@@ -124,379 +129,395 @@ public final class Float extends Number implements Comparable
* *
* @param value the <code>double</code> argument * @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>. * Create a <code>Float</code> from the specified <code>String</code>.
*
* This method calls <code>Float.parseFloat()</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 * @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>&lt;number&gt;</code>" means a string of digits ('0' to '9').
* "<code>&lt;digit&gt;</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>[-]&lt;digit&gt;.&lt;number&gt;
* E[-]&lt;number&gt;</code></td></tr>
* <tr><td>[+-] infinity</td> <td><code>[-]Infinity</code></td></tr>
* <tr><td>NaN</td> <td><code>NaN</code></td></tr>
* </table>
*
* Yes, negative zero <em>is</em> a possible value. Note that there is
* <em>always</em> a <code>.</code> and at least one digit printed after
* it: even if the number is 3, it will be printed as <code>3.0</code>.
* After the ".", all digits will be printed except trailing zeros. The
* result is rounded to the shortest decimal number which will parse back
* to the same float.
*
* <p>To create other output formats, use {@link java.text.NumberFormat}.
*
* @XXX specify where we are not in accord with the spec.
*
* @param f the <code>float</code> to convert
* @return the <code>String</code> representing the <code>float</code>
*/
public static String toString(float f)
{
return Double.toString(f, true);
}
/**
* Creates a new <code>Float</code> object using the <code>String</code>.
*
* @param s the <code>String</code> to convert
* @return the new <code>Float</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>float</code>
* @throws NullPointerException if <code>s</code> is null
* @see #parseFloat(String)
*/ */
public Float (String s) throws NumberFormatException public static Float valueOf(String s)
{ {
this.value = parseFloat (s); return new Float(parseFloat(s));
} }
/** /**
* Parse the specified <code>String</code> as a <code>float</code>. * Parse the specified <code>String</code> as a <code>float</code>. The
* * extended BNF grammar is as follows:<br>
* The number is really read as <em>n * 10<sup>exponent</sup></em>. The * <pre>
* first number is <em>n</em>, and if there is an "<code>E</code>" * <em>DecodableString</em>:
* ("<code>e</code>" is also acceptable), then the integer after that is * ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
* the exponent. * | ( [ <code>-</code> | <code>+</code> ] <code>Infinity</code> )
* <P> * | ( [ <code>-</code> | <code>+</code> ] <em>FloatingPoint</em>
* Here are the possible forms the number can take: * [ <code>f</code> | <code>F</code> | <code>d</code>
* <BR> * | <code>D</code>] )
* <TABLE BORDER=1> * <em>FloatingPoint</em>:
* <TR><TH>Form</TH><TH>Examples</TH></TR> * ( { <em>Digit</em> }+ [ <code>.</code> { <em>Digit</em> } ]
* <TR><TD><CODE>[+-]&lt;number&gt;[.]</CODE></TD><TD>345., -10, 12</TD></TR> * [ <em>Exponent</em> ] )
* <TR><TD><CODE>[+-]&lt;number&gt;.&lt;number&gt;</CODE></TD><TD>40.2, 80.00, -12.30</TD></TR> * | ( <code>.</code> { <em>Digit</em> }+ [ <em>Exponent</em> ] )
* <TR><TD><CODE>[+-]&lt;number&gt;[.]E[+-]&lt;number&gt;</CODE></TD><TD>80E12, -12e+7, 4.E-123</TD></TR> * <em>Exponent</em>:
* <TR><TD><CODE>[+-]&lt;number&gt;.&lt;number&gt;E[+-]&lt;number&gt;</CODE></TD><TD>6.02e-22, -40.2E+6, 12.3e9</TD></TR> * ( ( <code>e</code> | <code>E</code> )
* </TABLE> * [ <code>-</code> | <code>+</code> ] { <em>Digit</em> }+ )
* * <em>Digit</em>: <em><code>'0'</code> through <code>'9'</code></em>
* "<code>[+-]</code>" means either a plus or minus sign may go there, or * </pre>
* neither, in which case + is assumed. *
* <BR> * <p>NaN and infinity are special cases, to allow parsing of the output
* "<code>[.]</code>" means a dot may be placed here, but is optional. * of toString. Otherwise, the result is determined by calculating
* <BR> * <em>n * 10<sup>exponent</sup></em> to infinite precision, then rounding
* "<code>&lt;number&gt;</code>" means a string of digits (0-9), basically * to the nearest float. Remember that many numbers cannot be precisely
* an integer. "<code>&lt;number&gt;.&lt;number&gt;</code>" is basically * represented in floating point. In case of overflow, infinity is used,
* a real number, a floating-point value. * and in case of underflow, signed zero is used. Unlike Integer.parseInt,
* <P> * this does not accept Unicode digits outside the ASCII range.
* 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 * <p>If an unexpected character is found in the <code>String</code>, a
* than <code>-Float.MAX_VALUE</code>, it will be set at * <code>NumberFormatException</code> will be thrown. Leading and trailing
* <code>Float.POSITIVE_INFINITY</code> or * 'whitespace' is ignored via <code>String.trim()</code>, but spaces
* <code>Float.NEGATIVE_INFINITY</code>, respectively. * internal to the actual number are not allowed.
* <P> *
* * <p>To parse numbers according to another format, consider using
* Note also that <code>float</code> does not have perfect precision. Many * {@link java.text.NumberFormat}.
* 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.
* *
* @XXX specify where/how we are not in accord with the spec. * @XXX specify where/how we are not in accord with the spec.
* *
* @param str the <code>String</code> to convert * @param str the <code>String</code> to convert
* @return the value of the <code>String</code> as a <code>float</code>. * @return the <code>float</code> value of <code>s</code>
* @exception NumberFormatException when the string cannot be parsed to a * @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>float</code>. * <code>float</code>
* @since JDK 1.2 * @throws NullPointerException if <code>s</code> is null
* @see #MIN_VALUE * @see #MIN_VALUE
* @see #MAX_VALUE * @see #MAX_VALUE
* @see #POSITIVE_INFINITY * @see #POSITIVE_INFINITY
* @see #NEGATIVE_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 // XXX Rounding parseDouble() causes some errors greater than 1 ulp from
// Double.valueOf(). This is equivalent, in our implementation, // the infinitely precise decimal.
// but more efficient. return (float) Double.parseDouble(s);
return (float) Double.parseDouble (s);
} }
/** /**
* Convert the <code>float</code> value of this <code>Float</code> * Return <code>true</code> if the <code>float</code> has the same
* to a <code>String</code>. This method calls * value as <code>NaN</code>, otherwise return <code>false</code>.
* <code>Float.toString(float)</code> to do its dirty work.
* *
* @return the <code>String</code> representation of this <code>Float</code>. * @param v the <code>float</code> to compare
* @see #toString(float) * @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 * Return <code>true</code> if the <code>float</code> has a value
* <code>instanceof</code> <code>Float</code>, and represents * equal to either <code>NEGATIVE_INFINITY</code> or
* the same primitive <code>float</code> value return * <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
* <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>.
* *
* @param obj the object to compare to * @param v the <code>float</code> to compare
* @return whether the objects are semantically equal. * @return whether the argument is (-/+) infinity
*/ */
public boolean equals (Object obj) public static boolean isInfinite(float v)
{ {
if (!(obj instanceof Float)) return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
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 a hashcode representing this Object. * Return <code>true</code> if the value of this <code>Float</code>
* <code>Float</code>'s hash code is calculated by calling the * is the same as <code>NaN</code>, otherwise return <code>false</code>.
* <code>floatToIntBits()</code> function. *
* @return this Object's hash code. * @return whether this <code>Float</code> is <code>NaN</code>
* @see java.lang.Float.floatToIntBits(float)
*/ */
public int hashCode () public boolean isNaN()
{ {
return floatToIntBits (value); return isNaN(value);
} }
/** /**
* Return the value of this <code>Double</code> when cast to an * Return <code>true</code> if the value of this <code>Float</code>
* <code>int</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 * Convert the <code>float</code> value of this <code>Float</code>
* <code>long</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 * Return the value of this <code>Float</code> as a <code>byte</code>.
* <code>float</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 * Return the value of this <code>Float</code> as a <code>short</code>.
* <code>Double</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>. * Return the value of this <code>Integer</code> as an <code>int</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>&lt;number&gt;</CODE>" means a string of digits (0-9).
* "<CODE>&lt;digit&gt;</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>[-]&lt;digit&gt;.&lt;number&gt;E[-]&lt;number&gt;</CODE></TD>
* </TR>
* <TR>
* <TD>[+-] infinity</TD>
* <TD><CODE>[-]Infinity</CODE></TD>
* </TR>
* <TR>
* <TD>NaN</TD>
* <TD><CODE>NaN</CODE></TD>
* </TR>
* </TABLE>
*
* Yes, negative zero <EM>is</EM> a possible value. Note that there is
* <EM>always</EM> a <CODE>.</CODE> and at least one digit printed after
* it: even if the number is 3, it will be printed as <CODE>3.0</CODE>.
* After the ".", all digits will be printed except trailing zeros. No
* truncation or rounding is done by this function.
*
* @XXX specify where we are not in accord with the spec.
* *
* @param f the <code>float</code> to convert * @return the int value
* @return the <code>String</code> representing the <code>float</code>.
*/ */
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 * @return the long value
* be parsed as a <code>double</code>.
* @see #Float(java.lang.String)
* @see #parseFloat(java.lang.String)
*/ */
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> * Return 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 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 * Return the value of this <code>Float</code> as a <code>double</code>
* value as <code>NaN</code>, otherwise return <code>false</code>.
* *
* @param v the <code>float</code> to compare * @return the double value
* @return whether the argument is <code>NaN</code>.
*/ */
public static boolean isNaN (float v) public double doubleValue()
{ {
// This works since NaN != NaN is the only reflexive inequality return value;
// comparison which returns true.
return v != v;
} }
/** /**
* Return <code>true</code> if the value of this <code>Float</code> * Return a hashcode representing this Object. <code>Float</code>'s hash
* is the same as <code>NEGATIVE_INFINITY</code> or * code is calculated by calling <code>floatToIntBits(floatValue())</code>.
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</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 * Returns <code>true</code> if <code>obj</code> is an instance of
* equal to either <code>NEGATIVE_INFINITY</code> or * <code>Float</code> and represents the same float value. Unlike comparing
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>. * 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 * <p>Note that <code>f1.equals(f2)<code> is identical to
* @return whether the argument is (-/+) infinity. * <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>. * Convert the float to the IEEE 754 floating-point "single format" bit
* The result of this function can be used as the argument to * layout. Bit 31 (the most significant) is the sign bit, bits 30-23
* <code>Float.intBitsToFloat(long)</code> to obtain the * (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. * original <code>float</code> value.
* *
* @param value the <code>float</code> to convert * @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>. * Convert the float to the IEEE 754 floating-point "single format" bit
* The result of this function can be used as the argument to * layout. Bit 31 (the most significant) is the sign bit, bits 30-23
* <code>Float.intBitsToFloat(long)</code> to obtain the * (masked by 0x7f800000) represent the exponent, and bits 22-0
* original <code>float</code> value. The difference between * (masked by 0x007fffff) are the mantissa. This function leaves NaN alone,
* this function and <code>floatToIntBits</code> is that this * rather than collapsing to a canonical value. The result of this function
* function does not collapse NaN values. * 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 * @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 * Convert the argument in IEEE 754 floating-point "single format" bit
* bits specified. * 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> * @param bits the bits to convert
* @return the <code>float</code> represented by the bits. * @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 * Compare two Floats numerically by comparing their <code>float</code>
* equal to the value of this <code>Float</code>. Returns a number * values. The result is positive if the first is greater, negative if the
* less than zero if the value of this <code>Float</code> is less * second is greater, and 0 if the two are equal. However, this special
* than the <code>Float</code> value of the argument, and returns a * cases NaN and signed zero as follows: NaN is considered greater than
* number greater than zero if the value of this <code>Float</code> * all other floats, including <code>POSITIVE_INFINITY</code>, and positive
* is greater than the <code>float</code> value of the argument. * zero is considered greater than negative zero.
* <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 f the Float to compare to. * @param f the Float to compare
* @return 0 if the <code>Float</code>s are the same, &lt; 0 if this * @return the comparison
* <code>Float</code> is less than the <code>Float</code> in * @since 1.2
* in question, or &gt; 0 if it is greater. */
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 * @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. * Behaves like <code>new Float(x).compareTo(new Float(y))</code>; in
* Returns a number less than zero if the first argument is less than the * other words this compares two floats, special casing NaN and zero,
* second argument, and returns a number greater than zero if the first * without the overhead of objects.
* argument is greater than the second argument. *
* <br> * @param x the first float to compare
* <code>Float.NaN</code> is greater than any number other than itself, * @param y the second float to compare
* even <code>Float.POSITIVE_INFINITY</code>. * @return the comparison
* <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, &lt; 0 if the
* first argument is less than the second argument in
* in question, or &gt; 0 if it is greater.
* @since 1.4 * @since 1.4
*/ */
public static int compare (float x, float y) public static int compare(float x, float y)
{ {
if (isNaN (x)) if (isNaN(x))
return isNaN (y) ? 0 : 1; return isNaN(y) ? 0 : 1;
if (isNaN (y)) if (isNaN(y))
return -1; return -1;
// recall that 0.0 == -0.0, so we convert to infinities and try again // recall that 0.0 == -0.0, so we convert to infinities and try again
if (x == 0 && y == 0) if (x == 0 && y == 0)
...@@ -506,23 +527,4 @@ public final class Float extends Number implements Comparable ...@@ -506,23 +527,4 @@ public final class Float extends Number implements Comparable
return x > y ? 1 : -1; 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, &lt; 0 if this
* <code>Float</code> is less than the <code>Float</code> in
* in question, or &gt; 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);
}
} }
libjava/java/lang/Integer.java
/* java.lang.Integer /* Integer.java -- object wrapper for int
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -48,31 +48,40 @@ package java.lang; ...@@ -48,31 +48,40 @@ package java.lang;
* @author Paul Fisher * @author Paul Fisher
* @author John Keiser * @author John Keiser
* @author Warren Levy * @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 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; 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; 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; 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. * <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. * The immutable value of this Integer.
*
* @serial the wrapped int
*/ */
private final int value; private final int value;
...@@ -91,132 +100,70 @@ public final class Integer extends Number implements Comparable ...@@ -91,132 +100,70 @@ public final class Integer extends Number implements Comparable
* 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>. * 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
public Integer(String s) throws NumberFormatException * @see #valueOf(String)
{
value = parseInt(s, 10);
}
/**
* 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) public Integer(String s)
{ {
return obj instanceof Integer && value == ((Integer)obj).value; value = parseInt(s, 10, false);
} }
/** /**
* Get the specified system property as an <code>Integer</code>. * 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').
* *
* The <code>decode()</code> method will be used to interpret the value of * @param num the <code>int</code> to convert to <code>String</code>
* the property. * @param radix the radix (base) to use in the conversion
* @param nm the name of the system property * @return the <code>String</code> representation of the argument
* @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) public static String toString(int num, int radix)
{ {
return getInteger(nm, null); if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
} radix = 10;
/** // For negative numbers, print out the absolute value w/ a leading '-'.
* Get the specified system property as an <code>Integer</code>, or use a // Use an array large enough for a binary number.
* default <code>int</code> value if the property is not found or is not char[] buffer = new char[33];
* decodable. int i = 33;
* boolean isNeg = false;
* The <code>decode()</code> method will be used to interpret the value of if (num < 0)
* 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,java.lang.Integer)
*/
public static Integer getInteger(String nm, int val)
{ {
Integer result = getInteger(nm, null); isNeg = true;
return (result == null) ? new Integer(val) : result; num = -num;
}
/** // When the value is MIN_VALUE, it overflows when made positive
* Get the specified system property as an <code>Integer</code>, or use a if (num < 0)
* 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)
{ {
return def; 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 do
{ {
buffer[--i] = Character.forDigit(num & mask, radix); buffer[--i] = digits[num % radix];
num = num >>> exp; 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 * Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 16. * unsigned in base 16.
*
* @param i the <code>int</code> to convert to <code>String</code> * @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) public static String toHexString(int i)
{ {
...@@ -226,8 +173,9 @@ public final class Integer extends Number implements Comparable ...@@ -226,8 +173,9 @@ public final class Integer extends Number implements Comparable
/** /**
* Converts the <code>int</code> to a <code>String</code> assuming it is * Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 8. * unsigned in base 8.
*
* @param i the <code>int</code> to convert to <code>String</code> * @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) public static String toOctalString(int i)
{ {
...@@ -237,8 +185,9 @@ public final class Integer extends Number implements Comparable ...@@ -237,8 +185,9 @@ public final class Integer extends Number implements Comparable
/** /**
* Converts the <code>int</code> to a <code>String</code> assuming it is * Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 2. * unsigned in base 2.
*
* @param i the <code>int</code> to convert to <code>String</code> * @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) public static String toBinaryString(int i)
{ {
...@@ -248,335 +197,410 @@ public final class Integer extends Number implements Comparable ...@@ -248,335 +197,410 @@ public final class Integer extends Number implements Comparable
/** /**
* Converts the <code>int</code> to a <code>String</code> and assumes * Converts the <code>int</code> to a <code>String</code> and assumes
* a radix of 10. * a radix of 10.
*
* @param i the <code>int</code> to convert to <code>String</code> * @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) public static String toString(int i)
{ {
// This is tricky: in libgcj, String.valueOf(int) is a fast native // This is tricky: in libgcj, String.valueOf(int) is a fast native
// implementation. In Classpath it just calls back to // implementation. In Classpath it just calls back to
// Integer.toString(int,int). // Integer.toString(int, int).
return String.valueOf (i); return String.valueOf(i);
} }
/** /**
* Converts the <code>Integer</code> value to a <code>String</code> and * Converts the specified <code>String</code> into an <code>int</code>
* assumes a radix of 10. * using the specified radix (base). The string must not be <code>null</code>
* @return the <code>String</code> representation of this <code>Integer</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 String toString() public static int parseInt(String str, int radix)
{ {
return toString (value); return parseInt(str, radix, false);
} }
/** /**
* Converts the <code>int</code> to a <code>String</code> using * Converts the specified <code>String</code> into an <code>int</code>.
* the specified radix (base). * This function assumes a radix of 10.
* @param i the <code>int</code> to convert to <code>String</code>. *
* @param radix the radix (base) to use in the conversion. * @param s the <code>String</code> to convert
* @return the <code>String</code> representation of the argument. * @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 String toString(int num, int radix) public static int parseInt(String s)
{
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; return parseInt(s, 10, false);
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 /**
* 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>
* @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)
{ {
buffer[--i] = Character.forDigit(num % radix, radix); return new Integer(parseInt(s, radix, false));
num /= radix;
}
while (num > 0);
if (isNeg)
buffer[--i] = '-';
return String.valueOf(buffer, i, 33-i);
} }
/** /**
* Creates a new <code>Integer</code> object using the <code>String</code>, * Creates a new <code>Integer</code> object using the <code>String</code>,
* assuming a radix of 10. * assuming a radix of 10.
* @param s the <code>String</code> to convert. *
* @return the new <code>Integer</code>. * @param s the <code>String</code> to convert
* @see #Integer(java.lang.String) * @return the new <code>Integer</code>
* @see #parseInt(java.lang.String) * @throws NumberFormatException if <code>s</code> cannot be parsed as an
* @exception NumberFormatException thrown if the <code>String</code> * <code>int</code>
* cannot be parsed as an <code>int</code>. * @see #Integer(String)
* @see #parseInt(String)
*/ */
public static Integer valueOf(String s) throws NumberFormatException public static Integer valueOf(String s)
{ {
return new Integer(parseInt(s)); return new Integer(parseInt(s, 10, false));
} }
/** /**
* Creates a new <code>Integer</code> object using the <code>String</code> * Return the value of this <code>Integer</code> as a <code>byte</code>.
* and specified radix (base). *
* @param s the <code>String</code> to convert. * @return the byte value
* @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>.
*/ */
public static Integer valueOf(String s, int radix) public byte byteValue()
throws NumberFormatException
{ {
return new Integer(parseInt(s, radix)); return (byte) value;
} }
/** /**
* Converts the specified <code>String</code> into an <code>int</code>. * Return the value of this <code>Integer</code> as a <code>short</code>.
* This function assumes a radix of 10.
* *
* @param s the <code>String</code> to convert * @return the short value
* @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>.
*/ */
public static int parseInt(String s) throws NumberFormatException public short shortValue()
{ {
return parseInt(s, 10); return (short) value;
} }
/** /**
* Converts the specified <code>String</code> into an <code>int</code> * Return the value of this <code>Integer</code>.
* using the specified radix (base). * @return the int value
*
* @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>.
*/ */
public static int parseInt(String str, int radix) public int intValue()
throws NumberFormatException
{
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; return value;
index++;
}
else
throw new NumberFormatException();
return parseInt(str, index, len, isNeg, radix);
} }
private static int parseInt(String str, int index, int len, boolean isNeg, /**
int radix) * Return the value of this <code>Integer</code> as a <code>long</code>.
throws NumberFormatException *
{ * @return the long value
int val = 0; */
int digval; public long longValue()
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) return value;
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 isNeg ? -(val) : val;
} }
/** /**
* Convert the specified <code>String</code> into an <code>Integer</code>. * Return the value of this <code>Integer</code> as a <code>float</code>.
* The <code>String</code> may represent decimal, hexadecimal, or
* octal numbers.
*
* The <code>String</code> argument is interpreted based on the leading
* characters. Depending on what the String begins with, the base will be
* interpreted differently:
*
* <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 float value
* @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>.
*/ */
public static Integer decode(String str) throws NumberFormatException public float floatValue()
{
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; return value;
index++;
isNeg = true;
} }
else if (str.charAt(index) == '#')
/**
* Return the value of this <code>Integer</code> as a <code>double</code>.
*
* @return the double value
*/
public double doubleValue()
{ {
radix = 16; return value;
index++;
} }
else if (str.charAt(index) == '0')
{
// Check if str is just "0"
if (len == 1)
return new Integer(0);
index++; /**
if (str.charAt(index) == 'x' || str.charAt(index) == 'X') * 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()
{ {
radix = 16; return String.valueOf(value);
index++;
}
else
radix = 8;
} }
if (index >= len) /**
throw new NumberFormatException("empty value"); * Return a hashcode representing this Object. <code>Integer</code>'s hash
* code is simply its value.
return new Integer(parseInt(str, index, len, isNeg, radix)); *
* @return this Object's hash code
*/
public int hashCode()
{
return 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>. * Returns <code>true</code> if <code>obj</code> is an instance of
**/ * <code>Integer</code> and represents the same int value.
public byte byteValue() *
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{ {
return (byte) value; return obj instanceof Integer && value == ((Integer) obj).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>. * Get the specified system property as an <code>Integer</code>. The
**/ * <code>decode()</code> method will be used to interpret the value of
public short shortValue() * 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 (short) value; return getInteger(nm, null);
} }
/** 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>. * 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
public int intValue() * 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>long</code>. /**
** @return the value of this <code>Integer</code> as a <code>long</code>. * 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
public long longValue() * 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 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()
{ {
return value; 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>. * Convert the specified <code>String</code> into an <code>Integer</code>.
**/ * The <code>String</code> may represent decimal, hexadecimal, or
public double doubleValue() * 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 * Compare two Integers numerically by comparing their <code>int</code>
* <code>int</code> values. * values. The result is positive if the first is greater, negative if the
* @return a positive value if this <code>Integer</code> is greater * second is greater, and 0 if the two are equal.
* 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>.
* *
* @param i the Integer to compare
* @return the comparison
* @since 1.2 * @since 1.2
*/ */
public int compareTo(Integer i) public int compareTo(Integer i)
{ {
if (this.value == i.value) if (value == i.value)
return 0; return 0;
// Returns just -1 or 1 on inequality; doing math might overflow. // Returns just -1 or 1 on inequality; doing math might overflow.
if (this.value > i.value) return value > i.value ? 1 : -1;
return 1;
return -1;
} }
/** /**
* Behaves like <code>compareTo(java.lang.Integer)</code> unless the Object * Behaves like <code>compareTo(Integer)</code> unless the Object
* is not a <code>Integer</code>. Then it throws a * is not an <code>Integer</code>.
* <code>ClassCastException</code>.
* @exception ClassCastException if the argument is not a
* <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 * @since 1.2
*/ */
public int compareTo(Object o) 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;
} }
} }
libjava/java/lang/Long.java
/* java.lang.Long /* Long.java -- object wrapper for long
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -39,8 +39,8 @@ exception statement from your version. */ ...@@ -39,8 +39,8 @@ exception statement from your version. */
package java.lang; package java.lang;
/** /**
* Instances of class <code>Double</code> represent primitive * Instances of class <code>Long</code> represent primitive
* <code>double</code> values. * <code>long</code> values.
* *
* Additionally, this class provides various helper functions and variables * Additionally, this class provides various helper functions and variables
* related to longs. * related to longs.
...@@ -48,33 +48,40 @@ package java.lang; ...@@ -48,33 +48,40 @@ package java.lang;
* @author Paul Fisher * @author Paul Fisher
* @author John Keiser * @author John Keiser
* @author Warren Levy * @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 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 * The minimum value a <code>long</code> can represent is
* -9223372036854775808. * -9223372036854775808L (or -2<sup>63</sup>).
*/ */
public static final long MIN_VALUE = 0x8000000000000000L; public static final long MIN_VALUE = 0x8000000000000000L;
/** /**
* The maximum value a <code>long</code> can represent is * 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; 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. * <code>Class</code> object.
* @since 1.1
*/ */
public static final Class TYPE = VMClassLoader.getPrimitiveClass ('J'); public static final Class TYPE = VMClassLoader.getPrimitiveClass ('J');
/** /**
* The immutable value of this Long. * The immutable value of this Long.
*
* @serial the wrapped long
*/ */
private final long value; private final long value;
...@@ -93,374 +100,482 @@ public final class Long extends Number implements Comparable ...@@ -93,374 +100,482 @@ public final class Long extends Number implements Comparable
* 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>. * 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 * Converts the <code>long</code> to a <code>String</code> using
* <code>instanceof</code> <code>Long</code>, and represents * the specified radix (base). If the radix exceeds
* the same primitive <code>long</code> value return * <code>Character.MIN_RADIX</code> or <code>Character.MAX_RADIX</code>, 10
* <code>true</code>. Otherwise <code>false</code> is returned. * 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)
{
// 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)
{ {
return obj instanceof Long && ((Long)obj).value == value; 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.
* *
* @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 toHexString(long l)
{ {
return (int)(value^(value>>>32)); return toUnsignedString(l, 4);
} }
/** /**
* 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 8.
* 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 l the <code>long</code> to convert to <code>String</code>
* @return the system property as an <code>Long</code>, or * @return the <code>String</code> representation of the argument
* <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)
*/ */
public static Long getLong(String nm) public static String toOctalString(long l)
{ {
return getLong(nm, null); return toUnsignedString(l, 3);
} }
/** /**
* Get the specified system property as an <code>Long</code>, or use a * Converts the <code>long</code> to a <code>String</code> assuming it is
* default <code>long</code> value if the property is not found or is not * unsigned in base 2.
* 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 l the <code>long</code> to convert to <code>String</code>
* @param val the default value to use if the property is not found or not * @return the <code>String</code> representation of the argument
* 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)
*/ */
public static Long getLong(String nm, long val) public static String toBinaryString(long l)
{ {
Long result = getLong(nm, null); return toUnsignedString(l, 1);
return (result == null) ? new Long(val) : result;
} }
/** /**
* Get the specified system property as an <code>Long</code>, or use a * Converts the <code>long</code> to a <code>String</code> and assumes
* default <code>Long</code> value if the property is not found or is * a radix of 10.
* 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 num the <code>long</code> to convert to <code>String</code>
* @param val the default value to use if the property is not found or not * @return the <code>String</code> representation of the argument
* a number. * @see #toString(long, int)
* @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)
*/ */
public static Long getLong(String nm, Long def) public static String toString(long num)
{
String val = System.getProperty(nm);
if (val == null)
return def;
try
{ {
return decode(nm); return toString(num, 10);
} }
catch (NumberFormatException e)
/**
* 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 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 parseLong(String str, int radix)
{ {
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>.
// Use an array large enough for a binary number. * This function assumes a radix of 10.
int radix = 1 << exp; *
int mask = radix - 1; * @param s the <code>String</code> to convert
char[] buffer = new char[64]; * @return the <code>int</code> value of <code>s</code>
int i = 64; * @throws NumberFormatException if <code>s</code> cannot be parsed as a
do * <code>long</code>
* @see #parseLong(String, int)
*/
public static long parseLong(String s)
{ {
buffer[--i] = Character.forDigit((int) num & mask, radix); return parseLong(s, 10, false);
num = num >>> exp;
} }
while (num != 0);
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 * Creates a new <code>Long</code> object using the <code>String</code>,
* unsigned in base 16. * assuming a radix of 10.
* @param i the <code>long</code> to convert to <code>String</code> *
* @return the <code>String</code> representation of the argument. * @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 * Convert the specified <code>String</code> into a <code>Long</code>.
* unsigned in base 8. * The <code>String</code> may represent decimal, hexadecimal, or
* @param i the <code>long</code> to convert to <code>String</code> * octal numbers.
* @return the <code>String</code> representation of the argument. *
* <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 * Return the value of this <code>Long</code> as a <code>byte</code>.
* unsigned in base 2. *
* @param i the <code>long</code> to convert to <code>String</code> * @return the byte value
* @return the <code>String</code> representation of the argument.
*/ */
public static String toBinaryString(long i) { public byte byteValue()
return toUnsignedString(i, 1); {
return (byte) value;
} }
/** /**
* Converts the <code>long</code> to a <code>String</code> and assumes * Return the value of this <code>Long</code> as a <code>short</code>.
* a radix of 10. *
* @param num the <code>long</code> to convert to <code>String</code> * @return the short value
* @return the <code>String</code> representation of the argument.
*/ */
public static String toString(long num) public short shortValue()
{ {
// Use the Integer toString for efficiency if possible. return (short) value;
if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) }
return Integer.toString((int) num);
// Use an array large enough for "-9223372036854775808"; i.e. 20 chars. /**
char[] buffer = new char[20]; * Return the value of this <code>Long</code> as an <code>int</code>.
int i = 20; *
boolean isNeg; * @return the int value
if (num < 0) */
{ public int intValue()
isNeg = true;
num = -(num);
if (num < 0)
{ {
// Must be MIN_VALUE, so handle this special case. return (int) value;
buffer[--i] = '8';
num = 922337203685477580L;
}
} }
else
isNeg = false;
do /**
* Return the value of this <code>Long</code>.
*
* @return the long value
*/
public long longValue()
{ {
buffer[--i] = (char) ((int) '0' + (num % 10)); return value;
num /= 10;
} }
while (num > 0);
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 * Converts the <code>Long</code> value to a <code>String</code> and
* assumes a radix of 10. * 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() public String toString()
{ {
return toString(value); return toString(value, 10);
} }
/** /**
* Converts the <code>long</code> to a <code>String</code> using * Return a hashcode representing this Object. <code>Long</code>'s hash
* the specified radix (base). * code is calculated by <code>(int) (value ^ (value &gt;&gt; 32))</code>.
* @param num the <code>long</code> to convert to <code>String</code>. *
* @param radix the radix (base) to use in the conversion. * @return this Object's hash code
* @return the <code>String</code> representation of the argument.
*/ */
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; return (int) (value ^ (value >>> 32));
num = -(num); }
// When the value is MIN_VALUE, it overflows when made positive /**
if (num < 0) * Returns <code>true</code> if <code>obj</code> is an instance of
* <code>Long</code> and represents the same long value.
*
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{ {
buffer[--i] = Character.forDigit((int) (-(num + radix) % radix), return obj instanceof Long && value == ((Long) obj).value;
radix);
num = -(num / radix);
}
} }
else
isNeg = false;
do /**
* 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)
{ {
buffer[--i] = Character.forDigit((int) (num % radix), radix); return getLong(nm, null);
num /= radix;
} }
while (num > 0);
if (isNeg) /**
buffer[--i] = '-'; * Get the specified system property as a <code>Long</code>, or use a
* default <code>long</code> value if the property is not found or is not
return String.valueOf(buffer, i, 65-i); * decodable. The <code>decode()</code> method will be used to interpret
* the value of the property.
*
* @param nm the name of the system property
* @param val the default value
* @return the value of the system property, or the default
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Long getLong(String nm, long val)
{
Long result = getLong(nm, null);
return result == null ? new Long(val) : result;
} }
/** /**
* Creates a new <code>Long</code> object using the <code>String</code>, * Get the specified system property as a <code>Long</code>, or use a
* assuming a radix of 10. * default <code>Long</code> value if the property is not found or is
* @param s the <code>String</code> to convert. * not decodable. The <code>decode()</code> method will be used to
* @return the new <code>Long</code>. * interpret the value of the property.
* @see #Long(java.lang.String) *
* @see #parseLong(java.lang.String) * @param nm the name of the system property
* @exception NumberFormatException thrown if the <code>String</code> * @param val the default value
* cannot be parsed as a <code>long</code>. * @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 def)
{
if (nm == null || "".equals(nm))
return def;
nm = System.getProperty(nm);
if (nm == null)
return def;
try
{ {
return new Long(parseLong(s)); return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
} }
/** /**
* Creates a new <code>Long</code> object using the <code>String</code> * Compare two Longs numerically by comparing their <code>long</code>
* and specified radix (base). * values. The result is positive if the first is greater, negative if the
* @param s the <code>String</code> to convert. * second is greater, and 0 if the two are equal.
* @param radix the radix (base) to convert with. *
* @return the new <code>Long</code>. * @param l the Long to compare
* @see #parseLong(java.lang.String,int) * @return the comparison
* @exception NumberFormatException thrown if the <code>String</code> * @since 1.2
* cannot be parsed as a <code>long</code>.
*/ */
public static Long valueOf(String s, int radix) throws NumberFormatException public int compareTo(Long l)
{ {
return new Long(parseLong(s, radix)); if (value == l.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow the long.
return value > l.value ? 1 : -1;
} }
/** /**
* Converts the specified <code>String</code> into a <code>long</code>. * Behaves like <code>compareTo(Long)</code> unless the Object
* This function assumes a radix of 10. * is not a <code>Long</code>.
* *
* @param s the <code>String</code> to convert * @param o the object to compare
* @return the <code>long</code> value of the <code>String</code> * @return the comparison
* argument. * @throws ClassCastException if the argument is not a <code>Long</code>
* @exception NumberFormatException thrown if the <code>String</code> * @see #compareTo(Long)
* cannot be parsed as a <code>long</code>. * @see Comparable
* @since 1.2
*/ */
public static long parseLong(String s) throws NumberFormatException public int compareTo(Object o)
{ {
return parseLong(s, 10); return compareTo((Long) o);
} }
/** /**
* Converts the specified <code>String</code> into a <code>long</code> * Helper for converting unsigned numbers to String.
* using the specified radix (base).
* *
* @param s the <code>String</code> to convert * @param num the number
* @param radix the radix (base) to use in the conversion * @param exp log2(digit) (ie. 1, 3, or 4 for binary, oct, hex)
* @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>.
*/ */
public static long parseLong(String str, int radix) private static String toUnsignedString(long num, int exp)
throws NumberFormatException
{ {
final int len; // Use the Integer toUnsignedString for efficiency if possible.
// If NUM<0 then this particular optimization doesn't work
if ((len = str.length()) == 0 || radix < Character.MIN_RADIX // properly.
|| radix > Character.MAX_RADIX) if (num >= 0 && (int) num == num)
throw new NumberFormatException(); return Integer.toUnsignedString((int) num, exp);
boolean isNeg = false; // Use an array large enough for a binary number.
int index = 0; int mask = (1 << exp) - 1;
if (str.charAt(index) == '-') char[] buffer = new char[64];
if (len > 1) int i = 64;
do
{ {
isNeg = true; buffer[--i] = digits[(int) num & mask];
index++; num >>>= exp;
} }
else while (num != 0);
throw new NumberFormatException();
return parseLong(str, index, len, isNeg, radix); // Package constructor avoids an array copy.
return new String(buffer, i, 64 - i, true);
} }
public static Long decode(String str) throws NumberFormatException /**
* Helper for parsing longs.
*
* @param str the string to parse
* @param radix the radix to use, must be 10 if decode is true
* @param decode if called from decode
* @return the parsed long value
* @throws NumberFormatException if there is an error
* @throws NullPointerException if decode is true and str is null
* @see #parseLong(String, int)
* @see #decode(String)
*/
private static long parseLong(String str, int radix, boolean decode)
{ {
boolean isNeg = false; if (! decode && str == null)
throw new NumberFormatException();
int index = 0; int index = 0;
int radix = 10; int len = str.length();
final int len; boolean isNeg = false;
if (len == 0)
if ((len = str.length()) == 0)
throw new NumberFormatException(); throw new NumberFormatException();
int ch = str.charAt(index);
// Negative numbers are always radix 10. if (ch == '-')
if (str.charAt(0) == '-')
{ {
radix = 10; if (len == 1)
index++; throw new NumberFormatException();
isNeg = true; isNeg = true;
ch = str.charAt(++index);
} }
else if (str.charAt(index) == '#') if (decode)
{ {
radix = 16; if (ch == '0')
index++;
}
else if (str.charAt(index) == '0')
{ {
// Check if str is just "0" if (++index == len)
if (len == 1) return 0;
return new Long(0L); if ((str.charAt(index) & ~('x' ^ 'X')) == 'X')
index++;
if (str.charAt(index) == 'x')
{ {
radix = 16; radix = 16;
index++; index++;
...@@ -468,18 +583,14 @@ public final class Long extends Number implements Comparable ...@@ -468,18 +583,14 @@ public final class Long extends Number implements Comparable
else else
radix = 8; radix = 8;
} }
else if (ch == '#')
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; radix = 16;
int digval; index++;
}
}
if (index == len)
throw new NumberFormatException();
long max = MAX_VALUE / radix; long max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'. // We can't directly write `max = (MAX_VALUE + 1) / radix'.
...@@ -487,107 +598,17 @@ public final class Long extends Number implements Comparable ...@@ -487,107 +598,17 @@ public final class Long extends Number implements Comparable
if (isNeg && MAX_VALUE % radix == radix - 1) if (isNeg && MAX_VALUE % radix == radix - 1)
++max; ++max;
for ( ; index < len; index++) long val = 0;
while (index < len)
{ {
if (val < 0 || val > max) if (val < 0 || val > max)
throw new NumberFormatException(); throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0) ch = Character.digit(str.charAt(index++), radix);
throw new NumberFormatException(); val = val * radix + ch;
if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))
// 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(); throw new NumberFormatException();
} }
return isNeg ? -val : val;
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);
} }
} }
libjava/java/lang/Number.java
/* java.lang.Number /* Number.java =- abstract superclass of numeric objects
Copyright (C) 1998, 2001 Free Software Foundation, Inc. Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -41,54 +41,91 @@ package java.lang; ...@@ -41,54 +41,91 @@ package java.lang;
import java.io.Serializable; import java.io.Serializable;
/** /**
** Number is a generic superclass of all the numeric classes, namely * Number is a generic superclass of all the numeric classes, including
** <code>Byte</code>, <code>Short</code>, <code>Integer</code>, * the wrapper classes {@link Byte}, {@link Short}, {@link Integer},
** <code>Long</code>, <code>Float</code>, and <code>Double</code>. * {@link Long}, {@link Float}, and {@link Double}. Also worth mentioning
** * are the classes in {@link java.math}.
** It provides ways to convert from any one value to any other. *
** * It provides ways to convert numeric objects to any primitive.
** @author Paul Fisher *
** @author John Keiser * @author Paul Fisher
** @author Warren Levy * @author John Keiser
** @since JDK1.0 * @author Warren Levy
**/ * @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public abstract class Number implements Serializable 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>. * Compatible with JDK 1.1+.
**/ */
public byte byteValue() private static final long serialVersionUID = -8742448824652078965L;
{
return (byte) intValue();
}
/** 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>. * Table for calculating digits, used in Character, Long, and Integer.
**/ */
public short shortValue() 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(); 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(); 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(); 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(); 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();
}
} }
libjava/java/lang/String.java
/* 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. This file is part of libgcj.
...@@ -112,6 +112,12 @@ public final class String implements Serializable, Comparable, CharSequence ...@@ -112,6 +112,12 @@ public final class String implements Serializable, Comparable, CharSequence
init(data, offset, count, false); 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) public String (byte[] byteArray)
{ {
this (byteArray, 0, byteArray.length); this (byteArray, 0, byteArray.length);
......
libjava/java/lang/Void.java
/* java.lang.Void /* Void.class - defines void.class
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -38,19 +38,18 @@ exception statement from your version. */ ...@@ -38,19 +38,18 @@ exception statement from your version. */
package java.lang; 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 * Void is a placeholder class so that the variable <code>Void.TYPE</code>
* supported for reflection return types. * (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 Paul Fisher
* @author John Keiser * @author John Keiser
* @author Per Bothner <bothner@cygnus.com> * @author Eric Blake <ebb9@email.byu.edu>
* @since JDK1.1 * @since 1.1
* @status updated to 1.4
*/ */
public final class Void public final class Void
{ {
...@@ -61,7 +60,7 @@ public final class Void ...@@ -61,7 +60,7 @@ public final class Void
public static final Class TYPE = VMClassLoader.getPrimitiveClass('V'); public static final Class TYPE = VMClassLoader.getPrimitiveClass('V');
/** /**
* Don't allow Void objects to be made. * Void is non-instantiable.
*/ */
private Void() { } private Void() { }
} }
libjava/java/lang/natString.cc
...@@ -456,9 +456,8 @@ java::lang::String::init(jcharArray chars, jint offset, jint count, ...@@ -456,9 +456,8 @@ java::lang::String::init(jcharArray chars, jint offset, jint count,
} }
else else
{ {
JvAssert (offset == 0);
array = chars; array = chars;
pdst = elements (array); pdst = &(elements(array)[offset]);
} }
data = array; data = array;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment