mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-01-19 03:53:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

javaprims.h: Rebuilt class list.

Browse Source 
* gcj/javaprims.h: Rebuilt class list.
	* Makefile.in: Rebuilt.
	* Makefile.am (core_java_source_files): Added VMClassLoader.
	* java/lang/VMClassLoader.java: New file.
	* java/lang/Boolean.java: Merged with Classpath.
	* java/lang/Byte.java: Merged with Classpath.
	* java/lang/Integer.java: Merged with Classpath.
	* java/lang/Long.java: Merged with Classpath.
	* java/lang/Number.java: Merged with Classpath.
	* java/lang/Short.java: Merged with Classpath.

From-SVN: r44274
This commit is contained in:
Tom Tromey 2001-07-23 20:01:29 +00:00 committed by Tom Tromey
parent 57de7530c4
commit e109d16f8c
12 changed files with 1763 additions and 750 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
libjava/ChangeLog
View File

@ -1,3 +1,16 @@
2001-07-23 Tom Tromey <tromey@redhat.com>
* gcj/javaprims.h: Rebuilt class list.
* Makefile.in: Rebuilt.
* Makefile.am (core_java_source_files): Added VMClassLoader.
* java/lang/VMClassLoader.java: New file.
* java/lang/Boolean.java: Merged with Classpath.
* java/lang/Byte.java: Merged with Classpath.
* java/lang/Integer.java: Merged with Classpath.
* java/lang/Long.java: Merged with Classpath.
* java/lang/Number.java: Merged with Classpath.
* java/lang/Short.java: Merged with Classpath.
2001-07-22 Jeff Sturm <jsturm@one-point.com>
* configure.host: Enable hash synchronization for alpha*-*.

1
libjava/Makefile.am
View File

@ -847,6 +847,7 @@ java/lang/UnsatisfiedLinkError.java \
java/lang/UnsupportedOperationException.java \
java/lang/VerifyError.java \
java/lang/VirtualMachineError.java \
java/lang/VMClassLoader.java \
java/lang/Void.java \
java/io/BufferedInputStream.java \
java/io/BufferedOutputStream.java \

6
libjava/Makefile.in
View File

@ -617,6 +617,7 @@ java/lang/UnsatisfiedLinkError.java \
java/lang/UnsupportedOperationException.java \
java/lang/VerifyError.java \
java/lang/VirtualMachineError.java \
java/lang/VMClassLoader.java \
java/lang/Void.java \
java/io/BufferedInputStream.java \
java/io/BufferedOutputStream.java \
@ -1663,8 +1664,9 @@ DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
.deps/java/lang/ThreadLocal.P .deps/java/lang/Throwable.P \
.deps/java/lang/UnknownError.P .deps/java/lang/UnsatisfiedLinkError.P \
.deps/java/lang/UnsupportedOperationException.P \
.deps/java/lang/VerifyError.P .deps/java/lang/VirtualMachineError.P \
.deps/java/lang/Void.P .deps/java/lang/dtoa.P .deps/java/lang/e_acos.P \
.deps/java/lang/VMClassLoader.P .deps/java/lang/VerifyError.P \
.deps/java/lang/VirtualMachineError.P .deps/java/lang/Void.P \
.deps/java/lang/dtoa.P .deps/java/lang/e_acos.P \
.deps/java/lang/e_asin.P .deps/java/lang/e_atan2.P \
.deps/java/lang/e_exp.P .deps/java/lang/e_fmod.P \
.deps/java/lang/e_log.P .deps/java/lang/e_pow.P \

1
libjava/gcj/Makefile.in
View File

@ -95,6 +95,7 @@ LIBGCJTESTSPEC = @LIBGCJTESTSPEC@
LIBGCJ_CFLAGS = @LIBGCJ_CFLAGS@
LIBGCJ_CXXFLAGS = @LIBGCJ_CXXFLAGS@
LIBGCJ_JAVAFLAGS = @LIBGCJ_JAVAFLAGS@
LIBICONV = @LIBICONV@
LIBLTDL = @LIBLTDL@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@

3
libjava/gcj/javaprims.h
View File

@ -197,10 +197,13 @@ extern "Java"
class Thread;
class ThreadDeath;
class ThreadGroup;
class ThreadLocal;
class ThreadLocal$Value;
class Throwable;
class UnknownError;
class UnsatisfiedLinkError;
class UnsupportedOperationException;
class VMClassLoader;
class VerifyError;
class VirtualMachineError;
class Void;

251
libjava/java/lang/Boolean.java
View File

