procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
* 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
This commit is contained in:
Tom Tromey 2002-06-13 18:16:26 +00:00 • committed by Tom Tromey
parent a8fa30f301
commit 93f7aeea7a
10 changed files with 1874 additions and 1723 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
libjava/ChangeLog
View file

@ -1,3 +1,18 @@
2002-06-13 Tom Tromey <tromey@redhat.com>
* java/lang/natString.cc (init): Handle case where DONT_COPY is
true and OFFSET!=0.
* java/lang/String.java (String(char[],int,int,boolean): New
constructor.
* java/lang/Long.java: Imported new version from Classpath.
* java/lang/Number.java: Likewise.
* java/lang/Integer.java: Likewise.
* java/lang/Long.java: Likewise.
* java/lang/Float.java: Likewise.
* java/lang/Boolean.java: Likewise.
* java/lang/Double.java: Likewise.
* java/lang/Void.java: Likewise.
2002-06-12 Tom Tromey <tromey@redhat.com>
* java/io/natFilePosix.cc (getCanonicalPath): Treat "" like ".".

302
libjava/java/lang/Boolean.java
View file

@ -1,5 +1,5 @@
/* Boolean.java -- object wrapper for boolean
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -41,148 +41,184 @@ package java.lang;
import java.io.Serializable;
/**
* Instances of class <code>Boolean</code> represent primitive
* Instances of class <code>Boolean</code> represent primitive
* <code>boolean</code> values.
*
* @author Paul Fisher
* @since JDK1.0
*/
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public final class Boolean implements Serializable
{
static final long serialVersionUID = -3665804199014368530L;
/**
* This field is a <code>Boolean</code> object representing the
* primitive value <code>true</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>true</code>.
*/
public static final Boolean TRUE = new Boolean(true);
/**
* This field is a <code>Boolean</code> object representing the
* primitive value <code>false</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>false</code>.
*/
public static final Boolean FALSE = new Boolean(false);
/**
* Compatible with JDK 1.0.2+.
*/
private static final long serialVersionUID = -3665804199014368530L;
/**
* The primitive type <code>boolean</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
/**
* The immutable value of this Boolean.
*/
private final boolean value;
/**
* Create a <code>Boolean</code> object representing the value of the
* argument <code>value</code>. In general the use of the static
* method <code>valueof(boolean)</code> is more efficient since it will
* not create a new object.
*
* @param value the primitive value of this <code>Boolean</code>
*/
public Boolean(boolean value) {
this.value = value;
}
/**
* Creates a <code>Boolean</code> object representing the primitive
* <code>true</code> if and only if <code>s</code> matches
* the string "true" ignoring case, otherwise the object will represent
* the primitive <code>false</code>. In general the use of the static
* method <code>valueof(String)</code> is more efficient since it will
* not create a new object.
*
* @param s the <code>String</code> representation of <code>true</code>
* or false
*/
public Boolean(String s) {
value = "true".equalsIgnoreCase(s);
}
/**
* This field is a <code>Boolean</code> object representing the
* primitive value <code>true</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>true</code>.
*/
public static final Boolean TRUE = new Boolean(true);
/**
* Return the primitive <code>boolean</code> value of this
* <code>Boolean</code> object.
*/
public boolean booleanValue() {
return value;
}
/**
* This field is a <code>Boolean</code> object representing the
* primitive value <code>false</code>. This instance is returned
* by the static <code>valueOf()</code> methods if they return
* a <code>Boolean</code> representing <code>false</code>.
*/
public static final Boolean FALSE = new Boolean(false);
/**
* Returns the Boolean <code>TRUE</code> if the given boolean is
* <code>true</code>, otherwise it will return the Boolean
* <code>FALSE</code>.
*
* @since 1.4
*/
public static Boolean valueOf(boolean b) {
return b ? TRUE : FALSE;
}
/**
* The primitive type <code>boolean</code> is represented by this
* <code>Class</code> object.
*
* @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('Z');
/**
* Returns the Boolean <code>TRUE</code> if and only if the given
* String is equal, ignoring case, to the the String "true", otherwise
* it will return the Boolean <code>FALSE</code>.
*/
public static Boolean valueOf(String s) {
return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
}
/**
* The immutable value of this Boolean.
* @serial the wrapped value
*/
private final boolean value;
/**
* Returns the integer <code>1231</code> if this object represents
* the primitive <code>true</code> and the integer <code>1237</code>
* otherwise.
*/
public int hashCode() {
return (value) ? 1231 : 1237;
}
/**
* Create a <code>Boolean</code> object representing the value of the
* argument <code>value</code>. In general the use of the static
* method <code>valueof(boolean)</code> is more efficient since it will
* not create a new object.
*
* @param value the primitive value of this <code>Boolean</code>
* @see #valueOf(boolean)
*/
public Boolean(boolean value)
{
this.value = value;
}
/**
* If the <code>obj</code> is an instance of <code>Boolean</code> and
* has the same primitive value as this object then <code>true</code>
* is returned. In all other cases, including if the <code>obj</code>
* is <code>null</code>, <code>false</code> is returned.
*
* @param obj possibly an instance of any <code>Class</code>
* @return <code>false</code> is <code>obj</code> is an instance of
* <code>Boolean</code> and has the same primitive value as this
* object.
*/
public boolean equals(Object obj) {
return (obj instanceof Boolean && value == ((Boolean)obj).value);
}
/**
* Creates a <code>Boolean</code> object representing the primitive
* <code>true</code> if and only if <code>s</code> matches
* the string "true" ignoring case, otherwise the object will represent
* the primitive <code>false</code>. In general the use of the static
* method <code>valueof(String)</code> is more efficient since it will
* not create a new object.
*
* @param s the <code>String</code> representation of <code>true</code>
* or false
*/
public Boolean(String s)
{
value = "true".equalsIgnoreCase(s);
}
/**
* If the value of the system property <code>name</code> matches
* "true" ignoring case then the function returns <code>true</code>.
*/
public static boolean getBoolean(String name) {
String val = System.getProperty(name);
return ("true".equalsIgnoreCase(val));
}
/**
* Returns "true" if the value of the give boolean is <code>true</code> and
* returns "false" if the value of the given boolean is <code>false</code>.
*
* @since 1.4
*/
public static String toString(boolean b)
{
return b ? "true" : "false";
}
/**
* Return the primitive <code>boolean</code> value of this
* <code>Boolean</code> object.
*
* @return true or false, depending on the value of this Boolean
*/
public boolean booleanValue()
{
return value;
}
/**
* Returns "true" if the value of this object is <code>true</code> and
* returns "false" if the value of this object is <code>false</code>.
*/
public String toString()
{
return (value) ? "true" : "false";
}
/**
* Returns the Boolean <code>TRUE</code> if the given boolean is
* <code>true</code>, otherwise it will return the Boolean
* <code>FALSE</code>.
*
* @param b the boolean to wrap
* @return the wrapper object
* @see #TRUE
* @see #FALSE
* @since 1.4
*/
public static Boolean valueOf(boolean b)
{
return b ? TRUE : FALSE;
}
/**
* Returns the Boolean <code>TRUE</code> if and only if the given
* String is equal, ignoring case, to the the String "true", otherwise
* it will return the Boolean <code>FALSE</code>.
*
* @param s the string to convert
* @return a wrapped boolean from the string
*/
public static Boolean valueOf(String s)
{
return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
}
/**
* Returns "true" if the value of the give boolean is <code>true</code> and
* returns "false" if the value of the given boolean is <code>false</code>.
*
* @param b the boolean to convert
* @return the string representation of the boolean
* @since 1.4
*/
public static String toString(boolean b)
{
return b ? "true" : "false";
}
/**
* Returns "true" if the value of this object is <code>true</code> and
* returns "false" if the value of this object is <code>false</code>.
*
* @return the string representation of this
*/
public String toString()
{
return value ? "true" : "false";
}
/**
* Returns the integer <code>1231</code> if this object represents
* the primitive <code>true</code> and the integer <code>1237</code>
* otherwise.
*
* @return the hash code
*/
public int hashCode()
{
return value ? 1231 : 1237;
}
/**
* If the <code>obj</code> is an instance of <code>Boolean</code> and
* has the same primitive value as this object then <code>true</code>
* is returned. In all other cases, including if the <code>obj</code>
* is <code>null</code>, <code>false</code> is returned.
*
* @param obj possibly an instance of any <code>Class</code>
* @return true if <code>obj</code> equals this
*/
public boolean equals(Object obj)
{
return obj instanceof Boolean && value == ((Boolean) obj).value;
}
/**
* If the value of the system property <code>name</code> matches
* "true" ignoring case then the function returns <code>true</code>.
*
* @param name the property name to look up
* @return true if the property resulted in "true"
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
*/
public static boolean getBoolean(String name)
{
if (name == null || "".equals(name))
return false;
return "true".equalsIgnoreCase(System.getProperty(name));
}
}

716
libjava/java/lang/Double.java
View file

@ -1,4 +1,4 @@
/* Double.java -- object wrapper for double primitive
/* Double.java -- object wrapper for double
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -40,12 +40,6 @@ package java.lang;
import gnu.classpath.Configuration;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
/**
* Instances of class <code>Double</code> represent primitive
* <code>double</code> values.
@ -55,15 +49,16 @@ import gnu.classpath.Configuration;
*
* @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com>
* @since JDK 1.0
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public final class Double extends Number implements Comparable
{
/**
* The minimum positive value a <code>double</code> may represent
* is 5e-324.
* Compatible with JDK 1.0+.
*/
public static final double MIN_VALUE = 5e-324;
private static final long serialVersionUID = -9172774392245257468L;
/**
* The maximum positive value a <code>double</code> may represent
@ -72,43 +67,50 @@ public final class Double extends Number implements Comparable
public static final double MAX_VALUE = 1.7976931348623157e+308;
/**
* The value of a double representation -1.0/0.0, negative
* infinity.
* The minimum positive value a <code>double</code> may represent
* is 5e-324.
*/
public static final double NEGATIVE_INFINITY = -1.0d/0.0d;
public static final double MIN_VALUE = 5e-324;
/**
* The value of a double representation -1.0/0.0, negative
* infinity.
*/
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
/**
* The value of a double representing 1.0/0.0, positive infinity.
*/
public static final double POSITIVE_INFINITY = 1.0d/0.0d;
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
/**
* All IEEE 754 values of NaN have the same value in Java.
*/
public static final double NaN = 0.0d/0.0d;
public static final double NaN = 0.0 / 0.0;
/**
* The primitive type <code>double</code> is represented by this
* <code>Class</code> object.
* @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('D');
/**
* The immutable value of this Double.
*
* @serial the wrapped double
*/
private final double value;
private static final long serialVersionUID = -9172774392245257468L;
/**
* Load native routines necessary for this class.
* Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javalang");
initIDs ();
System.loadLibrary("javalang");
initIDs();
}
}
@ -118,149 +120,134 @@ public final class Double extends Number implements Comparable
*
* @param value the <code>double</code> argument
*/
public Double (double value)
public Double(double value)
{
this.value = value;
}
/**
* Create a <code>Double</code> from the specified
* <code>String</code>.
*
* Create a <code>Double</code> from the specified <code>String</code>.
* This method calls <code>Double.parseDouble()</code>.
*
* @exception NumberFormatException when the <code>String</code> cannot
* be parsed into a <code>Float</code>.
* @param s the <code>String</code> to convert
* @see #parseDouble(java.lang.String)
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>double</code>
* @throws NullPointerException if <code>s</code> is null
* @see #parseDouble(String)
*/
public Double (String s) throws NumberFormatException
public Double(String s)
{
value = parseDouble (s);
value = parseDouble(s);
}
/**
* Convert the <code>double</code> value of this <code>Double</code>
* to a <code>String</code>. This method calls
* <code>Double.toString(double)</code> to do its dirty work.
* Convert the <code>double</code> to a <code>String</code>.
* Floating-point string representation is fairly complex: here is a
* rundown of the possible values. "<code>[-]</code>" indicates that a
* negative sign will be printed if the value (or exponent) is negative.
* "<code>&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>.
* @see #toString(double)
*/
public String toString ()
{
return toString (value);
}
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Double</code>, and represents
* the same primitive <code>double</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
* <p>
* Note that there are two differences between <code>==</code> and
* <code>equals()</code>. <code>0.0d == -0.0d</code> returns <code>true</code>
* but <code>new Double(0.0d).equals(new Double(-0.0d))</code> returns
* <code>false</code>. And <code>Double.NaN == Double.NaN</code> returns
* <code>false</code>, but
* <code>new Double(Double.NaN).equals(new Double(Double.NaN))</code> returns
* <code>true</code>.
* <table border=1>
* <tr><th>Value of Double</th><th>String Representation</th></tr>
* <tr><td>[+-] 0</td> <td><code>[-]0.0</code></td></tr>
* <tr><td>Between [+-] 10<sup>-3</sup> and 10<sup>7</sup>, exclusive</td>
* <td><code>[-]number.number</code></td></tr>
* <tr><td>Other numeric value</td>
* <td><code>[-]&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>
*
* @param obj the object to compare to
* @return whether the objects are semantically equal.
*/
public boolean equals (Object obj)
{
if (!(obj instanceof Double))
return false;
double d = ((Double) obj).value;
// GCJ LOCAL: this implementation is probably faster than
// Classpath's, especially once we inline doubleToLongBits.
return doubleToLongBits (value) == doubleToLongBits (d);
// END GCJ LOCAL
}
/**
* The hashcode is the value of the expression: <br>
* <br>
* <code>(int)(v^(v>>>32))</code><br>
* <br>
* where v is defined by: <br>
* <code>long v = Double.doubleToLongBits(this.longValue());</code><br>
*/
public int hashCode ()
{
long v = doubleToLongBits (value);
return (int) (v ^ (v >>> 32));
}
/**
* Return the value of this <code>Double</code> when cast to an
* <code>int</code>.
*/
public int intValue ()
{
return (int) value;
}
/**
* Return the value of this <code>Double</code> when cast to a
* <code>long</code>.
*/
public long longValue ()
{
return (long) value;
}
/**
* Return the value of this <code>Double</code> when cast to a
* <code>float</code>.
*/
public float floatValue ()
{
return (float) value;
}
/**
* Return the primitive <code>double</code> value represented by this
* <code>Double</code>.
*/
public double doubleValue ()
{
return value;
}
/**
* Return the result of calling <code>new Double(java.lang.String)</code>.
* 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.
*
* @param s the <code>String</code> to convert to a <code>Double</code>.
* @return a new <code>Double</code> representing the <code>String</code>'s
* numeric value.
* <p>To create other output formats, use {@link java.text.NumberFormat}.
*
* @exception NullPointerException thrown if <code>String</code> is
* <code>null</code>.
* @exception NumberFormatException thrown if <code>String</code> cannot
* be parsed as a <code>double</code>.
* @see #Double(java.lang.String)
* @see #parseDouble(java.lang.String)
* @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 static Double valueOf (String s) throws NumberFormatException
public static String toString(double d)
{
return new Double (s);
return toString(d, false);
}
/**
* Return <code>true</code> if the value of this <code>Double</code>
* is the same as <code>NaN</code>, otherwise return <code>false</code>.
* @return whether this <code>Double</code> is <code>NaN</code>.
* Create a new <code>Double</code> object using the <code>String</code>.
*
* @param s the <code>String</code> to convert
* @return the new <code>Double</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>double</code>
* @throws NullPointerException if <code>s</code> is null.
* @see #parseDouble(String)
*/
public boolean isNaN ()
public static Double valueOf(String s)
{
return isNaN (value);
// XXX just call new Double(parseDouble(s));
if (s == null)
throw new NullPointerException();
return new Double(s);
}
/**
* Parse the specified <code>String</code> as a <code>double</code>. The
* extended BNF grammar is as follows:<br>
* <pre>
* <em>DecodableString</em>:
* ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
* | ( [ <code>-</code> | <code>+</code> ] <code>Infinity</code> )
* | ( [ <code>-</code> | <code>+</code> ] <em>FloatingPoint</em>
* [ <code>f</code> | <code>F</code> | <code>d</code>
* | <code>D</code>] )
* <em>FloatingPoint</em>:
* ( { <em>Digit</em> }+ [ <code>.</code> { <em>Digit</em> } ]
* [ <em>Exponent</em> ] )
* | ( <code>.</code> { <em>Digit</em> }+ [ <em>Exponent</em> ] )
* <em>Exponent</em>:
* ( ( <code>e</code> | <code>E</code> )
* [ <code>-</code> | <code>+</code> ] { <em>Digit</em> }+ )
* <em>Digit</em>: <em><code>'0'</code> through <code>'9'</code></em>
* </pre>
*
* <p>NaN and infinity are special cases, to allow parsing of the output
* of toString. Otherwise, the result is determined by calculating
* <em>n * 10<sup>exponent</sup></em> to infinite precision, then rounding
* to the nearest double. Remember that many numbers cannot be precisely
* represented in floating point. In case of overflow, infinity is used,
* and in case of underflow, signed zero is used. Unlike Integer.parseInt,
* this does not accept Unicode digits outside the ASCII range.
*
* <p>If an unexpected character is found in the <code>String</code>, a
* <code>NumberFormatException</code> will be thrown. Leading and trailing
* 'whitespace' is ignored via <code>String.trim()</code>, but spaces
* internal to the actual number are not allowed.
*
* <p>To parse numbers according to another format, consider using
* {@link java.text.NumberFormat}.
*
* @XXX specify where/how we are not in accord with the spec.
*
* @param str the <code>String</code> to convert
* @return the <code>double</code> value of <code>s</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>double</code>
* @throws NullPointerException if <code>s</code> is null
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
* @since 1.2
*/
public static native double parseDouble(String s);
/**
* Return <code>true</code> if the <code>double</code> has the same
* value as <code>NaN</code>, otherwise return <code>false</code>.
@ -268,7 +255,7 @@ public final class Double extends Number implements Comparable
* @param v the <code>double</code> to compare
* @return whether the argument is <code>NaN</code>.
*/
public static boolean isNaN (double v)
public static boolean isNaN(double v)
{
// This works since NaN != NaN is the only reflexive inequality
// comparison which returns true.
@ -276,77 +263,255 @@ public final class Double extends Number implements Comparable
}
/**
* Return <code>true</code> if the value of this <code>Double</code>
* is the same as <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @return whether this <code>Double</code> is (-/+) infinity.
*/
public boolean isInfinite ()
{
return isInfinite (value);
}
/**
* Return <code>true</code> if the <code>double</code> has a value
* equal to either <code>NEGATIVE_INFINITY</code> or
* Return <code>true</code> if the <code>double</code> has a value
* equal to either <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @param v the <code>double</code> to compare
* @return whether the argument is (-/+) infinity.
*/
public static boolean isInfinite (double v)
public static boolean isInfinite(double v)
{
return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY);
return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
}
/**
* Returns 0 if the <code>double</code> value of the argument is
* equal to the value of this <code>Double</code>. Returns a number
* less than zero if the value of this <code>Double</code> is less
* than the <code>double</code> value of the argument, and returns a
* number greater than zero if the value of this <code>Double</code>
* is greater than the <code>double</code> value of the argument.
* <br>
* <code>Double.NaN</code> is greater than any number other than itself,
* even <code>Double.POSITIVE_INFINITY</code>.
* <br>
* <code>0.0d</code> is greater than <code>-0.0d</code>.
* Return <code>true</code> if the value of this <code>Double</code>
* is the same as <code>NaN</code>, otherwise return <code>false</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.
* @return whether this <code>Double</code> is <code>NaN</code>
*/
public boolean isNaN()
{
return isNaN(value);
}
/**
* Return <code>true</code> if the value of this <code>Double</code>
* is the same as <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @return whether this <code>Double</code> is (-/+) infinity
*/
public boolean isInfinite()
{
return isInfinite(value);
}
/**
* Convert the <code>double</code> value of this <code>Double</code>
* to a <code>String</code>. This method calls
* <code>Double.toString(double)</code> to do its dirty work.
*
* @return the <code>String</code> representation
* @see #toString(double)
*/
public String toString()
{
return toString(value);
}
/**
* Return the value of this <code>Double</code> as a <code>byte</code>.
*
* @return the byte value
* @since 1.1
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this <code>Double</code> as a <code>short</code>.
*
* @return the short value
* @since 1.1
*/
public short shortValue()
{
return (short) value;
}
/**
* Return the value of this <code>Double</code> as an <code>int</code>.
*
* @return the int value
*/
public int intValue()
{
return (int) value;
}
/**
* Return the value of this <code>Double</code> as a <code>long</code>.
*
* @return the long value
*/
public long longValue()
{
return (long) value;
}
/**
* Return the value of this <code>Double</code> as a <code>float</code>.
*
* @return the float value
*/
public float floatValue()
{
return (float) value;
}
/**
* Return the value of this <code>Double</code>.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* Return a hashcode representing this Object. <code>Double</code>'s hash
* code is calculated by:<br>
* <code>long v = Double.doubleToLongBits(doubleValue());<br>
* int hash = (int)(v^(v&gt;&gt;32))</code>.
*
* @return this Object's hash code
* @see #doubleToLongBits(double)
*/
public int hashCode()
{
long v = doubleToLongBits(value);
return (int) (v ^ (v >>> 32));
}
/**
* Returns <code>true</code> if <code>obj</code> is an instance of
* <code>Double</code> and represents the same double value. Unlike comparing
* two doubles with <code>==</code>, this treats two instances of
* <code>Double.NaN</code> as equal, but treats <code>0.0</code> and
* <code>-0.0</code> as unequal.
*
* <p>Note that <code>d1.equals(d2)<code> is identical to
* <code>doubleToLongBits(d1.doubleValue()) ==
* doubleToLongBits(d2.doubleValue())<code>.
*
* @param obj the object to compare
* @return whether the objects are semantically equal
*/
public boolean equals(Object obj)
{
if (! (obj instanceof Double))
return false;
double d = ((Double) obj).value;
// Avoid call to native method. However, some implementations, like gcj,
// are better off using floatToIntBits(value) == floatToIntBits(f).
// Check common case first, then check NaN and 0.
if (value == d)
return (value != 0) || (1 / value == 1 / d);
return isNaN(value) && isNaN(d);
}
/**
* Convert the double to the IEEE 754 floating-point "double format" bit
* layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* (masked by 0x000fffffffffffffL) are the mantissa. This function
* collapses all versions of NaN to 0x7ff8000000000000L. The result of this
* function can be used as the argument to
* <code>Double.longBitsToDouble(long)</code> to obtain the original
* <code>double</code> value.
*
* @param value the <code>double</code> to convert
* @return the bits of the <code>double</code>
* @see #longBitsToDouble(long)
*/
public static native long doubleToLongBits(double value);
/**
* Convert the double to the IEEE 754 floating-point "double format" bit
* layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* (masked by 0x000fffffffffffffL) are the mantissa. This function
* leaves NaN alone, rather than collapsing to a canonical value. The
* result of this function can be used as the argument to
* <code>Double.longBitsToDouble(long)</code> to obtain the original
* <code>double</code> value.
*
* @param value the <code>double</code> to convert
* @return the bits of the <code>double</code>
* @see #longBitsToDouble(long)
*/
public static native long doubleToRawLongBits(double value);
/**
* Convert the argument in IEEE 754 floating-point "double format" bit
* layout to the corresponding float. Bit 63 (the most significant) is the
* sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the
* exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa.
* This function leaves NaN alone, so that you can recover the bit pattern
* with <code>Double.doubleToRawLongBits(double)</code>.
*
* @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 d the Double to compare
* @return the comparison
* @since 1.2
*/
public int compareTo (Double d)
public int compareTo(Double d)
{
return compare (value, d.value);
return compare(value, d.value);
}
/**
* Returns 0 if the first argument is equal to the second argument.
* Returns a number less than zero if the first argument is less than the
* second argument, and returns a number greater than zero if the first
* argument is greater than the second argument.
* <br>
* <code>Double.NaN</code> is greater than any number other than itself,
* even <code>Double.POSITIVE_INFINITY</code>.
* <br>
* <code>0.0d</code> is greater than <code>-0.0d</code>.
* Behaves like <code>compareTo(Double)</code> unless the Object
* is not an <code>Double</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.
* @param o the object to compare
* @return the comparison
* @throws ClassCastException if the argument is not a <code>Double</code>
* @see #compareTo(Double)
* @see Comparable
* @since 1.2
*/
public int compareTo(Object o)
{
return compare(value, ((Double) o).value);
}
/**
* Behaves like <code>new Double(x).compareTo(new Double(y))</code>; in
* other words this compares two doubles, special casing NaN and zero,
* without the overhead of objects.
*
* @param x the first double to compare
* @param y the second double to compare
* @return the comparison
* @since 1.4
*/
public static int compare (double x, double y)
public static int compare(double x, double y)
{
if (isNaN (x))
return isNaN (y) ? 0 : 1;
if (isNaN (y))
if (isNaN(x))
return isNaN(y) ? 0 : 1;
if (isNaN(y))
return -1;
// recall that 0.0 == -0.0, so we convert to infinites and try again
if (x == 0 && y == 0)
@ -358,171 +523,18 @@ public final class Double extends Number implements Comparable
}
/**
* Compares the specified <code>Object</code> to this <code>Double</code>
* if and only if the <code>Object</code> is an instanceof
* <code>Double</code>.
* Helper method to convert to string.
*
* @param o the Object 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.
* @throws ClassCastException if the argument is not a <code>Double</code>
* @param d the double to convert
* @param isFloat true if the conversion is requested by Float (results in
* fewer digits)
*/
public int compareTo (Object o)
{
return compareTo ((Double) o);
}
// Package visible for use by Float.
static native String toString(double d, boolean isFloat);
/**
* Convert the <code>double</code> to a <code>String</code>.
* <P>
*
* Floating-point string representation is fairly complex: here is a
* rundown of the possible values. "<CODE>[-]</CODE>" indicates that a
* negative sign will be printed if the value (or exponent) is negative.
* "<CODE>&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 d the <code>double</code> to convert
* @return the <code>String</code> representing the <code>double</code>.
*/
public static String toString (double d)
{
return toString (d, false);
}
static native String toString (double d, boolean isFloat);
/**
* Return the long bits of the specified <code>double</code>.
* The result of this function can be used as the argument to
* <code>Double.longBitsToDouble(long)</code> to obtain the
* original <code>double</code> value.
*
* @param value the <code>double</code> to convert
* @return the bits of the <code>double</code>.
*/
public static native long doubleToLongBits (double value);
/**
* Return the long bits of the specified <code>double</code>.
* The result of this function can be used as the argument to
* <code>Double.longBitsToDouble(long)</code> to obtain the
* original <code>double</code> value. This method differs from
* <code>doubleToLongBits</code> in that it does not collapse
* NaN values.
*
* @param value the <code>double</code> to convert
* @return the bits of the <code>double</code>.
*/
public static native long doubleToRawLongBits (double value);
/**
* Return the <code>double</code> represented by the long
* bits specified.
*
* @param bits the long bits representing a <code>double</code>
* @return the <code>double</code> represented by the bits.
*/
public static native double longBitsToDouble (long bits);
/**
* Parse the specified <code>String</code> as a <code>double</code>.
*
* The number is really read as <em>n * 10<sup>exponent</sup></em>. The
* first number is <em>n</em>, and if there is an "<code>E</code>"
* ("<code>e</code>" is also acceptable), then the integer after that is
* the exponent.
* <P>
* Here are the possible forms the number can take:
* <BR>
* <TABLE BORDER=1>
* <TR><TH>Form</TH><TH>Examples</TH></TR>
* <TR><TD><CODE>[+-]&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 str the <code>String</code> to convert
* @return the value of the <code>String</code> as a <code>double</code>.
* @exception NumberFormatException when the string cannot be parsed to a
* <code>double</code>.
* @exception NullPointerException when the string is null.
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
* @since 1.2
*/
public static native double parseDouble (String s)
throws NumberFormatException;
/**
* Initialize JNI cache. This method is called only by the
* Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
private static native void initIDs ();
private static native void initIDs();
}

656
libjava/java/lang/Float.java
View file

@ -1,4 +1,4 @@
/* java.lang.Float
/* Float.java -- object wrapper for float
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -40,12 +40,6 @@ package java.lang;
import gnu.classpath.Configuration;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
/**
* Instances of class <code>Float</code> represent primitive
* <code>float</code> values.
@ -55,10 +49,17 @@ import gnu.classpath.Configuration;
*
* @author Paul Fisher
* @author Andrew Haley <aph@cygnus.com>
* @since JDK 1.0
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public final class Float extends Number implements Comparable
{
/**
* Compatible with JDK 1.0+.
*/
private static final long serialVersionUID = -2671257302660747028L;
/**
* The maximum positive value a <code>double</code> may represent
* is 3.4028235e+38f.
@ -74,46 +75,50 @@ public final class Float extends Number implements Comparable
/**
* The value of a float representation -1.0/0.0, negative infinity.
*/
public static final float NEGATIVE_INFINITY = -1.0f/0.0f;
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
/**
* The value of a float representation 1.0/0.0, positive infinity.
*/
public static final float POSITIVE_INFINITY = 1.0f/0.0f;
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
/**
* All IEEE 754 values of NaN have the same value in Java.
*/
public static final float NaN = 0.0f/0.0f;
public static final float NaN = 0.0f / 0.0f;
/**
* The primitive type <code>float</code> is represented by this
* The primitive type <code>float</code> is represented by this
* <code>Class</code> object.
* @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('F');
/**
* The immutable value of this Float.
*
* @serial the wrapped float
*/
private final float value;
private static final long serialVersionUID = -2671257302660747028L;
/**
* Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javalang");
System.loadLibrary("javalang");
}
}
/**
* Create a <code>float</code> from the primitive <code>Float</code>
* Create a <code>Float</code> from the primitive <code>float</code>
* specified.
*
* @param value the <code>Float</code> argument
* @param value the <code>float</code> argument
*/
public Float (float value)
public Float(float value)
{
this.value = value;
}
@ -124,257 +129,134 @@ public final class Float extends Number implements Comparable
*
* @param value the <code>double</code> argument
*/
public Float (double value)
public Float(double value)
{
this.value = (float)value;
this.value = (float) value;
}
/**
* Create a <code>Float</code> from the specified <code>String</code>.
*
* This method calls <code>Float.parseFloat()</code>.
*
* @exception NumberFormatException when the <code>String</code> cannot
* be parsed into a <code>Float</code>.
* @param s the <code>String</code> to convert
* @see #parseFloat(java.lang.String)
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>float</code>
* @throws NullPointerException if <code>s</code> is null
* @see #parseFloat(String)
*/
public Float (String s) throws NumberFormatException
public Float(String s)
{
this.value = parseFloat (s);
}
/**
* Parse the specified <code>String</code> as a <code>float</code>.
*
* The number is really read as <em>n * 10<sup>exponent</sup></em>. The
* first number is <em>n</em>, and if there is an "<code>E</code>"
* ("<code>e</code>" is also acceptable), then the integer after that is
* the exponent.
* <P>
* Here are the possible forms the number can take:
* <BR>
* <TABLE BORDER=1>
* <TR><TH>Form</TH><TH>Examples</TH></TR>
* <TR><TD><CODE>[+-]&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>float</code> has a limited range. If the
* number you specify is greater than <code>Float.MAX_VALUE</code> or less
* than <code>-Float.MAX_VALUE</code>, it will be set at
* <code>Float.POSITIVE_INFINITY</code> or
* <code>Float.NEGATIVE_INFINITY</code>, respectively.
* <P>
*
* Note also that <code>float</code> does not have perfect precision. Many
* numbers cannot be precisely represented. The number you specify
* will be rounded to the nearest representable value.
* <code>Float.MIN_VALUE</code> is the margin of error for <code>float</code>
* values.
* <P>
* If an unexpected character is found in the <code>String</code>, a
* <code>NumberFormatException</code> will be thrown. Spaces are not
* allowed and will cause this exception to be thrown.
*
* @XXX specify where/how we are not in accord with the spec.
*
* @param str the <code>String</code> to convert
* @return the value of the <code>String</code> as a <code>float</code>.
* @exception NumberFormatException when the string cannot be parsed to a
* <code>float</code>.
* @since JDK 1.2
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
*/
public static float parseFloat (String s) throws NumberFormatException
{
// The spec says that parseFloat() should work like
// Double.valueOf(). This is equivalent, in our implementation,
// but more efficient.
return (float) Double.parseDouble (s);
}
/**
* Convert the <code>float</code> value of this <code>Float</code>
* to a <code>String</code>. This method calls
* <code>Float.toString(float)</code> to do its dirty work.
*
* @return the <code>String</code> representation of this <code>Float</code>.
* @see #toString(float)
*/
public String toString ()
{
return toString (value);
}
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Float</code>, and represents
* the same primitive <code>float</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
* <p>
* Note that there are two differences between <code>==</code> and
* <code>equals()</code>. <code>0.0f == -0.0f</code> returns <code>true</code>
* but <code>new Float(0.0f).equals(new Float(-0.0f))</code> returns
* <code>false</code>. And <code>Float.NaN == Float.NaN</code> returns
* <code>false</code>, but
* <code>new Float(Float.NaN).equals(new Float(Float.NaN))</code> returns
* <code>true</code>.
*
* @param obj the object to compare to
* @return whether the objects are semantically equal.
*/
public boolean equals (Object obj)
{
if (!(obj instanceof Float))
return false;
float f = ((Float) obj).value;
// GCJ LOCAL: this implementation is probably faster than
// Classpath's, especially once we inline floatToIntBits.
return floatToIntBits (value) == floatToIntBits (f);
// END GCJ LOCAL
}
/**
* Return a hashcode representing this Object.
* <code>Float</code>'s hash code is calculated by calling the
* <code>floatToIntBits()</code> function.
* @return this Object's hash code.
* @see java.lang.Float.floatToIntBits(float)
*/
public int hashCode ()
{
return floatToIntBits (value);
}
/**
* Return the value of this <code>Double</code> when cast to an
* <code>int</code>.
*/
public int intValue ()
{
return (int) value;
}
/**
* Return the value of this <code>Double</code> when cast to a
* <code>long</code>.
*/
public long longValue ()
{
return (long) value;
}
/**
* Return the value of this <code>Double</code> when cast to a
* <code>float</code>.
*/
public float floatValue ()
{
return (float) value;
}
/**
* Return the primitive <code>double</code> value represented by this
* <code>Double</code>.
*/
public double doubleValue ()
{
return (double) value;
value = parseFloat(s);
}
/**
* Convert the <code>float</code> to a <code>String</code>.
* <P>
*
* Floating-point string representation is fairly complex: here is a
* rundown of the possible values. "<CODE>[-]</CODE>" indicates that a
* 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>
* "<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>-</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>
* <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. No
* truncation or rounding is done by this function.
* 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>.
* @return the <code>String</code> representing the <code>float</code>
*/
public static String toString (float f)
public static String toString(float f)
{
return Double.toString ((double) f, true);
return Double.toString(f, true);
}
/**
* Return the result of calling <code>new Float(java.lang.String)</code>.
* Creates a new <code>Float</code> object using the <code>String</code>.
*
* @param s the <code>String</code> to convert to a <code>Float</code>.
* @return a new <code>Float</code> representing the <code>String</code>'s
* numeric value.
*
* @exception NumberFormatException thrown if <code>String</code> cannot
* be parsed as a <code>double</code>.
* @see #Float(java.lang.String)
* @see #parseFloat(java.lang.String)
* @param s the <code>String</code> to convert
* @return the new <code>Float</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>float</code>
* @throws NullPointerException if <code>s</code> is null
* @see #parseFloat(String)
*/
public static Float valueOf (String s) throws NumberFormatException
public static Float valueOf(String s)
{
return new Float (s);
return new Float(parseFloat(s));
}
/**
* Return <code>true</code> if the value of this <code>Float</code>
* is the same as <code>NaN</code>, otherwise return <code>false</code>.
* @return whether this <code>Float</code> is <code>NaN</code>.
* Parse the specified <code>String</code> as a <code>float</code>. The
* extended BNF grammar is as follows:<br>
* <pre>
* <em>DecodableString</em>:
* ( [ <code>-</code> | <code>+</code> ] <code>NaN</code> )
* | ( [ <code>-</code> | <code>+</code> ] <code>Infinity</code> )
* | ( [ <code>-</code> | <code>+</code> ] <em>FloatingPoint</em>
* [ <code>f</code> | <code>F</code> | <code>d</code>
* | <code>D</code>] )
* <em>FloatingPoint</em>:
* ( { <em>Digit</em> }+ [ <code>.</code> { <em>Digit</em> } ]
* [ <em>Exponent</em> ] )
* | ( <code>.</code> { <em>Digit</em> }+ [ <em>Exponent</em> ] )
* <em>Exponent</em>:
* ( ( <code>e</code> | <code>E</code> )
* [ <code>-</code> | <code>+</code> ] { <em>Digit</em> }+ )
* <em>Digit</em>: <em><code>'0'</code> through <code>'9'</code></em>
* </pre>
*
* <p>NaN and infinity are special cases, to allow parsing of the output
* of toString. Otherwise, the result is determined by calculating
* <em>n * 10<sup>exponent</sup></em> to infinite precision, then rounding
* to the nearest float. Remember that many numbers cannot be precisely
* represented in floating point. In case of overflow, infinity is used,
* and in case of underflow, signed zero is used. Unlike Integer.parseInt,
* this does not accept Unicode digits outside the ASCII range.
*
* <p>If an unexpected character is found in the <code>String</code>, a
* <code>NumberFormatException</code> will be thrown. Leading and trailing
* 'whitespace' is ignored via <code>String.trim()</code>, but spaces
* internal to the actual number are not allowed.
*
* <p>To parse numbers according to another format, consider using
* {@link java.text.NumberFormat}.
*
* @XXX specify where/how we are not in accord with the spec.
*
* @param str the <code>String</code> to convert
* @return the <code>float</code> value of <code>s</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>float</code>
* @throws NullPointerException if <code>s</code> is null
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
* @since 1.2
*/
public boolean isNaN ()
public static float parseFloat(String s)
{
return isNaN (value);
// XXX Rounding parseDouble() causes some errors greater than 1 ulp from
// the infinitely precise decimal.
return (float) Double.parseDouble(s);
}
/**
@ -382,9 +264,9 @@ public final class Float extends Number implements Comparable
* value as <code>NaN</code>, otherwise return <code>false</code>.
*
* @param v the <code>float</code> to compare
* @return whether the argument is <code>NaN</code>.
* @return whether the argument is <code>NaN</code>
*/
public static boolean isNaN (float v)
public static boolean isNaN(float v)
{
// This works since NaN != NaN is the only reflexive inequality
// comparison which returns true.
@ -392,111 +274,250 @@ public final class Float extends Number implements Comparable
}
/**
* Return <code>true</code> if the value of this <code>Float</code>
* is the same as <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @return whether this <code>Float</code> is (-/+) infinity.
*/
public boolean isInfinite ()
{
return isInfinite (value);
}
/**
* Return <code>true</code> if the <code>float</code> has a value
* equal to either <code>NEGATIVE_INFINITY</code> or
* Return <code>true</code> if the <code>float</code> has a value
* equal to either <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @param v the <code>float</code> to compare
* @return whether the argument is (-/+) infinity.
* @return whether the argument is (-/+) infinity
*/
public static boolean isInfinite (float v)
public static boolean isInfinite(float v)
{
return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY);
return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
}
/**
* Return the int bits of the specified <code>float</code>.
* The result of this function can be used as the argument to
* <code>Float.intBitsToFloat(long)</code> to obtain the
* Return <code>true</code> if the value of this <code>Float</code>
* is the same as <code>NaN</code>, otherwise return <code>false</code>.
*
* @return whether this <code>Float</code> is <code>NaN</code>
*/
public boolean isNaN()
{
return isNaN(value);
}
/**
* Return <code>true</code> if the value of this <code>Float</code>
* is the same as <code>NEGATIVE_INFINITY</code> or
* <code>POSITIVE_INFINITY</code>, otherwise return <code>false</code>.
*
* @return whether this <code>Float</code> is (-/+) infinity
*/
public boolean isInfinite()
{
return isInfinite(value);
}
/**
* Convert the <code>float</code> value of this <code>Float</code>
* to a <code>String</code>. This method calls
* <code>Float.toString(float)</code> to do its dirty work.
*
* @return the <code>String</code> representation
* @see #toString(float)
*/
public String toString()
{
return toString(value);
}
/**
* Return the value of this <code>Float</code> as a <code>byte</code>.
*
* @return the byte value
* @since 1.1
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this <code>Float</code> as a <code>short</code>.
*
* @return the short value
* @since 1.1
*/
public short shortValue()
{
return (short) value;
}
/**
* Return the value of this <code>Integer</code> as an <code>int</code>.
*
* @return the int value
*/
public int intValue()
{
return (int) value;
}
/**
* Return the value of this <code>Integer</code> as a <code>long</code>.
*
* @return the long value
*/
public long longValue()
{
return (long) value;
}
/**
* Return the value of this <code>Float</code>.
*
* @return the float value
*/
public float floatValue()
{
return value;
}
/**
* Return the value of this <code>Float</code> as a <code>double</code>
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* Return a hashcode representing this Object. <code>Float</code>'s hash
* code is calculated by calling <code>floatToIntBits(floatValue())</code>.
*
* @return this Object's hash code
* @see #floatToIntBits(float)
*/
public int hashCode()
{
return floatToIntBits(value);
}
/**
* Returns <code>true</code> if <code>obj</code> is an instance of
* <code>Float</code> and represents the same float value. Unlike comparing
* two floats with <code>==</code>, this treats two instances of
* <code>Float.NaN</code> as equal, but treats <code>0.0</code> and
* <code>-0.0</code> as unequal.
*
* <p>Note that <code>f1.equals(f2)<code> is identical to
* <code>floatToIntBits(f1.floatValue()) ==
* floatToIntBits(f2.floatValue())<code>.
*
* @param obj the object to compare
* @return whether the objects are semantically equal
*/
public boolean equals(Object obj)
{
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);
}
/**
* Convert the float to the IEEE 754 floating-point "single format" bit
* layout. Bit 31 (the most significant) is the sign bit, bits 30-23
* (masked by 0x7f800000) represent the exponent, and bits 22-0
* (masked by 0x007fffff) are the mantissa. This function collapses all
* versions of NaN to 0x7fc00000. The result of this function can be used
* as the argument to <code>Float.intBitsToFloat(int)</code> to obtain the
* original <code>float</code> value.
*
* @param value the <code>float</code> to convert
* @return the bits of the <code>float</code>.
* @return the bits of the <code>float</code>
* @see #intBitsToFloat(int)
*/
public static native int floatToIntBits (float value);
public static native int floatToIntBits(float value);
/**
* Return the int bits of the specified <code>float</code>.
* The result of this function can be used as the argument to
* <code>Float.intBitsToFloat(long)</code> to obtain the
* original <code>float</code> value. The difference between
* this function and <code>floatToIntBits</code> is that this
* function does not collapse NaN values.
* Convert the float to the IEEE 754 floating-point "single format" bit
* layout. Bit 31 (the most significant) is the sign bit, bits 30-23
* (masked by 0x7f800000) represent the exponent, and bits 22-0
* (masked by 0x007fffff) are the mantissa. This function leaves NaN alone,
* rather than collapsing to a canonical value. The result of this function
* can be used as the argument to <code>Float.intBitsToFloat(int)</code> to
* obtain the original <code>float</code> value.
*
* @param value the <code>float</code> to convert
* @return the bits of the <code>float</code>.
* @return the bits of the <code>float</code>
* @see #intBitsToFloat(int)
*/
public static native int floatToRawIntBits (float value);
public static native int floatToRawIntBits(float value);
/**
* Return the <code>float</code> represented by the long
* bits specified.
* Convert the argument in IEEE 754 floating-point "single format" bit
* layout to the corresponding float. Bit 31 (the most significant) is the
* sign bit, bits 30-23 (masked by 0x7f800000) represent the exponent, and
* bits 22-0 (masked by 0x007fffff) are the mantissa. This function leaves
* NaN alone, so that you can recover the bit pattern with
* <code>Float.floatToRawIntBits(float)</code>.
*
* @param bits the long bits representing a <code>double</code>
* @return the <code>float</code> represented by the bits.
* @param bits the bits to convert
* @return the <code>float</code> represented by the bits
* @see #floatToIntBits(float)
* @see #floatToRawIntBits(float)
*/
public static native float intBitsToFloat (int bits);
public static native float intBitsToFloat(int bits);
/**
* Returns 0 if the <code>float</code> value of the argument is
* equal to the value of this <code>Float</code>. Returns a number
* less than zero if the value of this <code>Float</code> is less
* than the <code>Float</code> value of the argument, and returns a
* number greater than zero if the value of this <code>Float</code>
* is greater than the <code>float</code> value of the argument.
* <br>
* <code>Float.NaN</code> is greater than any number other than itself,
* even <code>Float.POSITIVE_INFINITY</code>.
* <br>
* <code>0.0</code> is greater than <code>-0.0</code>.
*
* @param f the Float 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.
* Compare two Floats numerically by comparing their <code>float</code>
* values. The result is positive if the first is greater, negative if the
* second is greater, and 0 if the two are equal. However, this special
* cases NaN and signed zero as follows: NaN is considered greater than
* all other floats, including <code>POSITIVE_INFINITY</code>, and positive
* zero is considered greater than negative zero.
*
* @param f the Float to compare
* @return the comparison
* @since 1.2
*/
public int compareTo (Float f)
public int compareTo(Float f)
{
return compare (value, f.value);
return compare(value, f.value);
}
/**
* Returns 0 if the first argument is equal to the second argument.
* Returns a number less than zero if the first argument is less than the
* second argument, and returns a number greater than zero if the first
* argument is greater than the second argument.
* <br>
* <code>Float.NaN</code> is greater than any number other than itself,
* even <code>Float.POSITIVE_INFINITY</code>.
* <br>
* <code>0.0</code> is greater than <code>-0.0</code>.
* Behaves like <code>compareTo(Float)</code> unless the Object
* is not an <code>Float</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.
* @param o the object to compare
* @return the comparison
* @throws ClassCastException if the argument is not a <code>Float</code>
* @see #compareTo(Float)
* @see Comparable
* @since 1.2
*/
public int compareTo(Object o)
{
return compare(value, ((Float) o).value);
}
/**
* Behaves like <code>new Float(x).compareTo(new Float(y))</code>; in
* other words this compares two floats, special casing NaN and zero,
* without the overhead of objects.
*
* @param x the first float to compare
* @param y the second float to compare
* @return the comparison
* @since 1.4
*/
public static int compare (float x, float y)
public static int compare(float x, float y)
{
if (isNaN (x))
return isNaN (y) ? 0 : 1;
if (isNaN (y))
if (isNaN(x))
return isNaN(y) ? 0 : 1;
if (isNaN(y))
return -1;
// recall that 0.0 == -0.0, so we convert to infinities and try again
if (x == 0 && y == 0)
@ -506,23 +527,4 @@ public final class Float extends Number implements Comparable
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);
}
}

