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 1699 additions and 1548 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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -41,148 +41,184 @@ package java.lang; ...@@ -41,148 +41,184 @@ package java.lang;
import java.io.Serializable; import java.io.Serializable;
/** /**
* Instances of class <code>Boolean</code> represent primitive * Instances of class <code>Boolean</code> represent primitive
* <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+.
/** */
* This field is a <code>Boolean</code> object representing the private static final long serialVersionUID = -3665804199014368530L;
* primitive value <code>true</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return /**
* a <code>Boolean</code> representing <code>true</code>. * This field is a <code>Boolean</code> object representing the
*/ * primitive value <code>true</code>. This instance is returned
public static final Boolean TRUE = new Boolean(true); * by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>true</code>.
/** */
* This field is a <code>Boolean</code> object representing the public static final Boolean TRUE = new Boolean(true);
* primitive value <code>false</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return /**
* a <code>Boolean</code> representing <code>false</code>. * This field is a <code>Boolean</code> object representing the
*/ * primitive value <code>false</code>. This instance is returned
public static final Boolean FALSE = new Boolean(false); * by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>false</code>.
/** */
* The primitive type <code>boolean</code> is represented by this public static final Boolean FALSE = new Boolean(false);
* <code>Class</code> object.
*/ /**
public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z'); * The primitive type <code>boolean</code> is represented by this
* <code>Class</code> object.
/** *
* The immutable value of this Boolean. * @since 1.1
*/ */
private final boolean value; public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
/** /**
* Create a <code>Boolean</code> object representing the value of the * The immutable value of this Boolean.
* argument <code>value</code>. In general the use of the static * @serial the wrapped value
* method <code>valueof(boolean)</code> is more efficient since it will */
* not create a new object. private final boolean value;
*
* @param value the primitive value of this <code>Boolean</code> /**
*/ * Create a <code>Boolean</code> object representing the value of the
public Boolean(boolean value) { * argument <code>value</code>. In general the use of the static
this.value = value; * method <code>valueof(boolean)</code> is more efficient since it will
} * not create a new object.
*
/** * @param value the primitive value of this <code>Boolean</code>
* Creates a <code>Boolean</code> object representing the primitive * @see #valueOf(boolean)
* <code>true</code> if and only if <code>s</code> matches */
* the string "true" ignoring case, otherwise the object will represent public Boolean(boolean value)
* the primitive <code>false</code>. In general the use of the static {
* method <code>valueof(String)</code> is more efficient since it will this.value = value;
* not create a new object. }
*
* @param s the <code>String</code> representation of <code>true</code> /**
* or false * Creates a <code>Boolean</code> object representing the primitive
*/ * <code>true</code> if and only if <code>s</code> matches
public Boolean(String s) { * the string "true" ignoring case, otherwise the object will represent
value = "true".equalsIgnoreCase(s); * the primitive <code>false</code>. In general the use of the static
} * method <code>valueof(String)</code> is more efficient since it will
* not create a new object.
/** *
* Return the primitive <code>boolean</code> value of this * @param s the <code>String</code> representation of <code>true</code>
* <code>Boolean</code> object. * or false
*/ */
public boolean booleanValue() { public Boolean(String s)
return value; {
} value = "true".equalsIgnoreCase(s);
}
/**
* Returns the Boolean <code>TRUE</code> if the given boolean is /**
* <code>true</code>, otherwise it will return the Boolean * Return the primitive <code>boolean</code> value of this
* <code>FALSE</code>. * <code>Boolean</code> object.
* *
* @since 1.4 * @return true or false, depending on the value of this Boolean
*/ */
public static Boolean valueOf(boolean b) { public boolean booleanValue()
return b ? TRUE : FALSE; {
} return value;
}
/**
* Returns the Boolean <code>TRUE</code> if and only if the given /**
* String is equal, ignoring case, to the the String "true", otherwise * Returns the Boolean <code>TRUE</code> if the given boolean is
* it will return the Boolean <code>FALSE</code>. * <code>true</code>, otherwise it will return the Boolean
*/ * <code>FALSE</code>.
public static Boolean valueOf(String s) { *
return "true".equalsIgnoreCase(s) ? TRUE : FALSE; * @param b the boolean to wrap
} * @return the wrapper object
* @see #TRUE
/** * @see #FALSE
* Returns the integer <code>1231</code> if this object represents * @since 1.4
* the primitive <code>true</code> and the integer <code>1237</code> */
* otherwise. public static Boolean valueOf(boolean b)
*/ {
public int hashCode() { return b ? TRUE : FALSE;
return (value) ? 1231 : 1237; }
}
/**
/** * Returns the Boolean <code>TRUE</code> if and only if the given
* If the <code>obj</code> is an instance of <code>Boolean</code> and * String is equal, ignoring case, to the the String "true", otherwise
* has the same primitive value as this object then <code>true</code> * it will return the Boolean <code>FALSE</code>.
* is returned. In all other cases, including if the <code>obj</code> *
* is <code>null</code>, <code>false</code> is returned. * @param s the string to convert
* * @return a wrapped boolean from the string
* @param obj possibly an instance of any <code>Class</code> */
* @return <code>false</code> is <code>obj</code> is an instance of public static Boolean valueOf(String s)
* <code>Boolean</code> and has the same primitive value as this {
* object. return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
*/ }
public boolean equals(Object obj) {
return (obj instanceof Boolean && value == ((Boolean)obj).value); /**
} * 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>.
/** *
* If the value of the system property <code>name</code> matches * @param b the boolean to convert
* "true" ignoring case then the function returns <code>true</code>. * @return the string representation of the boolean
*/ * @since 1.4
public static boolean getBoolean(String name) { */
String val = System.getProperty(name); public static String toString(boolean b)
return ("true".equalsIgnoreCase(val)); {
} return b ? "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>. * 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>.
* @since 1.4 *
*/ * @return the string representation of this
public static String toString(boolean b) */
{ public String toString()
return b ? "true" : "false"; {
} return value ? "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>. * Returns the integer <code>1231</code> if this object represents
*/ * the primitive <code>true</code> and the integer <code>1237</code>
public String toString() * otherwise.
{ *
return (value) ? "true" : "false"; * @return the hash code
} */
public int hashCode()
{
return value ? 1231 : 1237;
}
/**
* If the <code>obj</code> is an instance of <code>Boolean</code> and
* has the same primitive value as this object then <code>true</code>
* is returned. In all other cases, including if the <code>obj</code>
* is <code>null</code>, <code>false</code> is returned.
*
* @param obj possibly an instance of any <code>Class</code>
* @return true if <code>obj</code> equals this
*/
public boolean equals(Object obj)
{
return obj instanceof Boolean && value == ((Boolean) obj).value;
}
/**
* If the value of the system property <code>name</code> matches
* "true" ignoring case then the function returns <code>true</code>.
*
* @param name the property name to look up
* @return true if the property resulted in "true"
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
*/
public static boolean getBoolean(String name)
{
if (name == null || "".equals(name))
return false;
return "true".equalsIgnoreCase(System.getProperty(name));
}
} }
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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -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,43 +67,50 @@ public final class Double extends Number implements Comparable ...@@ -72,43 +67,50 @@ 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.
*/ */
static static
{ {
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.
*
* *
* @XXX specify where we are not in accord with the spec. * <p>Note that <code>d1.equals(d2)<code> is identical to
* <code>doubleToLongBits(d1.doubleValue()) ==
* doubleToLongBits(d2.doubleValue())<code>.
* *
* @param d the <code>double</code> to convert * @param obj the object to compare
* @return the <code>String</code> representing the <code>double</code>. * @return whether the objects are semantically equal
*/ */
public static String toString (double d) public boolean equals(Object obj)
{ {
return toString (d, false); if (! (obj instanceof Double))
} return false;
static native String toString (double d, boolean isFloat); double d = ((Double) obj).value;
// Avoid call to native method. However, some implementations, like gcj,
// are better off using floatToIntBits(value) == floatToIntBits(f).
// Check common case first, then check NaN and 0.
if (value == d)
return (value != 0) || (1 / value == 1 / d);
return isNaN(value) && isNaN(d);
}
/** /**
* Return the long bits of the specified <code>double</code>. * 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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -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 * @return the int value
* 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 <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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -48,36 +48,45 @@ package java.lang; ...@@ -48,36 +48,45 @@ 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;
/** /**
* Create an <code>Integer</code> object representing the value of the * Create an <code>Integer</code> object representing the value of the
* <code>int</code> argument. * <code>int</code> argument.
* *
* @param value the value to use * @param value the value to use
...@@ -88,135 +97,73 @@ public final class Integer extends Number implements Comparable ...@@ -88,135 +97,73 @@ 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
* @see #valueOf(String)
*/ */
public Integer(String s) throws NumberFormatException public Integer(String s)
{ {
value = parseInt(s, 10); value = parseInt(s, 10, false);
} }
/** /**
* Return a hashcode representing this Object. * Converts the <code>int</code> to a <code>String</code> using
* * the specified radix (base). If the radix exceeds
* <code>Integer</code>'s hash code is calculated by simply returning its * <code>Character.MIN_RADIX</code> or <code>Character.MAX_RADIX</code>, 10
* value. * is used instead. If the result is negative, the leading character is
* * '-' ('\\u002D'). The remaining characters come from
* @return this Object's hash code. * <code>Character.forDigit(digit, radix)</code> ('0'-'9','a'-'z').
*/
public int hashCode()
{
return value;
}
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Integer</code>, and represents
* the same primitive <code>int</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
*/
public boolean equals(Object obj)
{
return obj instanceof Integer && value == ((Integer)obj).value;
}
/**
* Get the specified system property as an <code>Integer</code>.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
* @param nm the name of the system property
* @return the system property as an <code>Integer</code>, or
* <code>null</code> if the property is not found or cannot be
* decoded as an <code>Integer</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see #decode(int)
*/
public static Integer getInteger(String nm)
{
return getInteger(nm, null);
}
/**
* Get the specified system property as an <code>Integer</code>, or use a
* default <code>int</code> value if the property is not found or is not
* decodable.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
* *
* @param nm the name of the system property * @param num the <code>int</code> to convert to <code>String</code>
* @param val the default value to use if the property is not found or not * @param radix the radix (base) to use in the conversion
* a number. * @return the <code>String</code> representation of the argument
* @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) public static String toString(int num, int radix)
{ {
Integer result = getInteger(nm, null); if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
return (result == null) ? new Integer(val) : result; 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>Integer</code> value if the property is not found or is char[] buffer = new char[33];
* not 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,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; isNeg = true;
num = -num;
// When the value is MIN_VALUE, it overflows when made positive
if (num < 0)
{
buffer[--i] = digits[(int) (-(num + radix) % radix)];
num = -(num / radix);
}
} }
}
private static String toUnsignedString(int num, int exp)
{
// Use an array large enough for a binary number.
int radix = 1 << exp;
int mask = radix - 1;
char[] buffer = new char[32];
int i = 32;
do 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
public String toString() * <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
return toString (value); * 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
* Converts the <code>int</code> to a <code>String</code> using * @param radix the radix (base) to use in the conversion
* the specified radix (base). * @return the <code>String</code> argument converted to </code>int</code>
* @param i the <code>int</code> to convert to <code>String</code>. * @throws NumberFormatException if <code>s</code> cannot be parsed as an
* @param radix the radix (base) to use in the conversion. * <code>int</code>
* @return the <code>String</code> representation of the argument.
*/ */
public static String toString(int num, int radix) public static int parseInt(String str, int radix)
{ {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) return parseInt(str, radix, false);
radix = 10;
// For negative numbers, print out the absolute value w/ a leading '-'.
// Use an array large enough for a binary number.
char[] buffer = new char[33];
int i = 33;
boolean isNeg;
if (num < 0)
{
isNeg = true;
num = -(num);
// When the value is MIN_VALUE, it overflows when made positive
if (num < 0)
{
buffer[--i] = Character.forDigit(-(num + radix) % radix, radix);
num = -(num / radix);
}
}
else
isNeg = false;
do
{
buffer[--i] = Character.forDigit(num % radix, radix);
num /= radix;
}
while (num > 0);
if (isNeg)
buffer[--i] = '-';
return String.valueOf(buffer, i, 33-i);
} }
/** /**
* Creates a new <code>Integer</code> object using the <code>String</code>, * Converts the specified <code>String</code> into an <code>int</code>.
* assuming a radix of 10. * This function assumes 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 <code>int</code> value of <code>s</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 #parseInt(String, int)
*/ */
public static Integer valueOf(String s) throws NumberFormatException public static int parseInt(String s)
{ {
return new Integer(parseInt(s)); return parseInt(s, 10, false);
} }
/** /**
* Creates a new <code>Integer</code> object using the <code>String</code> * Creates a new <code>Integer</code> object using the <code>String</code>
* and specified radix (base). * and specified radix (base).
* @param s the <code>String</code> to convert. *
* @param radix the radix (base) to convert with. * @param s the <code>String</code> to convert
* @return the new <code>Integer</code>. * @param radix the radix (base) to convert with
* @see #parseInt(java.lang.String,int) * @return the new <code>Integer</code>
* @exception NumberFormatException thrown if the <code>String</code> * @throws NumberFormatException if <code>s</code> cannot be parsed as an
* cannot be parsed as an <code>int</code>. * <code>int</code>
* @see #parseInt(String, int)
*/ */
public static Integer valueOf(String s, int radix) public static Integer valueOf(String s, int radix)
throws NumberFormatException
{ {
return new Integer(parseInt(s, radix)); return new Integer(parseInt(s, radix, false));
} }
/** /**
* Converts the specified <code>String</code> into an <code>int</code>. * Creates a new <code>Integer</code> object using the <code>String</code>,
* This function assumes a radix of 10. * assuming a radix of 10.
* *
* @param s the <code>String</code> to convert * @param s the <code>String</code> to convert
* @return the <code>int</code> value of the <code>String</code> * @return the new <code>Integer</code>
* argument. * @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 int parseInt(String s) throws NumberFormatException public static Integer valueOf(String s)
{ {
return parseInt(s, 10); return new Integer(parseInt(s, 10, false));
} }
/** /**
* Converts the specified <code>String</code> into an <code>int</code> * Return the value of this <code>Integer</code> as a <code>byte</code>.
* using the specified radix (base).
* *
* @param s the <code>String</code> to convert * @return the byte value
* @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 byte byteValue()
throws NumberFormatException
{ {
final int len; return (byte) value;
if (str == null)
throw new NumberFormatException ();
if ((len = str.length()) == 0 ||
radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
throw new NumberFormatException();
boolean isNeg = false;
int index = 0;
if (str.charAt(index) == '-')
if (len > 1)
{
isNeg = true;
index++;
}
else
throw new NumberFormatException();
return parseInt(str, index, len, isNeg, radix);
} }
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>short</code>.
throws NumberFormatException *
* @return the short value
*/
public short shortValue()
{ {
int val = 0; return (short) value;
int digval; }
int max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
}
return isNeg ? -(val) : val; /**
* Return the value of this <code>Integer</code>.
* @return the int value
*/
public int intValue()
{
return value;
} }
/** /**
* Convert the specified <code>String</code> into an <code>Integer</code>. * Return the value of this <code>Integer</code> as a <code>long</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> * @return the long value
* <tr><th>Leading<br>Characters</th><th>Base</th></tr>
* <tr><td>#</td><td>16</td></tr>
* <tr><td>0x</td><td>16</td></tr>
* <tr><td>0X</td><td>16</td></tr>
* <tr><td>0</td><td>8</td></tr>
* <tr><td>Anything<br>Else</td><td>10</td></tr>
* </table>
*
* @param str the <code>String</code> to interpret.
* @return the value of the String as an <code>Integer</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
*/ */
public static Integer decode(String str) throws NumberFormatException public long longValue()
{ {
boolean isNeg = false; return value;
int index = 0; }
int radix = 10;
final int len;
if (str == null || (len = str.length()) == 0)
throw new NumberFormatException("string null or empty");
// Negative numbers are always radix 10.
if (str.charAt(index) == '-')
{
radix = 10;
index++;
isNeg = true;
}
else if (str.charAt(index) == '#')
{
radix = 16;
index++;
}
else if (str.charAt(index) == '0')
{
// Check if str is just "0"
if (len == 1)
return new Integer(0);
index++; /**
if (str.charAt(index) == 'x' || str.charAt(index) == 'X') * Return the value of this <code>Integer</code> as a <code>float</code>.
{ *
radix = 16; * @return the float value
index++; */
} public float floatValue()
else {
radix = 8; return value;
} }
if (index >= len) /**
throw new NumberFormatException("empty value"); * Return the value of this <code>Integer</code> as a <code>double</code>.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
return new Integer(parseInt(str, index, len, isNeg, radix)); /**
* Converts the <code>Integer</code> value to a <code>String</code> and
* assumes a radix of 10.
*
* @return the <code>String</code> representation
*/
public String toString()
{
return String.valueOf(value);
} }
/** Return the value of this <code>Integer</code> as a <code>byte</code>. /**
** @return the value of this <code>Integer</code> as a <code>byte</code>. * Return a hashcode representing this Object. <code>Integer</code>'s hash
**/ * code is simply its value.
public byte byteValue() *
* @return this Object's hash code
*/
public int hashCode()
{ {
return (byte) value; return value;
} }
/** Return the value of this <code>Integer</code> as a <code>short</code>. /**
** @return the value of this <code>Integer</code> as a <code>short</code>. * Returns <code>true</code> if <code>obj</code> is an instance of
**/ * <code>Integer</code> and represents the same int value.
public short shortValue() *
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{ {
return (short) value; return obj instanceof Integer && value == ((Integer) obj).value;
} }
/** Return the value of this <code>Integer</code> as an <code>int</code>. /**
** @return the value of this <code>Integer</code> as an <code>int</code>. * Get the specified system property as an <code>Integer</code>. The
**/ * <code>decode()</code> method will be used to interpret the value of
public int intValue() * the property.
*
* @param nm the name of the system property
* @return the system property as an <code>Integer</code>, or null if the
* property is not found or cannot be decoded
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Integer getInteger(String nm)
{ {
return value; return getInteger(nm, null);
} }
/** Return the value of this <code>Integer</code> as a <code>long</code>. /**
** @return the value of this <code>Integer</code> as a <code>long</code>. * 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 long longValue() * decodable. The <code>decode()</code> method will be used to interpret
* the value of the property.
*
* @param nm the name of the system property
* @param val the default value
* @return the value of the system property, or the default
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Integer getInteger(String nm, int val)
{ {
return value; Integer result = getInteger(nm, null);
return result == null ? new Integer(val) : result;
} }
/** Return the value of this <code>Integer</code> as a <code>float</code>. /**
** @return the value of this <code>Integer</code> as a <code>float</code>. * 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 float floatValue() * not decodable. The <code>decode()</code> method will be used to
* interpret the value of the property.
*
* @param nm the name of the system property
* @param val the default value
* @return the value of the system property, or the default
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Integer getInteger(String nm, Integer def)
{ {
return value; if (nm == null || "".equals(nm))
return def;
nm = System.getProperty(nm);
if (nm == null)
return def;
try
{
return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
} }
/** Return the value of this <code>Integer</code> as a <code>double</code>. /**
** @return the value of this <code>Integer</code> as a <code>double</code>. * 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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -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,38 +48,45 @@ package java.lang; ...@@ -48,38 +48,45 @@ 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;
/** /**
* Create a <code>Long</code> object representing the value of the * Create a <code>Long</code> object representing the value of the
* <code>long</code> argument. * <code>long</code> argument.
* *
* @param value the value to use * @param value the value to use
...@@ -90,504 +97,518 @@ public final class Long extends Number implements Comparable ...@@ -90,504 +97,518 @@ 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)
{ {
return obj instanceof Long && ((Long)obj).value == value; // Use the Integer toString for efficiency if possible.
if ((int) num == num)
return Integer.toString((int) num, radix);
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
// For negative numbers, print out the absolute value w/ a leading '-'.
// Use an array large enough for a binary number.
char[] buffer = new char[65];
int i = 65;
boolean isNeg = false;
if (num < 0)
{
isNeg = true;
num = -num;
// When the value is MIN_VALUE, it overflows when made positive
if (num < 0)
{
buffer[--i] = digits[(int) (-(num + radix) % radix)];
num = -(num / radix);
}
}
do
{
buffer[--i] = digits[(int) (num % radix)];
num /= radix;
}
while (num > 0);
if (isNeg)
buffer[--i] = '-';
// Package constructor avoids an array copy.
return new String(buffer, i, 65 - i, true);
} }
/** /**
* Return a hashcode representing this Object. * Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 16.
* *
* <code>Long</code>'s hash code is calculated by simply returning its * @param l the <code>long</code> to convert to <code>String</code>
* value. * @return the <code>String</code> representation of the argument
*/
public static String toHexString(long l)
{
return toUnsignedString(l, 4);
}
/**
* Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 8.
* *
* @return this Object's hash code. * @param l the <code>long</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument
*/ */
public int hashCode() public static String toOctalString(long l)
{ {
return (int)(value^(value>>>32)); return toUnsignedString(l, 3);
} }
/** /**
* Get the specified system property as a <code>Long</code>. * Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 2.
* *
* A method similar to <code>Integer</code>'s <code>decode()</code> will be * @param l the <code>long</code> to convert to <code>String</code>
* used to interpret the value of the property. * @return the <code>String</code> representation of the argument
*
* @param nm the name of the system property
* @return the system property as an <code>Long</code>, or
* <code>null</code> if the property is not found or cannot be
* decoded as a <code>Long</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.Integer#decode(int)
*/ */
public static Long getLong(String nm) public static String toBinaryString(long l)
{ {
return getLong(nm, null); return toUnsignedString(l, 1);
} }
/** /**
* Get the specified system property as an <code>Long</code>, or use a * 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 not * a radix of 10.
* decodable. *
* * @param num the <code>long</code> to convert to <code>String</code>
* A method similar to <code>Integer</code>'s <code>decode()</code> will be * @return the <code>String</code> representation of the argument
* used to interpret the value of the property. * @see #toString(long, int)
*
* @param nm the name of the system property
* @param val the default value to use if the property is not found or not
* a number.
* @return the system property as a <code>Long</code>, or the default
* value if the property is not found or cannot be decoded as a
* <code>Long</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.Integer#decode(int)
* @see #getLong(java.lang.String,java.lang.Long)
*/ */
public static Long getLong(String nm, long val) public static String toString(long num)
{ {
Long result = getLong(nm, null); return toString(num, 10);
return (result == null) ? new Long(val) : result;
} }
/** /**
* Get the specified system property as an <code>Long</code>, or use a * Converts the specified <code>String</code> into an <code>int</code>
* default <code>Long</code> value if the property is not found or is * using the specified radix (base). The string must not be <code>null</code>
* not decodable. * 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
* The <code>decode()</code> method will be used to interpret the value of * <code>Character.digit(d, radix)</code>, and must be in the range
* the property. * <code>0</code> to <code>radix - 1</code>. Finally, the result must be
* within <code>MIN_VALUE</code> to <code>MAX_VALUE</code>, inclusive.
* Unlike Double.parseDouble, you may not have a leading '+'; and 'l' or
* 'L' as the last character is only valid in radices 22 or greater, where
* it is a digit and not a type indicator.
* *
* @param nm the name of the system property * @param s the <code>String</code> to convert
* @param val the default value to use if the property is not found or not * @param radix the radix (base) to use in the conversion
* a number. * @return the <code>String</code> argument converted to </code>long</code>
* @return the system property as an <code>Long</code>, or the default * @throws NumberFormatException if <code>s</code> cannot be parsed as a
* value if the property is not found or cannot be decoded as an * <code>long</code>
* <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 long parseLong(String str, int radix)
{ {
String val = System.getProperty(nm); return parseLong(str, radix, false);
if (val == null)
return def;
try
{
return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
} }
private static String toUnsignedString(long num, int exp) /**
* Converts the specified <code>String</code> into a <code>long</code>.
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>int</code> value of <code>s</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>long</code>
* @see #parseLong(String, int)
*/
public static long parseLong(String s)
{ {
// Use an array large enough for a binary number. return parseLong(s, 10, false);
int radix = 1 << exp; }
int mask = radix - 1;
char[] buffer = new char[64];
int i = 64;
do
{
buffer[--i] = Character.forDigit((int) num & mask, radix);
num = num >>> exp;
}
while (num != 0);
return 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 short shortValue()
public static String toString(long num)
{ {
// 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); return (int) value;
if (num < 0) }
{
// Must be MIN_VALUE, so handle this special case.
buffer[--i] = '8';
num = 922337203685477580L;
}
}
else
isNeg = false;
do /**
{ * Return the value of this <code>Long</code>.
buffer[--i] = (char) ((int) '0' + (num % 10)); *
num /= 10; * @return the long value
} */
while (num > 0); public long longValue()
{
return value;
}
if (isNeg) /**
buffer[--i] = '-'; * Return the value of this <code>Long</code> as a <code>float</code>.
*
* @return the float value
*/
public float floatValue()
{
return value;
}
return String.valueOf(buffer, i, 20-i); /**
* Return the value of this <code>Long</code> as a <code>double</code>.
*
* @return the double value
*/
public double doubleValue()
{
return value;
} }
/** /**
* Converts the <code>Long</code> value to a <code>String</code> and * 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. return (int) (value ^ (value >>> 32));
if (radix == 10 || }
radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
return toString(num);
// Use the Integer toString for efficiency if possible.
if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE)
return Integer.toString((int) num, radix);
// For negative numbers, print out the absolute value w/ a leading '-'.
// Use an array large enough for a binary number.
char[] buffer = new char[65];
int i = 65;
boolean isNeg;
if (num < 0)
{
isNeg = true;
num = -(num);
// When the value is MIN_VALUE, it overflows when made positive
if (num < 0)
{
buffer[--i] = Character.forDigit((int) (-(num + radix) % radix),
radix);
num = -(num / radix);
}
}
else
isNeg = false;
do /**
{ * Returns <code>true</code> if <code>obj</code> is an instance of
buffer[--i] = Character.forDigit((int) (num % radix), radix); * <code>Long</code> and represents the same long value.
num /= radix; *
} * @param obj the object to compare
while (num > 0); * @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{
return obj instanceof Long && value == ((Long) obj).value;
}
if (isNeg) /**
buffer[--i] = '-'; * Get the specified system property as a <code>Long</code>. The
* <code>decode()</code> method will be used to interpret the value of
* the property.
*
* @param nm the name of the system property
* @return the system property as a <code>Long</code>, or null if the
* property is not found or cannot be decoded
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Long getLong(String nm)
{
return getLong(nm, null);
}
return String.valueOf(buffer, i, 65-i); /**
* Get the specified system property as a <code>Long</code>, or use a
* default <code>long</code> value if the property is not found or is not
* decodable. The <code>decode()</code> method will be used to interpret
* the value of the property.
*
* @param nm the name of the system property
* @param val the default value
* @return the value of the system property, or the default
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Long getLong(String nm, long val)
{
Long result = getLong(nm, null);
return result == null ? new Long(val) : result;
} }
/** /**
* Creates a new <code>Long</code> object using the <code>String</code>, * 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
public static Long valueOf(String s) throws NumberFormatException * @see System#getProperty(String)
* @see #decode(String)
*/
public static Long getLong(String nm, Long def)
{ {
return new Long(parseLong(s)); if (nm == null || "".equals(nm))
return def;
nm = System.getProperty(nm);
if (nm == null)
return def;
try
{
return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
} }
/** /**
* Creates a new <code>Long</code> object using the <code>String</code> * 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 int compareTo(Long l)
public static Long valueOf(String s, int radix) throws NumberFormatException
{ {
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
// properly.
if (num >= 0 && (int) num == num)
return Integer.toUnsignedString((int) num, exp);
if ((len = str.length()) == 0 || radix < Character.MIN_RADIX // Use an array large enough for a binary number.
|| radix > Character.MAX_RADIX) int mask = (1 << exp) - 1;
throw new NumberFormatException(); char[] buffer = new char[64];
int i = 64;
do
{
buffer[--i] = digits[(int) num & mask];
num >>>= exp;
}
while (num != 0);
boolean isNeg = false; // Package constructor avoids an array copy.
int index = 0; return new String(buffer, i, 64 - i, true);
if (str.charAt(index) == '-')
if (len > 1)
{
isNeg = true;
index++;
}
else
throw new NumberFormatException();
return parseLong(str, index, len, isNeg, radix);
} }
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;
index++;
}
else if (str.charAt(index) == '0')
{ {
// Check if str is just "0" if (ch == '0')
if (len == 1) {
return new Long(0L); if (++index == len)
return 0;
index++; if ((str.charAt(index) & ~('x' ^ 'X')) == 'X')
if (str.charAt(index) == 'x') {
radix = 16;
index++;
}
else
radix = 8;
}
else if (ch == '#')
{ {
radix = 16; radix = 16;
index++; index++;
} }
else
radix = 8;
} }
if (index == len)
if (index >= len)
throw new NumberFormatException(); throw new NumberFormatException();
return new Long(parseLong(str, index, len, isNeg, radix));
}
private static long parseLong(String str, int index, int len, boolean isNeg,
int radix) throws NumberFormatException
{
long val = 0;
int digval;
long max = MAX_VALUE / radix; 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'.
// So instead we fake it. // So instead we fake it.
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);
val = val * radix + ch;
if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))
throw new NumberFormatException(); throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
} }
return isNeg ? -val : val;
return 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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -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.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -38,30 +38,29 @@ exception statement from your version. */ ...@@ -38,30 +38,29 @@ 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
{ {
/** /**
* The return type <code>void</code> is represented by this * The return type <code>void</code> is represented by this
* <code>Class</code> object. * <code>Class</code> object.
*/ */
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