@ -1,100 +1,177 @@
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
/* Boolean.java -- object wrapper for boolean
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.lang;
import java.io.Serializable;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 3, 1998.
*/
/* 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.
*/
public final class Boolean extends Object implements Serializable
* Instances of class <code>Boolean</code> represent primitive
* <code>boolean</code> values.
*
* @author Paul Fisher
* @since JDK1.0
*/
public final class Boolean implements Serializable
{
public static final Boolean FALSE = new Boolean(false);
public static final Boolean TRUE = new Boolean(true);
// This initialization is seemingly circular, but it is accepted
// by javac, and is handled specially by gcc.
public static final Class TYPE = boolean.class;
/* The boolean value of the instance. */
private boolean value;
private static final long serialVersionUID = -3665804199014368530L;
public Boolean(boolean boolVal)
{
value = boolVal;
}
public Boolean(String strVal)
{
value = (strVal == null ? false : strVal.equalsIgnoreCase("true"));
}
public boolean booleanValue()
{
return value;
}
public boolean equals(Object obj)
{
/* Don't need to compare obj to null as instanceof will do this. */
if (obj instanceof Boolean)
return value == ((Boolean) obj).value;
return false;
}
public static boolean getBoolean(String property)
{
/* TBD: If a security manager exists and it doesn't permit accessing
* the property, it will throw an exception. Should we catch it?
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>.
*/
try
{
String val = System.getProperty(property);
return val == null ? false : val.equalsIgnoreCase("true");
}
catch (SecurityException e)
{
return false;
}
}
public int hashCode()
{
/* These values are from the Java Lang. Spec. (Sec 20.4.7).
* TBD: They could be made private static final fields but they're only
* used here (and shouldn't be used anywhere else), though it might be
* useful to grep on something like JAVA_HASH_* values for us as
* developers.
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>.
*/
return value ? 1231 : 1237;
}
public static final Boolean FALSE = new Boolean(false);
public String toString()
{
return value ? "true" : "false";
}
/**
* The primitive type <code>boolean</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass("boolean");
/**
* 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);
}
public static Boolean valueOf(String str)
{
if (str == null)
return FALSE;
else
/* This returns a Boolean (big B), not a boolean (little b). */
return str.equalsIgnoreCase("true") ? TRUE : FALSE;
}
/**
* Return the primitive <code>boolean</code> value of this
* <code>Boolean</code> object.
*/
public boolean booleanValue() {
return value;
}
/**
* Returns the Boolean <code>TRUE</code> if the given boolean is
* <code>true</code>, otherwise it will return the Boolean
* <code>FALSE</code>.
*
* @since 1.4
*/
public static Boolean valueOf(boolean b) {
return b ? TRUE : FALSE;
}
/**
* Returns the Boolean <code>TRUE</code> if and only if the given
* String is equal, ignoring case, to the the String "true", otherwise
* it will return the Boolean <code>FALSE</code>.
*/
public static Boolean valueOf(String s) {
return "true".equalsIgnoreCase(s) ? TRUE : FALSE;
}
/**
* Returns the integer <code>1231</code> if this object represents
* the primitive <code>true</code> and the integer <code>1237</code>
* otherwise.
*/
public int hashCode() {
return (value) ? 1231 : 1237;
}
/**
* If the <code>obj</code> is an instance of <code>Boolean</code> and
* has the same primitive value as this object then <code>true</code>
* is returned. In all other cases, including if the <code>obj</code>
* is <code>null</code>, <code>false</code> is returned.
*
* @param obj possibly an instance of any <code>Class</code>
* @return <code>false</code> is <code>obj</code> is an instance of
* <code>Boolean</code> and has the same primitive value as this
* object.
*/
public boolean equals(Object obj) {
return (obj instanceof Boolean && value == ((Boolean)obj).value);
}
/**
* If the value of the system property <code>name</code> matches
* "true" ignoring case then the function returns <code>true</code>.
*/
public static boolean getBoolean(String name) {
String val = System.getProperty(name);
return ("true".equalsIgnoreCase(val));
}
/**
* Returns "true" if the value of the give boolean is <code>true</code> and
* returns "false" if the value of the given boolean is <code>false</code>.
*
* @since 1.4
*/
public static String toString(boolean b)
{
return b ? "true" : "false";
}
/**
* Returns "true" if the value of this object is <code>true</code> and
* returns "false" if the value of this object is <code>false</code>.
*/
public String toString()
{
return (value) ? "true" : "false";
}
}

333
libjava/java/lang/Byte.java
View File