870
libjava/java/lang/Integer.java
View file

@ -1,5 +1,5 @@
/* java.lang.Integer
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
/* Integer.java -- object wrapper for int
Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -48,36 +48,45 @@ package java.lang;
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
* @since JDK 1.0
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public final class Integer extends Number implements Comparable
{
// compatible with JDK 1.0.2+
/**
* Compatible with JDK 1.0.2+.
*/
private static final long serialVersionUID = 1360826667806852920L;
/**
* The minimum value an <code>int</code> can represent is -2147483648.
* The minimum value an <code>int</code> can represent is -2147483648 (or
* -2<sup>31</sup>).
*/
public static final int MIN_VALUE = 0x80000000;
/**
* The maximum value an <code>int</code> can represent is 2147483647.
* The maximum value an <code>int</code> can represent is 2147483647 (or
* 2<sup>31</sup> - 1).
*/
public static final int MAX_VALUE = 0x7fffffff;
/**
* The primitive type <code>int</code> is represented by this
* The primitive type <code>int</code> is represented by this
* <code>Class</code> object.
* @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass ('I');
public static final Class TYPE = VMClassLoader.getPrimitiveClass('I');
/**
* The immutable value of this Integer.
*
* @serial the wrapped int
*/
private final int value;
/**
* Create an <code>Integer</code> object representing the value of the
* Create an <code>Integer</code> object representing the value of the
* <code>int</code> argument.
*
* @param value the value to use
@ -88,193 +97,29 @@ 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>.
*
* @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);
}
/**
* Return a hashcode representing this Object.
*
* <code>Integer</code>'s hash code is calculated by simply returning its
* value.
*
* @return this Object's hash code.
*/
public int hashCode()
{
return value;
}
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Integer</code>, and represents
* the same primitive <code>int</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
*/
public boolean equals(Object obj)
{
return obj instanceof Integer && value == ((Integer)obj).value;
}
/**
* Get the specified system property as an <code>Integer</code>.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
* @param nm the name of the system property
* @return the system property as an <code>Integer</code>, or
* <code>null</code> if the property is not found or cannot be
* decoded as an <code>Integer</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see #decode(int)
*/
public static Integer getInteger(String nm)
{
return getInteger(nm, null);
}
/**
* Get the specified system property as an <code>Integer</code>, or use a
* default <code>int</code> value if the property is not found or is not
* decodable.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
*
* @param nm the name of the system property
* @param val the default value to use if the property is not found or not
* a number.
* @return the system property as an <code>Integer</code>, or the default
* value if the property is not found or cannot be decoded as an
* <code>Integer</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see #decode(int)
* @see #getInteger(java.lang.String,java.lang.Integer)
*/
public static Integer getInteger(String nm, int val)
{
Integer result = getInteger(nm, null);
return (result == null) ? new Integer(val) : result;
}
/**
* Get the specified system property as an <code>Integer</code>, or use a
* default <code>Integer</code> value if the property is not found or is
* not decodable.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
*
* @param nm the name of the system property
* @param val the default value to use if the property is not found or not
* a number.
* @return the system property as an <code>Integer</code>, or the default
* value if the property is not found or cannot be decoded as an
* <code>Integer</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see #decode(int)
* @see #getInteger(java.lang.String,int)
*/
public static Integer getInteger(String nm, Integer def)
{
String val = System.getProperty(nm);
if (val == null) return def;
try
{
return decode(val);
}
catch (NumberFormatException e)
{
return def;
}
}
private static String toUnsignedString(int num, int exp)
{
// Use an array large enough for a binary number.
int radix = 1 << exp;
int mask = radix - 1;
char[] buffer = new char[32];
int i = 32;
do
{
buffer[--i] = Character.forDigit(num & mask, radix);
num = num >>> exp;
}
while (num != 0);
return String.valueOf(buffer, i, 32-i);
}
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 16.
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toHexString(int i)
{
return toUnsignedString(i, 4);
}
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 8.
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toOctalString(int i)
{
return toUnsignedString(i, 3);
}
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 2.
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toBinaryString(int i)
{
return toUnsignedString(i, 1);
}
/**
* Converts the <code>int</code> to a <code>String</code> and assumes
* a radix of 10.
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toString(int i)
{
// This is tricky: in libgcj, String.valueOf(int) is a fast native
// implementation. In Classpath it just calls back to
// Integer.toString(int,int).
return String.valueOf (i);
}
/**
* Converts the <code>Integer</code> value to a <code>String</code> and
* assumes a radix of 10.
* @return the <code>String</code> representation of this <code>Integer</code>.
*/
public String toString()
{
return toString (value);
value = parseInt(s, 10, false);
}
/**
* Converts the <code>int</code> to a <code>String</code> using
* the specified radix (base).
* @param i the <code>int</code> to convert to <code>String</code>.
* @param radix the radix (base) to use in the conversion.
* @return the <code>String</code> representation of the argument.
* the specified radix (base). If the radix exceeds
* <code>Character.MIN_RADIX</code> or <code>Character.MAX_RADIX</code>, 10
* is used instead. If the result is negative, the leading character is
* '-' ('\\u002D'). The remaining characters come from
* <code>Character.forDigit(digit, radix)</code> ('0'-'9','a'-'z').
*
* @param num the <code>int</code> to convert to <code>String</code>
* @param radix the radix (base) to use in the conversion
* @return the <code>String</code> representation of the argument
*/
public static String toString(int num, int radix)
{
@ -285,25 +130,23 @@ public final class Integer extends Number implements Comparable
// Use an array large enough for a binary number.
char[] buffer = new char[33];
int i = 33;
boolean isNeg;
boolean isNeg = false;
if (num < 0)
{
isNeg = true;
num = -(num);
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);
}
{
buffer[--i] = digits[(int) (-(num + radix) % radix)];
num = -(num / radix);
}
}
else
isNeg = false;
do
{
buffer[--i] = Character.forDigit(num % radix, radix);
buffer[--i] = digits[num % radix];
num /= radix;
}
while (num > 0);
@ -311,38 +154,81 @@ public final class Integer extends Number implements Comparable
if (isNeg)
buffer[--i] = '-';
return String.valueOf(buffer, i, 33-i);
// Package constructor avoids an array copy.
return new String(buffer, i, 33 - i, true);
}
/**
* Creates a new <code>Integer</code> object using the <code>String</code>,
* assuming a radix of 10.
* @param s the <code>String</code> to convert.
* @return the new <code>Integer</code>.
* @see #Integer(java.lang.String)
* @see #parseInt(java.lang.String)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 16.
*
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument
*/
public static Integer valueOf(String s) throws NumberFormatException
public static String toHexString(int i)
{
return new Integer(parseInt(s));
return toUnsignedString(i, 4);
}
/**
* Creates a new <code>Integer</code> object using the <code>String</code>
* and specified radix (base).
* @param s the <code>String</code> to convert.
* @param radix the radix (base) to convert with.
* @return the new <code>Integer</code>.
* @see #parseInt(java.lang.String,int)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 8.
*
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument
*/
public static Integer valueOf(String s, int radix)
throws NumberFormatException
public static String toOctalString(int i)
{
return new Integer(parseInt(s, radix));
return toUnsignedString(i, 3);
}
/**
* Converts the <code>int</code> to a <code>String</code> assuming it is
* unsigned in base 2.
*
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument
*/
public static String toBinaryString(int i)
{
return toUnsignedString(i, 1);
}
/**
* Converts the <code>int</code> to a <code>String</code> and assumes
* a radix of 10.
*
* @param i the <code>int</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument
* @see #toString(int, int)
*/
public static String toString(int i)
{
// This is tricky: in libgcj, String.valueOf(int) is a fast native
// implementation. In Classpath it just calls back to
// Integer.toString(int, int).
return String.valueOf(i);
}
/**
* Converts the specified <code>String</code> into an <code>int</code>
* using the specified radix (base). The string must not be <code>null</code>
* or empty. It may begin with an optional '-', which will negate the answer,
* provided that there are also valid digits. Each digit is parsed as if by
* <code>Character.digit(d, radix)</code>, and must be in the range
* <code>0</code> to <code>radix - 1</code>. Finally, the result must be
* within <code>MIN_VALUE</code> to <code>MAX_VALUE</code>, inclusive.
* Unlike Double.parseDouble, you may not have a leading '+'.
*
* @param s the <code>String</code> to convert
* @param radix the radix (base) to use in the conversion
* @return the <code>String</code> argument converted to </code>int</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as an
* <code>int</code>
*/
public static int parseInt(String str, int radix)
{
return parseInt(str, radix, false);
}
/**
@ -350,58 +236,353 @@ public final class Integer extends Number implements Comparable
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>int</code> value of the <code>String</code>
* argument.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
* @return the <code>int</code> value of <code>s</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as an
* <code>int</code>
* @see #parseInt(String, int)
*/
public static int parseInt(String s) throws NumberFormatException
public static int parseInt(String s)
{
return parseInt(s, 10);
return parseInt(s, 10, false);
}
/**
* Converts the specified <code>String</code> into an <code>int</code>
* using the specified radix (base).
* Creates a new <code>Integer</code> object using the <code>String</code>
* and specified radix (base).
*
* @param s the <code>String</code> to convert
* @param radix the radix (base) to 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>.
* @param radix the radix (base) to convert with
* @return the new <code>Integer</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as an
* <code>int</code>
* @see #parseInt(String, int)
*/
public static int parseInt(String str, int radix)
throws NumberFormatException
public static Integer valueOf(String s, int radix)
{
final int len;
if (str == null)
throw new NumberFormatException ();
if ((len = str.length()) == 0 ||
radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
throw new NumberFormatException();
boolean isNeg = false;
int index = 0;
if (str.charAt(index) == '-')
if (len > 1)
{
isNeg = true;
index++;
}
else
throw new NumberFormatException();
return parseInt(str, index, len, isNeg, radix);
return new Integer(parseInt(s, radix, false));
}
private static int parseInt(String str, int index, int len, boolean isNeg,
int radix)
throws NumberFormatException
/**
* Creates a new <code>Integer</code> object using the <code>String</code>,
* assuming a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the new <code>Integer</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as an
* <code>int</code>
* @see #Integer(String)
* @see #parseInt(String)
*/
public static Integer valueOf(String s)
{
int val = 0;
int digval;
return new Integer(parseInt(s, 10, false));
}
/**
* Return the value of this <code>Integer</code> as a <code>byte</code>.
*
* @return the byte value
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this <code>Integer</code> as a <code>short</code>.
*
* @return the short value
*/
public short shortValue()
{
return (short) value;
}
/**
* Return the value of this <code>Integer</code>.
* @return the int value
*/
public int intValue()
{
return value;
}
/**
* Return the value of this <code>Integer</code> as a <code>long</code>.
*
* @return the long value
*/
public long longValue()
{
return value;
}
/**
* Return the value of this <code>Integer</code> as a <code>float</code>.
*
* @return the float value
*/
public float floatValue()
{
return value;
}
/**
* Return the value of this <code>Integer</code> as a <code>double</code>.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* 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 a hashcode representing this Object. <code>Integer</code>'s hash
* code is simply its value.
*
* @return this Object's hash code
*/
public int hashCode()
{
return value;
}
/**
* Returns <code>true</code> if <code>obj</code> is an instance of
* <code>Integer</code> and represents the same int value.
*
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{
return 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 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 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 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)
{
Integer result = getInteger(nm, null);
return result == null ? new Integer(val) : result;
}
/**
* Get the specified system property as an <code>Integer</code>, or use a
* default <code>Integer</code> value if the property is not found or is
* not decodable. The <code>decode()</code> method will be used to
* interpret the value of the property.
*
* @param nm the name of the system property
* @param val the default value
* @return the value of the system property, or the default
* @throws SecurityException if accessing the system property is forbidden
* @see System#getProperty(String)
* @see #decode(String)
*/
public static Integer getInteger(String nm, Integer def)
{
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;
}
}
/**
* Convert the specified <code>String</code> into an <code>Integer</code>.
* The <code>String</code> may represent decimal, hexadecimal, or
* octal numbers.
*
* <p>The extended BNF grammar is as follows:<br>
* <pre>
* <em>DecodableString</em>:
* ( [ <code>-</code> ] <em>DecimalNumber</em> )
* | ( [ <code>-</code> ] ( <code>0x</code> | <code>0X</code>
* | <code>#</code> ) <em>HexDigit</em> { <em>HexDigit</em> } )
* | ( [ <code>-</code> ] <code>0</code> { <em>OctalDigit</em> } )
* <em>DecimalNumber</em>:
* <em>DecimalDigit except '0'</em> { <em>DecimalDigit</em> }
* <em>DecimalDigit</em>:
* <em>Character.digit(d, 10) has value 0 to 9</em>
* <em>OctalDigit</em>:
* <em>Character.digit(d, 8) has value 0 to 7</em>
* <em>DecimalDigit</em>:
* <em>Character.digit(d, 16) has value 0 to 15</em>
* </pre>
* Finally, the value must be in the range <code>MIN_VALUE</code> to
* <code>MAX_VALUE</code>, or an exception is thrown.
*
* @param s the <code>String</code> to interpret
* @return the value of the String as an <code>Integer</code>
* @throws NumberFormatException if <code>s</code> cannot be parsed as a
* <code>int</code>
* @throws NullPointerException if <code>s</code> is null
* @since 1.2
*/
public static Integer decode(String str)
{
return new Integer(parseInt(str, 10, true));
}
/**
* Compare two Integers numerically by comparing their <code>int</code>
* values. The result is positive if the first is greater, negative if the
* second is greater, and 0 if the two are equal.
*
* @param i the Integer to compare
* @return the comparison
* @since 1.2
*/
public int compareTo(Integer i)
{
if (value == i.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow.
return value > i.value ? 1 : -1;
}
/**
* Behaves like <code>compareTo(Integer)</code> unless the Object
* is not an <code>Integer</code>.
*
* @param o the object to compare
* @return the comparison
* @throws ClassCastException if the argument is not an <code>Integer</code>
* @see #compareTo(Integer)
* @see Comparable
* @since 1.2
*/
public int compareTo(Object o)
{
return compareTo((Integer) o);
}
/**
* 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'.
@ -409,174 +590,17 @@ public final class Integer extends Number implements Comparable
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
int val = 0;
while (index < len)
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
ch = Character.digit(str.charAt(index++), radix);
val = val * radix + ch;
if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
}
return isNeg ? -(val) : val;
}
/**
* Convert the specified <code>String</code> into an <code>Integer</code>.
* The <code>String</code> may represent decimal, hexadecimal, or
* octal numbers.
*
* The <code>String</code> argument is interpreted based on the leading
* characters. Depending on what the String begins with, the base will be
* interpreted differently:
*
* <table border=1>
* <tr><th>Leading<br>Characters</th><th>Base</th></tr>
* <tr><td>#</td><td>16</td></tr>
* <tr><td>0x</td><td>16</td></tr>
* <tr><td>0X</td><td>16</td></tr>
* <tr><td>0</td><td>8</td></tr>
* <tr><td>Anything<br>Else</td><td>10</td></tr>
* </table>
*
* @param str the <code>String</code> to interpret.
* @return the value of the String as an <code>Integer</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
*/
public static Integer decode(String str) throws NumberFormatException
{
boolean isNeg = false;
int index = 0;
int radix = 10;
final int len;
if (str == null || (len = str.length()) == 0)
throw new NumberFormatException("string null or empty");
// Negative numbers are always radix 10.
if (str.charAt(index) == '-')
{
radix = 10;
index++;
isNeg = true;
}
else if (str.charAt(index) == '#')
{
radix = 16;
index++;
}
else if (str.charAt(index) == '0')
{
// Check if str is just "0"
if (len == 1)
return new Integer(0);
index++;
if (str.charAt(index) == 'x' || str.charAt(index) == 'X')
{
radix = 16;
index++;
}
else
radix = 8;
}
if (index >= len)
throw new NumberFormatException("empty value");
return new Integer(parseInt(str, index, len, isNeg, radix));
}
/** Return the value of this <code>Integer</code> as a <code>byte</code>.
** @return the value of this <code>Integer</code> as a <code>byte</code>.
**/
public byte byteValue()
{
return (byte) value;
}
/** Return the value of this <code>Integer</code> as a <code>short</code>.
** @return the value of this <code>Integer</code> as a <code>short</code>.
**/
public short shortValue()
{
return (short) value;
}
/** Return the value of this <code>Integer</code> as an <code>int</code>.
** @return the value of this <code>Integer</code> as an <code>int</code>.
**/
public int intValue()
{
return value;
}
/** Return the value of this <code>Integer</code> as a <code>long</code>.
** @return the value of this <code>Integer</code> as a <code>long</code>.
**/
public long longValue()
{
return value;
}
/** Return the value of this <code>Integer</code> as a <code>float</code>.
** @return the value of this <code>Integer</code> as a <code>float</code>.
**/
public float floatValue()
{
return value;
}
/** Return the value of this <code>Integer</code> as a <code>double</code>.
** @return the value of this <code>Integer</code> as a <code>double</code>.
**/
public double doubleValue()
{
return value;
}
/**
* Compare two Integers numerically by comparing their
* <code>int</code> values.
* @return a positive value if this <code>Integer</code> is greater
* in value than the argument <code>Integer</code>; a negative value
* if this <code>Integer</code> is smaller in value than the argument
* <code>Integer</code>; and <code>0</code>, zero, if this
* <code>Integer</code> is equal in value to the argument
* <code>Integer</code>.
*
* @since 1.2
*/
public int compareTo(Integer i)
{
if (this.value == i.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow.
if (this.value > i.value)
return 1;
return -1;
}
/**
* Behaves like <code>compareTo(java.lang.Integer)</code> unless the Object
* is not a <code>Integer</code>. Then it throws a
* <code>ClassCastException</code>.
* @exception ClassCastException if the argument is not a
* <code>Integer</code>.
*
* @since 1.2
*/
public int compareTo(Object o)
{
return compareTo((Integer)o);
return isNeg ? -val : val;
}
}

879
libjava/java/lang/Long.java
View file

File diff suppressed because it is too large Load diff

121
libjava/java/lang/Number.java
View file

@ -1,5 +1,5 @@
/* java.lang.Number
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
/* Number.java =- abstract superclass of numeric objects
Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -41,54 +41,91 @@ package java.lang;
import java.io.Serializable;
/**
** Number is a generic superclass of all the numeric classes, namely
** <code>Byte</code>, <code>Short</code>, <code>Integer</code>,
** <code>Long</code>, <code>Float</code>, and <code>Double</code>.
**
** It provides ways to convert from any one value to any other.
**
** @author Paul Fisher
** @author John Keiser
** @author Warren Levy
** @since JDK1.0
**/
* Number is a generic superclass of all the numeric classes, including
* the wrapper classes {@link Byte}, {@link Short}, {@link Integer},
* {@link Long}, {@link Float}, and {@link Double}. Also worth mentioning
* are the classes in {@link java.math}.
*
* It provides ways to convert numeric objects to any primitive.
*
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status updated to 1.4
*/
public abstract class Number implements Serializable
{
/** Return the value of this <code>Number</code> as a <code>byte</code>.
** @return the value of this <code>Number</code> as a <code>byte</code>.
**/
/**
* Compatible with JDK 1.1+.
*/
private static final long serialVersionUID = -8742448824652078965L;
/**
* Table for calculating digits, used in Character, Long, and Integer.
*/
static final char[] digits = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
/**
* The basic constructor (often called implicitly).
*/
public Number()
{
}
/**
* Return the value of this <code>Number</code> as an <code>int</code>.
*
* @return the int value
*/
public abstract int intValue();
/**
* Return the value of this <code>Number</code> as a <code>long</code>.
*
* @return the long value
*/
public abstract long longValue();
/**
* Return the value of this <code>Number</code> as a <code>float</code>.
*
* @return the float value
*/
public abstract float floatValue();
/**
* Return the value of this <code>Number</code> as a <code>float</code>.
*
* @return the double value
*/
public abstract double doubleValue();
/**
* 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 value of this <code>Number</code> as a <code>short</code>.
**/
/**
* 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();
}
/** 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>.
**/
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>.
**/
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>.
**/
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>.
**/
public abstract double doubleValue();
private static final long serialVersionUID = -8742448824652078965L;
}

8
libjava/java/lang/String.java
View file

@ -1,4 +1,4 @@
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
This file is part of libgcj.
@ -112,6 +112,12 @@ public final class String implements Serializable, Comparable, CharSequence
init(data, offset, count, false);
}
// This is used by Integer.toString(int,int).
String (char[] data, int offset, int count, boolean dont_copy)
{
init(data, offset, count, dont_copy);
}
public String (byte[] byteArray)
{
this (byteArray, 0, byteArray.length);

27
libjava/java/lang/Void.java
View file

@ -1,5 +1,5 @@
/* java.lang.Void
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
/* Void.class - defines void.class
Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -38,30 +38,29 @@ exception statement from your version. */
package java.lang;
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Complete.
*/
/**
* Void is a placeholder class so that the variable Void.TYPE can be
* supported for reflection return types.
* Void is a placeholder class so that the variable <code>Void.TYPE</code>
* (also available as <code>void.class</code>) can be supported for
* reflection return types.
*
* <p>This class could be Serializable, but that is up to Sun.
*
* @author Paul Fisher
* @author John Keiser
* @author Per Bothner <bothner@cygnus.com>
* @since JDK1.1
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.1
* @status updated to 1.4
*/
public final class Void
{
/**
* The return type <code>void</code> is represented by this
* The return type <code>void</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('V');
/**
* Don't allow Void objects to be made.
* Void is non-instantiable.
*/
private Void() { }
}

3
libjava/java/lang/natString.cc
View file

@ -456,9 +456,8 @@ java::lang::String::init(jcharArray chars, jint offset, jint count,
}
else
{
JvAssert (offset == 0);
array = chars;
pdst = elements (array);
pdst = &(elements(array)[offset]);
}
data = array;