@ -1,88 +1,193 @@
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
/* Byte.java -- object wrapper for byte
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.lang;
/**
* @author Per Bothner <bothner@cygnus.com>
* @date April 17, 1998.
* Instances of class <code>Byte</code> represent primitive <code>byte</code>
* values.
*
* Additionally, this class provides various helper functions and variables
* useful to bytes.
*
* @author Paul Fisher
* @author John Keiser
* @author Per Bothner
* @since JDK 1.0
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
* Includes JDK 1.2 methods.
*/
public final class Byte extends Number implements Comparable
public final class Byte extends Number implements Comparable
{
byte value;
static final long serialVersionUID = -7183698231559129828L;
public final static byte MIN_VALUE = -128;
public final static byte MAX_VALUE = 127;
/**
* The minimum value a <code>byte</code> can represent is -128.
*/
public static final byte MIN_VALUE = -128;
// This initialization is seemingly circular, but it is accepted
// by javac, and is handled specially by gcc.
public static final Class TYPE = byte.class;
/**
* The maximum value a <code>byte</code> can represent is 127.
*/
public static final byte MAX_VALUE = 127;
private static final long serialVersionUID = -7183698231559129828L;
/**
* The primitive type <code>byte</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass("byte");
public Byte(byte value)
/**
* The immutable value of this Byte.
*/
private final byte value;
/**
* Create a <code>Byte</code> object representing the value of the
* <code>byte</code> argument.
*
* @param value the value to use
*/
public Byte(byte value)
{
this.value = value;
}
public Byte(String str)
throws NumberFormatException
/**
* Create a <code>Byte</code> object representing the value specified
* by the <code>String</code> argument.
*
* @param s the string to convert.
*/
public Byte(String s) throws NumberFormatException
{
this.value = parseByte(str, 10);
value = parseByte(s, 10);
}
public byte byteValue()
/**
* Return a hashcode representing this Object.
*
* <code>Byte</code>'s hash code is calculated by simply returning its
* value.
*
* @return this Object's hash code.
*/
public int hashCode()
{
return value;
}
public short shortValue()
/**
* Returns <code>true</code> if <code>obj</code> is an instance of
* <code>Byte</code> and represents the same byte value.
* @return whether these Objects are semantically equal.
*/
public boolean equals(Object obj)
{
return value;
return ((obj instanceof Byte) && (value == ((Byte)obj).byteValue()));
}
public int intValue()
/**
* Converts the <code>byte</code> to a <code>String</code> and assumes
* a radix of 10.
* @param i the <code>byte</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toString(byte i)
{
return value;
return Integer.toString ((int) i);
}
public long longValue ()
/**
* Converts the <code>Byte</code> value to a <code>String</code> and
* assumes a radix of 10.
* @return the <code>String</code> representation of this <code>Byte</code>.
*/
public String toString()
{
return value;
return Integer.toString ((int) value);
}
/**
* Creates a new <code>Byte</code> object using the <code>String</code>,
* assuming a radix of 10.
* @param s the <code>String</code> to convert.
* @return the new <code>Byte</code>.
* @see #Byte(java.lang.String)
* @see #parseByte(java.lang.String)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>byte</code>.
*/
public static Byte valueOf(String s) throws NumberFormatException
{
return new Byte(parseByte(s));
}
public float floatValue ()
/**
* Creates a new <code>Byte</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>Byte</code>.
* @see #parseByte(java.lang.String,int)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>byte</code>.
*/
public static Byte valueOf(String s, int radix)
throws NumberFormatException
{
return (float) value;
return new Byte(parseByte(s, radix));
}
public double doubleValue ()
/**
* Converts the specified <code>String</code> into a <code>byte</code>.
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>byte</code> value of the <code>String</code>
* argument.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>byte</code>.
*/
public static byte parseByte(String s) throws NumberFormatException
{
return (double) value;
return parseByte(s, 10);
}
public static Byte decode(String str)
throws NumberFormatException
{
int i = (Integer.decode(str)).intValue();
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return new Byte((byte) i);
}
public static byte parseByte(String str, int radix)
throws NumberFormatException
/**
* Converts the specified <code>String</code> into a <code>byte</code>
* using the specified radix (base).
*
* @param str 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>byte</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>byte</code>.
*/
public static byte parseByte(String str, int radix)
throws NumberFormatException
{
int i = Integer.parseInt(str, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
@ -90,55 +195,109 @@ public final class Byte extends Number implements Comparable
return (byte) i;
}
public static byte parseByte(String str)
throws NumberFormatException
/**
* Convert the specified <code>String</code> into a <code>Byte</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>
* <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 a <code>Byte</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>byte</code>.
*/
public static Byte decode(String str) throws NumberFormatException
{
return parseByte(str, 10);
int i = (Integer.decode(str)).intValue();
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return new Byte((byte) i);
}
public static Byte valueOf(String str, int radix)
throws NumberFormatException
{
return new Byte(parseByte(str, radix));
}
public static Byte valueOf(String str)
throws NumberFormatException
{
return valueOf(str, 10);
}
// Added in JDK 1.2
public int compareTo(Byte anotherByte)
{
return this.value - anotherByte.value;
}
// Added in JDK 1.2
/** @throws ClassCastException */
public int compareTo(Object o)
{
return this.value - ((Byte) o).value;
}
public boolean equals(Object obj)
{
return (obj instanceof Byte) && ((Byte)obj).value == value;
}
// Verified that hashCode is returns plain value (see Boolean_1 test).
public int hashCode()
/** Return the value of this <code>Byte</code> as an <code>short</code>.
** @return the value of this <code>Byte</code> as an <code>short</code>.
**/
public byte byteValue()
{
return value;
}
public String toString()
/** Return the value of this <code>Byte</code> as an <code>short</code>.
** @return the value of this <code>Byte</code> as an <code>short</code>.
**/
public short shortValue()
{
return Integer.toString((int) value);
return value;
}
public static String toString(byte value)
/** Return the value of this <code>Byte</code> as an <code>int</code>.
** @return the value of this <code>Byte</code> as an <code>int</code>.
**/
public int intValue()
{
return Integer.toString((int) value);
return value;
}
/** Return the value of this <code>Byte</code> as a <code>long</code>.
** @return the value of this <code>Byte</code> as a <code>long</code>.
**/
public long longValue()
{
return value;
}
/** Return the value of this <code>Byte</code> as a <code>float</code>.
** @return the value of this <code>Byte</code> as a <code>float</code>.
**/
public float floatValue()
{
return value;
}
/** Return the value of this <code>Byte</code> as a <code>double</code>.
** @return the value of this <code>Byte</code> as a <code>double</code>.
**/
public double doubleValue()
{
return value;
}
/**
* Compare two Bytes numerically by comparing their
* <code>byte</code> values.
* @return a positive value if this <code>Byte</code> is greater
* in value than the argument <code>Byte</code>; a negative value
* if this <code>Byte</code> is smaller in value than the argument
* <code>Byte</code>; and <code>0</code>, zero, if this
* <code>Byte</code> is equal in value to the argument
* <code>Byte</code>.
*/
public int compareTo(Byte b)
{
return (int)(value - b.byteValue());
}
/**
* Behaves like <code>compareTo(java.lang.Byte)</code> unless the Object
* is not a <code>Byte</code>. Then it throws a
* <code>ClassCastException</code>.
* @exception ClassCastException if the argument is not a
* <code>Byte</code>.
*/
public int compareTo(Object o)
{
return compareTo((Byte)o);
}
}

691
libjava/java/lang/Integer.java
View File

@ -1,246 +1,187 @@
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
/* java.lang.Integer
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.lang;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 11, 1998.
* Instances of class <code>Integer</code> represent primitive
* <code>int</code> values.
*
* Additionally, this class provides various helper functions and variables
* related to ints.
*
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
* @since JDK 1.0
*/
/* 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.
*/
public final class Integer extends Number implements Comparable
{
public static final int MAX_VALUE = 0x7FFFFFFF;
public static final int MIN_VALUE = 0x80000000;
// This initialization is seemingly circular, but it is accepted
// by javac, and is handled specially by gcc.
public static final Class TYPE = int.class;
/* The int value of the instance. */
private int value;
// compatible with JDK 1.0.2+
private static final long serialVersionUID = 1360826667806852920L;
public Integer(int val)
/**
* The minimum value an <code>int</code> can represent is -2147483648.
*/
public static final int MIN_VALUE = 0x80000000;
/**
* The maximum value an <code>int</code> can represent is 2147483647.
*/
public static final int MAX_VALUE = 0x7fffffff;
/**
* The primitive type <code>int</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass ("int");
/**
* The immutable value of this Integer.
*/
private final int value;
/**
* Create an <code>Integer</code> object representing the value of the
* <code>int</code> argument.
*
* @param value the value to use
*/
public Integer(int value)
{
value = val;
this.value = value;
}
public Integer(String str) throws NumberFormatException
/**
* 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.
*/
public Integer(String s) throws NumberFormatException
{
value = parseInt(str, 10);
}
public byte byteValue()
{
return (byte) value;
}
public double doubleValue()
{
return (double) value;
}
public float floatValue()
{
return (float) value;
}
public int intValue()
{
return value;
}
public long longValue()
{
return value;
}
public short shortValue()
{
return (short) value;
}
// Added in JDK 1.2
public int compareTo(Integer anotherInteger)
{
if (this.value == anotherInteger.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow the int.
if (this.value > anotherInteger.value)
return 1;
return -1;
}
// Added in JDK 1.2
/** @throws ClassCastException */
public int compareTo(Object o)
{
return this.compareTo((Integer) o);
}
public static Integer decode(String str) throws NumberFormatException
{
boolean isNeg = false;
int index = 0;
int radix = 10;
final int len;
if ((len = str.length()) == 0)
throw new NumberFormatException();
// Negative numbers are always radix 10.
if (str.charAt(0) == '-')
{
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')
{
radix = 16;
index++;
}
else
radix = 8;
}
if (index >= len)
throw new NumberFormatException();
return new Integer(parseInt(str, index, len, isNeg, radix));
}
public boolean equals(Object obj)
{
return (obj instanceof Integer && ((Integer) obj).value == value);
}
public static Integer getInteger(String prop)
{
return getInteger(prop, null);
}
public static Integer getInteger(String prop, int defval)
{
Integer val = getInteger(prop, null);
return val == null ? new Integer(defval) : val;
}
public static Integer getInteger(String prop, Integer defobj)
{
try
{
String val = System.getProperty(prop);
if (val != null)
return decode(val);
}
catch (NumberFormatException ex)
{
}
return defobj;
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;
}
public static int parseInt(String str) throws NumberFormatException
/**
* 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 parseInt(str, 10);
return obj instanceof Integer && value == ((Integer)obj).value;
}
public static int parseInt(String str, int radix) throws NumberFormatException
/**
* 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)
{
final int len;
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 getInteger(nm, null);
}
private static int parseInt(String str, int index, int len, boolean isNeg,
int radix) throws NumberFormatException
/**
* 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)
{
int val = 0;
int digval;
Integer result = getInteger(nm, null);
return (result == null) ? new Integer(val) : result;
}
int max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
/**
* 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
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
return isNeg ? -(val) : val;
}
public static String toBinaryString(int num)
{
return toUnsignedString(num, 1);
}
public static String toHexString(int num)
{
return toUnsignedString(num, 4);
}
public static String toOctalString(int num)
{
return toUnsignedString(num, 3);
}
private static String toUnsignedString(int num, int exp)
@ -260,16 +201,70 @@ public final class Integer extends Number implements Comparable
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(this.value);
}
public static String toString(int num)
{
return String.valueOf (num);
return toString (value);
}
/**
* Converts the <code>int</code> to a <code>String</code> using
* the specified radix (base).
* @param i the <code>int</code> to convert to <code>String</code>.
* @param radix the radix (base) to use in the conversion.
* @return the <code>String</code> representation of the argument.
*/
public static String toString(int num, int radix)
{
// Use optimized method for the typical case.
@ -310,14 +305,266 @@ public final class Integer extends Number implements Comparable
return String.valueOf(buffer, i, 33-i);
}
public static Integer valueOf(String str) 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>.
* @see #Integer(java.lang.String)
* @see #parseInt(java.lang.String)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
*/
public static Integer valueOf(String s) throws NumberFormatException
{
return new Integer(parseInt(str, 10));
return new Integer(parseInt(s));
}
public static Integer valueOf(String str, int radix)
throws NumberFormatException
/**
* 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>.
*/
public static Integer valueOf(String s, int radix)
throws NumberFormatException
{
return new Integer(parseInt(str, radix));
return new Integer(parseInt(s, radix));
}
/**
* Converts the specified <code>String</code> into an <code>int</code>.
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>int</code> value of the <code>String</code>
* argument.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as an <code>int</code>.
*/
public static int parseInt(String s) throws NumberFormatException
{
return parseInt(s, 10);
}
/**
* Converts the specified <code>String</code> into an <code>int</code>
* using the 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>.
*/
public static int parseInt(String str, int radix)
throws NumberFormatException
{
final int len;
if ((len = str.length()) == 0 ||
radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
throw new NumberFormatException();
boolean isNeg = false;
int index = 0;
if (str.charAt(index) == '-')
if (len > 1)
{
isNeg = true;
index++;
}
else
throw new NumberFormatException();
return parseInt(str, index, len, isNeg, radix);
}
private static int parseInt(String str, int index, int len, boolean isNeg,
int radix)
throws NumberFormatException
{
int val = 0;
int digval;
int max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
}
return 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);
}
}

656
libjava/java/lang/Long.java
View File

@ -1,260 +1,203 @@
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
/* java.lang.Long
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.lang;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 18, 1998.
* Instances of class <code>Double</code> represent primitive
* <code>double</code> values.
*
* Additionally, this class provides various helper functions and variables
* related to longs.
*
* @author Paul Fisher
* @author John Keiser
* @author Warren Levy
* @since JDK 1.0
*/
/* 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.
*/
public final class Long extends Number implements Comparable
{
public static final long MAX_VALUE = 0x7FFFFFFFFFFFFFFFL;
// compatible with JDK 1.0.2+
static final long serialVersionUID = 4290774380558885855L;
/**
* The minimum value a <code>long</code> can represent is
* -9223372036854775808.
*/
public static final long MIN_VALUE = 0x8000000000000000L;
// This initialization is seemingly circular, but it is accepted
// by javac, and is handled specially by gcc.
public static final Class TYPE = long.class;
/**
* The maximum value a <code>long</code> can represent is
* 9223372036854775807.
*/
public static final long MAX_VALUE = 0x7fffffffffffffffL;
/* The long value of the instance. */
private long value;
/**
* The primitive type <code>long</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass ("long");
private static final long serialVersionUID = 4290774380558885855L;
/**
* The immutable value of this Long.
*/
private final long value;
public Long(long val)
/**
* Create a <code>Long</code> object representing the value of the
* <code>long</code> argument.
*
* @param value the value to use
*/
public Long(long value)
{
value = val;
this.value = value;
}
public Long(String str) throws NumberFormatException
/**
* Create a <code>Long</code> object representing the value of the
* argument after conversion to a <code>long</code>.
*
* @param s the string to convert.
*/
public Long(String s) throws NumberFormatException
{
value = parseLong(str, 10);
}
public byte byteValue()
{
return (byte) value;
}
public double doubleValue()
{
return (double) value;
}
public float floatValue()
{
return (float) value;
}
public int intValue()
{
return (int) value;
}
public long longValue()
{
return value;
}
public short shortValue()
{
return (short) value;
}
// Added in JDK 1.2
public int compareTo(Long anotherLong)
{
if (this.value == anotherLong.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow the long.
if (this.value > anotherLong.value)
return 1;
return -1;
}
// Added in JDK 1.2
/** @throws ClassCastException */
public int compareTo(Object o)
{
return this.compareTo((Long) o);
}
// Added in JDK 1.2
public static Long decode(String str) throws NumberFormatException
{
boolean isNeg = false;
int index = 0;
int radix = 10;
final int len;
if ((len = str.length()) == 0)
throw new NumberFormatException();
// Negative numbers are always radix 10.
if (str.charAt(0) == '-')
{
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 Long(0L);
index++;
if (str.charAt(index) == 'x')
{
radix = 16;
index++;
}
else
radix = 8;
}
if (index >= len)
throw new NumberFormatException();
return new Long(parseLong(str, index, len, isNeg, radix));
value = parseLong(s, 10);
}
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Long</code>, and represents
* the same primitive <code>long</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
*/
public boolean equals(Object obj)
{
return (obj instanceof Long && ((Long) obj).value == value);
}
public static Long getLong(String prop)
{
return getLong(prop, null);
}
public static Long getLong(String prop, long defval)
{
Long val = getLong(prop, null);
return val == null ? new Long(defval) : val;
}
public static Long getLong(String prop, Long defobj)
{
try
{
String val = System.getProperty(prop);
if (val != null)
return decode(val);
}
catch (NumberFormatException ex)
{
}
return defobj;
return obj instanceof Long && ((Long)obj).value == value;
}
/**
* Return a hashcode representing this Object.
*
* <code>Long</code>'s hash code is calculated by simply returning its
* value.
*
* @return this Object's hash code.
*/
public int hashCode()
{
return (int)(this.longValue()^(this.longValue()>>>32));
return (int)(value^(value>>>32));
}
public static long parseLong(String str) throws NumberFormatException
/**
* Get the specified system property as a <code>Long</code>.
*
* A method similar to <code>Integer</code>'s <code>decode()</code> will be
* used to interpret the value of the property.
*
* @param nm the name of the system property
* @return the system property as an <code>Long</code>, or
* <code>null</code> if the property is not found or cannot be
* decoded as a <code>Long</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.Integer#decode(int)
*/
public static Long getLong(String nm)
{
return parseLong(str, 10);
return getLong(nm, null);
}
public static long parseLong(String str, int radix)
throws NumberFormatException
/**
* Get the specified system property as an <code>Long</code>, or use a
* default <code>long</code> value if the property is not found or is not
* decodable.
*
* A method similar to <code>Integer</code>'s <code>decode()</code> will be
* used to interpret the value of the property.
*
* @param nm the name of the system property
* @param val the default value to use if the property is not found or not
* a number.
* @return the system property as a <code>Long</code>, or the default
* value if the property is not found or cannot be decoded as a
* <code>Long</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.Integer#decode(int)
* @see #getLong(java.lang.String,java.lang.Long)
*/
public static Long getLong(String nm, long val)
{
final int len;
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 parseLong(str, index, len, isNeg, radix);
Long result = getLong(nm, null);
return (result == null) ? new Long(val) : result;
}
private static long parseLong(String str, int index, int len, boolean isNeg,
int radix) throws NumberFormatException
/**
* Get the specified system property as an <code>Long</code>, or use a
* default <code>Long</code> value if the property is not found or is
* not decodable.
*
* The <code>decode()</code> method will be used to interpret the value of
* the property.
*
* @param nm the name of the system property
* @param val the default value to use if the property is not found or not
* a number.
* @return the system property as an <code>Long</code>, or the default
* value if the property is not found or cannot be decoded as an
* <code>Long</code>.
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.Integer#decode(int)
* @see #getLong(java.lang.String,long)
*/
public static Long getLong(String nm, Long def)
{
long val = 0;
int digval;
long max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
String val = System.getProperty(nm);
if (val == null)
return def;
try
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
return decode(nm);
}
catch (NumberFormatException e)
{
return def;
}
return isNeg ? -(val) : val;
}
public static String toBinaryString(long num)
{
return toUnsignedString(num, 1);
}
public static String toHexString(long num)
{
return toUnsignedString(num, 4);
}
public static String toOctalString(long num)
{
return toUnsignedString(num, 3);
}
private static String toUnsignedString(long num, int exp)
{
// Use an array large enough for a binary number.
int radix = 1 << exp;
long mask = radix - 1;
int mask = radix - 1;
char[] buffer = new char[64];
int i = 64;
do
{
buffer[--i] = Character.forDigit((int) (num & mask), radix);
buffer[--i] = Character.forDigit((int) num & mask, radix);
num = num >>> exp;
}
while (num != 0);
@ -262,11 +205,44 @@ public final class Long extends Number implements Comparable
return String.valueOf(buffer, i, 64-i);
}
public String toString()
/**
* Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 16.
* @param i the <code>long</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toHexString(long i)
{
return toString(this.value);
return toUnsignedString(i, 4);
}
/**
* Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 8.
* @param i the <code>long</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toOctalString(long i)
{
return toUnsignedString(i, 3);
}
/**
* Converts the <code>long</code> to a <code>String</code> assuming it is
* unsigned in base 2.
* @param i the <code>long</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toBinaryString(long i) {
return toUnsignedString(i, 1);
}
/**
* Converts the <code>long</code> to a <code>String</code> and assumes
* a radix of 10.
* @param num the <code>long</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toString(long num)
{
// Use the Integer toString for efficiency if possible.
@ -304,6 +280,23 @@ public final class Long extends Number implements Comparable
return String.valueOf(buffer, i, 20-i);
}
/**
* Converts the <code>Long</code> value to a <code>String</code> and
* assumes a radix of 10.
* @return the <code>String</code> representation of this <code>Long</code>.
*/
public String toString()
{
return toString(value);
}
/**
* Converts the <code>long</code> to a <code>String</code> using
* the specified radix (base).
* @param num the <code>long</code> to convert to <code>String</code>.
* @param radix the radix (base) to use in the conversion.
* @return the <code>String</code> representation of the argument.
*/
public static String toString(long num, int radix)
{
// Use optimized method for the typical case.
@ -348,15 +341,242 @@ public final class Long extends Number implements Comparable
return String.valueOf(buffer, i, 65-i);
}
public static Long valueOf(String str) throws NumberFormatException
/**
* Creates a new <code>Long</code> object using the <code>String</code>,
* assuming a radix of 10.
* @param s the <code>String</code> to convert.
* @return the new <code>Long</code>.
* @see #Long(java.lang.String)
* @see #parseLong(java.lang.String)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>long</code>.
*/
public static Long valueOf(String s) throws NumberFormatException
{
return new Long(parseLong(str, 10));
return new Long(parseLong(s));
}
public static Long valueOf(String str, int radix)
throws NumberFormatException
/**
* Creates a new <code>Long</code> object using the <code>String</code>
* and specified radix (base).
* @param s the <code>String</code> to convert.
* @param radix the radix (base) to convert with.
* @return the new <code>Long</code>.
* @see #parseLong(java.lang.String,int)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>long</code>.
*/
public static Long valueOf(String s, int radix) throws NumberFormatException
{
return new Long(parseLong(str, radix));
return new Long(parseLong(s, radix));
}
/**
* Converts the specified <code>String</code> into a <code>long</code>.
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>long</code> value of the <code>String</code>
* argument.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>long</code>.
*/
public static long parseLong(String s) throws NumberFormatException
{
return parseLong(s, 10);
}
/**
* Converts the specified <code>String</code> into a <code>long</code>
* using the 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>long</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>long</code>.
*/
public static long parseLong(String str, int radix)
throws NumberFormatException
{
final int len;
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 parseLong(str, index, len, isNeg, radix);
}
public static Long decode(String str) throws NumberFormatException
{
boolean isNeg = false;
int index = 0;
int radix = 10;
final int len;
if ((len = str.length()) == 0)
throw new NumberFormatException();
// Negative numbers are always radix 10.
if (str.charAt(0) == '-')
{
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 Long(0L);
index++;
if (str.charAt(index) == 'x')
{
radix = 16;
index++;
}
else
radix = 8;
}
if (index >= len)
throw new NumberFormatException();
return new Long(parseLong(str, index, len, isNeg, radix));
}
private static long parseLong(String str, int index, int len, boolean isNeg,
int radix) throws NumberFormatException
{
long val = 0;
int digval;
long max = MAX_VALUE / radix;
// We can't directly write `max = (MAX_VALUE + 1) / radix'.
// So instead we fake it.
if (isNeg && MAX_VALUE % radix == radix - 1)
++max;
for ( ; index < len; index++)
{
if (val < 0 || val > max)
throw new NumberFormatException();
if ((digval = Character.digit(str.charAt(index), radix)) < 0)
throw new NumberFormatException();
// Throw an exception for overflow if result is negative.
// However, we special-case the most negative value.
val = val * radix + digval;
if (val < 0 && (! isNeg || val != MIN_VALUE))
throw new NumberFormatException();
}
return isNeg ? -(val) : val;
}
/** Return the value of this <code>Long</code> as an <code>short</code>.
** @return the value of this <code>Long</code> as an <code>short</code>.
**/
public byte byteValue()
{
return (byte) value;
}
/** Return the value of this <code>Long</code> as an <code>short</code>.
** @return the value of this <code>Long</code> as an <code>short</code>.
**/
public short shortValue()
{
return (short) value;
}
/** Return the value of this <code>Long</code> as an <code>int</code>.
** @return the value of this <code>Long</code> as an <code>int</code>.
**/
public int intValue()
{
return (int) value;
}
/** Return the value of this <code>Long</code> as a <code>long</code>.
** @return the value of this <code>Long</code> as a <code>long</code>.
**/
public long longValue()
{
return value;
}
/** Return the value of this <code>Long</code> as a <code>float</code>.
** @return the value of this <code>Long</code> as a <code>float</code>.
**/
public float floatValue()
{
return value;
}
/** Return the value of this <code>Long</code> as a <code>double</code>.
** @return the value of this <code>Long</code> as a <code>double</code>.
**/
public double doubleValue()
{
return value;
}
/**
* Compare two Longs numerically by comparing their
* <code>long</code> values.
* @return a positive value if this <code>Long</code> is greater
* in value than the argument <code>Long</code>; a negative value
* if this <code>Long</code> is smaller in value than the argument
* <code>Long</code>; and <code>0</code>, zero, if this
* <code>Long</code> is equal in value to the argument
* <code>Long</code>.
*
* @since 1.2
*/
public int compareTo(Long l)
{
if (this.value == l.value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow the long.
if (this.value > l.value)
return 1;
return -1;
}
/**
* Behaves like <code>compareTo(java.lang.Long)</code> unless the Object
* is not a <code>Long</code>. Then it throws a
* <code>ClassCastException</code>.
* @exception ClassCastException if the argument is not a
* <code>Long</code>.
*
* @since 1.2
*/
public int compareTo(Object o)
{
return compareTo((Long)o);
}
}

86
libjava/java/lang/Number.java
View File

@ -1,41 +1,83 @@
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
/* java.lang.Number
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.lang;
import java.io.Serializable;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 2, 1998.
*/
/* 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.
*/
** 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
**/
public abstract class Number implements Serializable
{
public byte byteValue() // Became non-abstract in JDK 1.2
/** Return the value of this <code>Number</code> as a <code>byte</code>.
** @return the value of this <code>Number</code> as a <code>byte</code>.
**/
public byte byteValue()
{
return (byte) intValue();
}
public abstract double doubleValue();
public abstract float floatValue();
public abstract int intValue();
public abstract long longValue();
public short shortValue() // Became non-abstract in JDK 1.2
/** Return the value of this <code>Number</code> as a <code>short</code>.
** @return the value of this <code>Number</code> as a <code>short</code>.
**/
public short shortValue()
{
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;
}

387
libjava/java/lang/Short.java
View File

@ -1,144 +1,307 @@
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
/* java.lang.Short
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.lang;
/**
* @author Per Bothner <bothner@cygnus.com>
* @date April 17, 1998.
* Instances of class <code>Short</code> represent primitive
* <code>short</code> values.
*
* Additionally, this class provides various helper functions and variables
* related to shorts.
*
* @author Paul Fisher
* @author John Keiser
* @since JDK 1.0
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
* Includes JDK 1.2 methods.
*/
public final class Short extends Number implements Comparable
{
short value;
static final long serialVersionUID = 7515723908773894738L;
public final static short MIN_VALUE = -32768;
public final static short MAX_VALUE = 32767;
/**
* The minimum value a <code>short</code> can represent is -32768.
*/
public static final short MIN_VALUE = -32768;
// This initialization is seemingly circular, but it is accepted
// by javac, and is handled specially by gcc.
public static final Class TYPE = short.class;
/**
* The minimum value a <code>short</code> can represent is 32767.
*/
public static final short MAX_VALUE = 32767;
private static final long serialVersionUID = 7515723908773894738L;
/**
* The primitive type <code>short</code> is represented by this
* <code>Class</code> object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass("short");
/**
* The immutable value of this Short.
*/
private final short value;
/**
* Create a <code>Short</code> object representing the value of the
* <code>short</code> argument.
*
* @param value the value to use
*/
public Short(short value)
{
this.value = value;
}
public Short(String str)
throws NumberFormatException
/**
* Create a <code>Short</code> object representing the value of the
* argument after conversion to a <code>short</code>.
*
* @param s the string to convert.
*/
public Short(String s) throws NumberFormatException
{
this.value = parseShort(str, 10);
value = parseShort(s, 10);
}
public byte byteValue()
{
return (byte) value;
}
public short shortValue()
{
return value;
}
public int intValue()
{
return value;
}
public long longValue ()
{
return value;
}
public float floatValue ()
{
return (float) value;
}
public double doubleValue ()
{
return (double) value;
}
public static Short decode(String str)
throws NumberFormatException
{
int i = (Integer.decode(str)).intValue();
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return new Short((short) i);
}
public static short parseShort(String str, int radix)
throws NumberFormatException
{
int i = Integer.parseInt(str, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return (short) i;
}
public static short parseShort(String str)
throws NumberFormatException
{
return parseShort(str, 10);
}
public static Short valueOf(String str, int radix)
throws NumberFormatException
{
return new Short(parseShort(str, radix));
}
public static Short valueOf(String str)
throws NumberFormatException
{
return valueOf(str, 10);
}
// Added in JDK 1.2
public int compareTo(Short anotherShort)
{
return this.value - anotherShort.value;
}
// Added in JDK 1.2
/** @throws ClassCastException */
public int compareTo(Object o)
{
return this.value - ((Short) o).value;
}
public boolean equals(Object obj)
{
return (obj instanceof Short) && ((Short) obj).value == value;
}
// Verified that hashCode is returns plain value (see Short_1 test).
/**
* Return a hashcode representing this Object.
*
* <code>Short</code>'s hash code is calculated by simply returning its
* value.
*
* @return this Object's hash code.
*/
public int hashCode()
{
return value;
}
public String toString()
/**
* If the <code>Object</code> is not <code>null</code>, is an
* <code>instanceof</code> <code>Short</code>, and represents
* the same primitive <code>short</code> value return
* <code>true</code>. Otherwise <code>false</code> is returned.
*/
public boolean equals(Object obj)
{
return Integer.toString((int) value);
return obj instanceof Short && ((Short)obj).value == value;
}
public static String toString(short value)
/**
* Converts the <code>short</code> to a <code>String</code> and assumes
* a radix of 10.
* @param i the <code>short</code> to convert to <code>String</code>
* @return the <code>String</code> representation of the argument.
*/
public static String toString(short i)
{
return Integer.toString((int) value);
return Integer.toString((int) i);
}
/**
* Converts the <code>Short</code> value to a <code>String</code> and
* assumes a radix of 10.
* @return the <code>String</code> representation of this <code>Short</code>.
*/
public String toString()
{
return Integer.toString ((int) value);
}
/**
* Creates a new <code>Short</code> object using the <code>String</code>,
* assuming a radix of 10.
* @param s the <code>String</code> to convert.
* @return the new <code>Short</code>.
* @see #Short(java.lang.String)
* @see #parseShort(java.lang.String)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>short</code>.
*/
public static Short valueOf(String s) throws NumberFormatException
{
return new Short(parseShort(s));
}
/**
* Creates a new <code>Short</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>Short</code>.
* @see #parseShort(java.lang.String,int)
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>short</code>.
*/
public static Short valueOf(String s, int radix)
throws NumberFormatException
{
return new Short(parseShort(s, radix));
}
/**
* Converts the specified <code>String</code> into a <code>short</code>.
* This function assumes a radix of 10.
*
* @param s the <code>String</code> to convert
* @return the <code>short</code> value of the <code>String</code>
* argument.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>short</code>.
*/
public static short parseShort(String s) throws NumberFormatException
{
return parseShort(s, 10);
}
/**
* Converts the specified <code>String</code> into a <code>short</code>
* using the 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>short</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>short</code>.
*/
public static short parseShort(String s, int radix)
throws NumberFormatException
{
int i = Integer.parseInt(s, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return (short) i;
}
/**
* Convert the specified <code>String</code> into a <code>Short</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>
* <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 s the <code>String</code> to interpret.
* @return the value of the String as a <code>Short</code>.
* @exception NumberFormatException thrown if the <code>String</code>
* cannot be parsed as a <code>short</code>.
*/
public static Short decode(String s) throws NumberFormatException
{
int i = (Integer.decode(s)).intValue();
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return new Short((short) i);
}
/** Return the value of this <code>Short</code> as an <code>short</code>.
** @return the value of this <code>Short</code> as an <code>short</code>.
**/
public byte byteValue()
{
return (byte) value;
}
/** Return the value of this <code>Short</code> as an <code>short</code>.
** @return the value of this <code>Short</code> as an <code>short</code>.
**/
public short shortValue()
{
return value;
}
/** Return the value of this <code>Short</code> as an <code>int</code>.
** @return the value of this <code>Short</code> as an <code>int</code>.
**/
public int intValue()
{
return value;
}
/** Return the value of this <code>Short</code> as a <code>long</code>.
** @return the value of this <code>Short</code> as a <code>long</code>.
**/
public long longValue()
{
return value;
}
/** Return the value of this <code>Short</code> as a <code>float</code>.
** @return the value of this <code>Short</code> as a <code>float</code>.
**/
public float floatValue()
{
return value;
}
/** Return the value of this <code>Short</code> as a <code>double</code>.
** @return the value of this <code>Short</code> as a <code>double</code>.
**/
public double doubleValue()
{
return value;
}
/**
* Compare two Shorts numerically by comparing their
* <code>short</code> values.
* @return a positive value if this <code>Short</code> is greater
* in value than the argument <code>Short</code>; a negative value
* if this <code>Short</code> is smaller in value than the argument
* <code>Short</code>; and <code>0</code>, zero, if this
* <code>Short</code> is equal in value to the argument
* <code>Short</code>.
*
* @since 1.2
*/
public int compareTo(Short s)
{
return value - s.value;
}
/**
* Behaves like <code>compareTo(java.lang.Short)</code> unless the Object
* is not a <code>Short</code>. Then it throws a
* <code>ClassCastException</code>.
* @exception ClassCastException if the argument is not a
* <code>Short</code>.
*
* @since 1.2
*/
public int compareTo(Object o)
{
return compareTo((Short)o);
}
}

85
libjava/java/lang/VMClassLoader.java Normal file
View File

@ -0,0 +1,85 @@
/*
* java.lang.ClassLoader: part of the Java Class Libraries project.
* Copyright (C) 1998, 2001 Free Software Foundation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
package java.lang;
/**
* java.lang.VMClassLoader is a package-private helper for VMs to implement
* on behalf of java.lang.ClassLoader.
*
* @author John Keiser
* @version 1.1.0, Sep 22 1998
* @since CP1.1
*/
class VMClassLoader {
/**
* Helper to define a class using a string of bytes.
*
* @param name the name to give the class. null if unknown.
* @param data the data representing the classfile, in classfile format.
* @param offset the offset into the data where the classfile starts.
* @param len the length of the classfile data in the array.
* @return the class that was defined.
* @exception ClassFormatError if the byte array is not in proper classfile format.
*/
// Not yet needed for libgcj.
// final static native Class defineClass(ClassLoader cl, String name,
// byte[] data, int offset, int len) throws ClassFormatError;
/**
* Helper to resolve all references to other classes from this class.
* @param c the class to resolve.
*/
// Not yet needed for libgcj.
// final static native void resolveClass(Class c);
/**
* Helper for java.lang.Integer, Byte, etc. to get the TYPE class
* at initialization time. If there are multiple classloaders, this
* method may be called once per ClassLoader per type.
*
* @param type name of the primitive type; i.e. "int", "byte", etc.
* @return a "bogus" class representing the primitive type.
*/
static final Class getPrimitiveClass(String type)
{
if ("int".equals (type))
return int.class;
else if ("long".equals (type))
return int.class;
else if ("boolean".equals (type))
return int.class;
else if ("short".equals (type))
return int.class;
else if ("char".equals (type))
return int.class;
else if ("byte".equals (type))
return int.class;
else if ("float".equals (type))
return int.class;
else if ("double".equals (type))
return int.class;
else if ("void".equals (type))
return int.class;
return null;
}
}