From: Tom Tromey Date: Mon, 23 Jul 2001 20:01:29 +0000 (+0000) Subject: javaprims.h: Rebuilt class list. X-Git-Tag: prereleases/libstdc++-3.0.95~3106 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e109d16f8c56fa61f9b4c15a2426ad07ac88cbd6;p=thirdparty%2Fgcc.git javaprims.h: Rebuilt class list. * 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 --- diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 173a68933d74..56d89c868291 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,16 @@ +2001-07-23 Tom Tromey + + * 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 * configure.host: Enable hash synchronization for alpha*-*. diff --git a/libjava/Makefile.am b/libjava/Makefile.am index 27e92f3d1c8c..debd21904f86 100644 --- a/libjava/Makefile.am +++ b/libjava/Makefile.am @@ -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 \ diff --git a/libjava/Makefile.in b/libjava/Makefile.in index 4c485e87528c..f792edb126b6 100644 --- a/libjava/Makefile.in +++ b/libjava/Makefile.in @@ -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 \ diff --git a/libjava/gcj/Makefile.in b/libjava/gcj/Makefile.in index 4419fa6cd60a..6634da2a957a 100644 --- a/libjava/gcj/Makefile.in +++ b/libjava/gcj/Makefile.in @@ -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@ diff --git a/libjava/gcj/javaprims.h b/libjava/gcj/javaprims.h index a6111f8f777e..5608aed010fb 100644 --- a/libjava/gcj/javaprims.h +++ b/libjava/gcj/javaprims.h @@ -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; diff --git a/libjava/java/lang/Boolean.java b/libjava/java/lang/Boolean.java index 027fd24da830..91edeb92d7c0 100644 --- a/libjava/java/lang/Boolean.java +++ b/libjava/java/lang/Boolean.java @@ -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 - * @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 Boolean represent primitive + * boolean 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 Boolean object representing the + * primitive value true. This instance is returned + * by the static valueOf() methods if they return + * a Boolean representing true. + */ + public static final Boolean TRUE = new Boolean(true); + + /** + * This field is a Boolean object representing the + * primitive value false. This instance is returned + * by the static valueOf() methods if they return + * a Boolean representing false. + */ + public static final Boolean FALSE = new Boolean(false); + + /** + * The primitive type boolean is represented by this + * Class object. + */ + public static final Class TYPE = VMClassLoader.getPrimitiveClass("boolean"); + + /** + * The immutable value of this Boolean. + */ + private final boolean value; + + /** + * Create a Boolean object representing the value of the + * argument value. In general the use of the static + * method valueof(boolean) is more efficient since it will + * not create a new object. + * + * @param value the primitive value of this Boolean + */ + public Boolean(boolean value) { + this.value = value; + } + + /** + * Creates a Boolean object representing the primitive + * true if and only if s matches + * the string "true" ignoring case, otherwise the object will represent + * the primitive false. In general the use of the static + * method valueof(String) is more efficient since it will + * not create a new object. + * + * @param s the String representation of true + * or false */ - 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 Boolean(String s) { + value = "true".equalsIgnoreCase(s); + } + + /** + * Return the primitive boolean value of this + * Boolean object. + */ + public boolean booleanValue() { + return value; + } + + /** + * Returns the Boolean TRUE if the given boolean is + * true, otherwise it will return the Boolean + * FALSE. + * + * @since 1.4 + */ + public static Boolean valueOf(boolean b) { + return b ? TRUE : FALSE; + } + + /** + * Returns the Boolean TRUE if and only if the given + * String is equal, ignoring case, to the the String "true", otherwise + * it will return the Boolean FALSE. + */ + public static Boolean valueOf(String s) { + return "true".equalsIgnoreCase(s) ? TRUE : FALSE; + } + + /** + * Returns the integer 1231 if this object represents + * the primitive true and the integer 1237 + * otherwise. + */ + public int hashCode() { + return (value) ? 1231 : 1237; + } + + /** + * If the obj is an instance of Boolean and + * has the same primitive value as this object then true + * is returned. In all other cases, including if the obj + * is null, false is returned. + * + * @param obj possibly an instance of any Class + * @return false is obj is an instance of + * Boolean 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 name matches + * "true" ignoring case then the function returns true. + */ + 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 true and + * returns "false" if the value of the given boolean is false. + * + * @since 1.4 + */ + public static String toString(boolean b) + { + return b ? "true" : "false"; + } + + /** + * Returns "true" if the value of this object is true and + * returns "false" if the value of this object is false. */ - return value ? 1231 : 1237; - } - - public String toString() - { - return value ? "true" : "false"; - } - - 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; - } + public String toString() + { + return (value) ? "true" : "false"; + } } diff --git a/libjava/java/lang/Byte.java b/libjava/java/lang/Byte.java index 347e2524fae8..964e073b7351 100644 --- a/libjava/java/lang/Byte.java +++ b/libjava/java/lang/Byte.java @@ -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 - * @date April 17, 1998. + * Instances of class Byte represent primitive byte + * 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 byte 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 byte can represent is 127. + */ + public static final byte MAX_VALUE = 127; - private static final long serialVersionUID = -7183698231559129828L; + /** + * The primitive type byte is represented by this + * Class 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 Byte object representing the value of the + * byte argument. + * + * @param value the value to use + */ + public Byte(byte value) { this.value = value; } - public Byte(String str) - throws NumberFormatException + /** + * Create a Byte object representing the value specified + * by the String 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. + * + * Byte'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 true if obj is an instance of + * Byte 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 byte to a String and assumes + * a radix of 10. + * @param i the byte to convert to String + * @return the String representation of the argument. + */ + public static String toString(byte i) { - return value; + return Integer.toString ((int) i); } - public long longValue () + /** + * Converts the Byte value to a String and + * assumes a radix of 10. + * @return the String representation of this Byte. + */ + public String toString() { - return value; + return Integer.toString ((int) value); } - - public float floatValue () + + /** + * Creates a new Byte object using the String, + * assuming a radix of 10. + * @param s the String to convert. + * @return the new Byte. + * @see #Byte(java.lang.String) + * @see #parseByte(java.lang.String) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static Byte valueOf(String s) throws NumberFormatException { - return (float) value; + return new Byte(parseByte(s)); } - public double doubleValue () + /** + * Creates a new Byte object using the String + * and specified radix (base). + * @param s the String to convert. + * @param radix the radix (base) to convert with. + * @return the new Byte. + * @see #parseByte(java.lang.String,int) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static Byte valueOf(String s, int radix) + throws NumberFormatException { - return (double) value; + return new Byte(parseByte(s, radix)); } - public static Byte decode(String str) - throws NumberFormatException + /** + * Converts the specified String into a byte. + * This function assumes a radix of 10. + * + * @param s the String to convert + * @return the byte value of the String + * argument. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static byte parseByte(String s) throws NumberFormatException { - int i = (Integer.decode(str)).intValue(); - if (i < MIN_VALUE || i > MAX_VALUE) - throw new NumberFormatException(); - return new Byte((byte) i); + return parseByte(s, 10); } - public static byte parseByte(String str, int radix) - throws NumberFormatException + /** + * Converts the specified String into a byte + * using the specified radix (base). + * + * @param str the String to convert + * @param radix the radix (base) to use in the conversion + * @return the String argument converted to byte. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + 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 String into a Byte. + * The String may represent decimal, hexadecimal, or + * octal numbers. + * + * The String argument is interpreted based on the leading + * characters. Depending on what the String begins with, the base will be + * interpreted differently: + * + * + * + * + * + * + * + * + *
Leading
Characters		Base
#16
0x16
0X16
08
Anything
Else		10
+ * + * @param str the String to interpret. + * @return the value of the String as a Byte. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + 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 the value of this Byte as an short. + ** @return the value of this Byte as an short. + **/ + public byte byteValue() { - return new Byte(parseByte(str, radix)); + return value; } - public static Byte valueOf(String str) - throws NumberFormatException + /** Return the value of this Byte as an short. + ** @return the value of this Byte as an short. + **/ + public short shortValue() { - return valueOf(str, 10); + return value; } - // Added in JDK 1.2 - public int compareTo(Byte anotherByte) + /** Return the value of this Byte as an int. + ** @return the value of this Byte as an int. + **/ + public int intValue() { - return this.value - anotherByte.value; + return value; } - // Added in JDK 1.2 - /** @throws ClassCastException */ - public int compareTo(Object o) + /** Return the value of this Byte as a long. + ** @return the value of this Byte as a long. + **/ + public long longValue() { - return this.value - ((Byte) o).value; + return value; } - public boolean equals(Object obj) + /** Return the value of this Byte as a float. + ** @return the value of this Byte as a float. + **/ + public float floatValue() { - return (obj instanceof Byte) && ((Byte)obj).value == value; + return value; } - // Verified that hashCode is returns plain value (see Boolean_1 test). - public int hashCode() + /** Return the value of this Byte as a double. + ** @return the value of this Byte as a double. + **/ + public double doubleValue() { return value; } - - public String toString() + + /** + * Compare two Bytes numerically by comparing their + * byte values. + * @return a positive value if this Byte is greater + * in value than the argument Byte; a negative value + * if this Byte is smaller in value than the argument + * Byte; and 0, zero, if this + * Byte is equal in value to the argument + * Byte. + */ + public int compareTo(Byte b) { - return Integer.toString((int) value); + return (int)(value - b.byteValue()); } - - public static String toString(byte value) + + /** + * Behaves like compareTo(java.lang.Byte) unless the Object + * is not a Byte. Then it throws a + * ClassCastException. + * @exception ClassCastException if the argument is not a + * Byte. + */ + public int compareTo(Object o) { - return Integer.toString((int) value); + return compareTo((Byte)o); } } diff --git a/libjava/java/lang/Integer.java b/libjava/java/lang/Integer.java index 9ddfa312f06f..414d93d43a85 100644 --- a/libjava/java/lang/Integer.java +++ b/libjava/java/lang/Integer.java @@ -1,182 +1,368 @@ -/* 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 - * @date September 11, 1998. + * Instances of class Integer represent primitive + * int 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 int can represent is -2147483648. + */ + public static final int MIN_VALUE = 0x80000000; + + /** + * The maximum value an int can represent is 2147483647. + */ + public static final int MAX_VALUE = 0x7fffffff; + + /** + * The primitive type int is represented by this + * Class object. + */ + public static final Class TYPE = VMClassLoader.getPrimitiveClass ("int"); + + /** + * The immutable value of this Integer. + */ + private final int value; + + /** + * Create an Integer object representing the value of the + * int argument. + * + * @param value the value to use + */ + public Integer(int value) { - value = val; + this.value = value; } - public Integer(String str) throws NumberFormatException + /** + * Create an Integer object representing the value of the + * argument after conversion to an int. + * + * @param s the string to convert. + */ + public Integer(String s) throws NumberFormatException { - value = parseInt(str, 10); + value = parseInt(s, 10); } - public byte byteValue() + /** + * Return a hashcode representing this Object. + * + * Integer's hash code is calculated by simply returning its + * value. + * + * @return this Object's hash code. + */ + public int hashCode() { - return (byte) value; + return value; } - public double doubleValue() + /** + * If the Object is not null, is an + * instanceof Integer, and represents + * the same primitive int value return + * true. Otherwise false is returned. + */ + public boolean equals(Object obj) { - return (double) value; + return obj instanceof Integer && value == ((Integer)obj).value; } - public float floatValue() + /** + * Get the specified system property as an Integer. + * + * The decode() 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 Integer, or + * null if the property is not found or cannot be + * decoded as an Integer. + * @see java.lang.System#getProperty(java.lang.String) + * @see #decode(int) + */ + public static Integer getInteger(String nm) { - return (float) value; + return getInteger(nm, null); } - public int intValue() + /** + * Get the specified system property as an Integer, or use a + * default int value if the property is not found or is not + * decodable. + * + * The decode() 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 Integer, or the default + * value if the property is not found or cannot be decoded as an + * Integer. + * @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) { - return value; + Integer result = getInteger(nm, null); + return (result == null) ? new Integer(val) : result; } - public long longValue() + /** + * Get the specified system property as an Integer, or use a + * default Integer value if the property is not found or is + * not decodable. + * + * The decode() 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 Integer, or the default + * value if the property is not found or cannot be decoded as an + * Integer. + * @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) { - return value; + String val = System.getProperty(nm); + if (val == null) return def; + try + { + return decode(nm); + } + catch (NumberFormatException e) + { + return def; + } } - public short shortValue() + private static String toUnsignedString(int num, int exp) { - return (short) value; + // 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); } - // Added in JDK 1.2 - public int compareTo(Integer anotherInteger) + /** + * Converts the int to a String assuming it is + * unsigned in base 16. + * @param i the int to convert to String + * @return the String representation of the argument. + */ + public static String toHexString(int i) { - if (this.value == anotherInteger.value) - return 0; + return toUnsignedString(i, 4); + } - // Returns just -1 or 1 on inequality; doing math might overflow the int. - if (this.value > anotherInteger.value) - return 1; + /** + * Converts the int to a String assuming it is + * unsigned in base 8. + * @param i the int to convert to String + * @return the String representation of the argument. + */ + public static String toOctalString(int i) + { + return toUnsignedString(i, 3); + } - return -1; + /** + * Converts the int to a String assuming it is + * unsigned in base 2. + * @param i the int to convert to String + * @return the String representation of the argument. + */ + public static String toBinaryString(int i) + { + return toUnsignedString(i, 1); } - // Added in JDK 1.2 - /** @throws ClassCastException */ - public int compareTo(Object o) + /** + * Converts the int to a String and assumes + * a radix of 10. + * @param i the int to convert to String + * @return the String representation of the argument. + */ + public static String toString(int i) { - return this.compareTo((Integer) o); + // 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); } - public static Integer decode(String str) throws NumberFormatException + /** + * Converts the Integer value to a String and + * assumes a radix of 10. + * @return the String representation of this Integer. + */ + public String toString() { - boolean isNeg = false; - int index = 0; - int radix = 10; - final int len; + return toString (value); + } - if ((len = str.length()) == 0) - throw new NumberFormatException(); + /** + * Converts the int to a String using + * the specified radix (base). + * @param i the int to convert to String. + * @param radix the radix (base) to use in the conversion. + * @return the String representation of the argument. + */ + public static String toString(int num, int radix) + { + // Use optimized method for the typical case. + if (radix == 10 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + return toString(num); - // Negative numbers are always radix 10. - if (str.charAt(0) == '-') + // For negative numbers, print out the absolute value w/ a leading '-'. + // Use an array large enough for a binary number. + char[] buffer = new char[33]; + int i = 33; + boolean isNeg; + if (num < 0) { - 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); + num = -(num); - index++; - if (str.charAt(index) == 'x') + // When the value is MIN_VALUE, it overflows when made positive + if (num < 0) { - radix = 16; - index++; + buffer[--i] = Character.forDigit(-(num + radix) % radix, radix); + num = -(num / radix); } - else - radix = 8; } + else + isNeg = false; - 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); - } + do + { + buffer[--i] = Character.forDigit(num % radix, radix); + num /= radix; + } + while (num > 0); - public static Integer getInteger(String prop) - { - return getInteger(prop, null); - } + if (isNeg) + buffer[--i] = '-'; - public static Integer getInteger(String prop, int defval) - { - Integer val = getInteger(prop, null); - return val == null ? new Integer(defval) : val; + return String.valueOf(buffer, i, 33-i); } - public static Integer getInteger(String prop, Integer defobj) + /** + * Creates a new Integer object using the String, + * assuming a radix of 10. + * @param s the String to convert. + * @return the new Integer. + * @see #Integer(java.lang.String) + * @see #parseInt(java.lang.String) + * @exception NumberFormatException thrown if the String + * cannot be parsed as an int. + */ + public static Integer valueOf(String s) throws NumberFormatException { - try - { - String val = System.getProperty(prop); - if (val != null) - return decode(val); - } - catch (NumberFormatException ex) - { - } - return defobj; + return new Integer(parseInt(s)); } - public int hashCode() + /** + * Creates a new Integer object using the String + * and specified radix (base). + * @param s the String to convert. + * @param radix the radix (base) to convert with. + * @return the new Integer. + * @see #parseInt(java.lang.String,int) + * @exception NumberFormatException thrown if the String + * cannot be parsed as an int. + */ + public static Integer valueOf(String s, int radix) + throws NumberFormatException { - return value; + return new Integer(parseInt(s, radix)); } - public static int parseInt(String str) throws NumberFormatException + /** + * Converts the specified String into an int. + * This function assumes a radix of 10. + * + * @param s the String to convert + * @return the int value of the String + * argument. + * @exception NumberFormatException thrown if the String + * cannot be parsed as an int. + */ + public static int parseInt(String s) throws NumberFormatException { - return parseInt(str, 10); + return parseInt(s, 10); } - public static int parseInt(String str, int radix) throws NumberFormatException + /** + * Converts the specified String into an int + * using the specified radix (base). + * + * @param s the String to convert + * @param radix the radix (base) to use in the conversion + * @return the String argument converted to int. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a int. + */ + public static int parseInt(String str, int radix) + throws NumberFormatException { final int len; @@ -199,7 +385,8 @@ public final class Integer extends Number implements Comparable } private static int parseInt(String str, int index, int len, boolean isNeg, - int radix) throws NumberFormatException + int radix) + throws NumberFormatException { int val = 0; int digval; @@ -228,96 +415,156 @@ public final class Integer extends Number implements Comparable return isNeg ? -(val) : val; } - public static String toBinaryString(int num) + /** + * Convert the specified String into an Integer. + * The String may represent decimal, hexadecimal, or + * octal numbers. + * + * The String argument is interpreted based on the leading + * characters. Depending on what the String begins with, the base will be + * interpreted differently: + * + * + * + * + * + * + * + * + *
Leading
Characters		Base
#16
0x16
0X16
08
Anything
Else		10
+ * + * @param str the String to interpret. + * @return the value of the String as an Integer. + * @exception NumberFormatException thrown if the String + * cannot be parsed as an int. + */ + public static Integer decode(String str) throws NumberFormatException { - return toUnsignedString(num, 1); + 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)); } - public static String toHexString(int num) + /** Return the value of this Integer as a byte. + ** @return the value of this Integer as a byte. + **/ + public byte byteValue() { - return toUnsignedString(num, 4); + return (byte) value; } - public static String toOctalString(int num) + /** Return the value of this Integer as a short. + ** @return the value of this Integer as a short. + **/ + public short shortValue() { - return toUnsignedString(num, 3); + return (short) value; } - private static String toUnsignedString(int num, int exp) + /** Return the value of this Integer as an int. + ** @return the value of this Integer as an int. + **/ + public int intValue() { - // 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); + return value; } - public String toString() + /** Return the value of this Integer as a long. + ** @return the value of this Integer as a long. + **/ + public long longValue() { - return toString(this.value); + return value; } - public static String toString(int num) + /** Return the value of this Integer as a float. + ** @return the value of this Integer as a float. + **/ + public float floatValue() { - return String.valueOf (num); + return value; } - public static String toString(int num, int radix) + /** Return the value of this Integer as a double. + ** @return the value of this Integer as a double. + **/ + public double doubleValue() { - // Use optimized method for the typical case. - if (radix == 10 || - radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) - return toString(num); - - // For negative numbers, print out the absolute value w/ a leading '-'. - // Use an array large enough for a binary number. - char[] buffer = new char[33]; - int i = 33; - boolean isNeg; - if (num < 0) - { - isNeg = true; - num = -(num); - - // When the value is MIN_VALUE, it overflows when made positive - if (num < 0) - { - buffer[--i] = Character.forDigit(-(num + radix) % radix, radix); - num = -(num / radix); - } - } - else - isNeg = false; - - do - { - buffer[--i] = Character.forDigit(num % radix, radix); - num /= radix; - } - while (num > 0); - - if (isNeg) - buffer[--i] = '-'; - - return String.valueOf(buffer, i, 33-i); + return value; } - public static Integer valueOf(String str) throws NumberFormatException + /** + * Compare two Integers numerically by comparing their + * int values. + * @return a positive value if this Integer is greater + * in value than the argument Integer; a negative value + * if this Integer is smaller in value than the argument + * Integer; and 0, zero, if this + * Integer is equal in value to the argument + * Integer. + * + * @since 1.2 + */ + public int compareTo(Integer i) { - return new Integer(parseInt(str, 10)); + 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; } - public static Integer valueOf(String str, int radix) - throws NumberFormatException + /** + * Behaves like compareTo(java.lang.Integer) unless the Object + * is not a Integer. Then it throws a + * ClassCastException. + * @exception ClassCastException if the argument is not a + * Integer. + * + * @since 1.2 + */ + public int compareTo(Object o) { - return new Integer(parseInt(str, radix)); + return compareTo((Integer)o); } } diff --git a/libjava/java/lang/Long.java b/libjava/java/lang/Long.java index c33a43b6c2cb..addb7e9d83c4 100644 --- a/libjava/java/lang/Long.java +++ b/libjava/java/lang/Long.java @@ -1,184 +1,404 @@ -/* 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 - * @date September 18, 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. + * Instances of class Double represent primitive + * double 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 */ - public final class Long extends Number implements Comparable { - public static final long MAX_VALUE = 0x7FFFFFFFFFFFFFFFL; - 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; + // compatible with JDK 1.0.2+ + static final long serialVersionUID = 4290774380558885855L; - /* The long value of the instance. */ - private long value; - - private static final long serialVersionUID = 4290774380558885855L; + /** + * The minimum value a long can represent is + * -9223372036854775808. + */ + public static final long MIN_VALUE = 0x8000000000000000L; - public Long(long val) + /** + * The maximum value a long can represent is + * 9223372036854775807. + */ + public static final long MAX_VALUE = 0x7fffffffffffffffL; + + /** + * The primitive type long is represented by this + * Class object. + */ + public static final Class TYPE = VMClassLoader.getPrimitiveClass ("long"); + + /** + * The immutable value of this Long. + */ + private final long value; + + /** + * Create a Long object representing the value of the + * long argument. + * + * @param value the value to use + */ + public Long(long value) { - value = val; + this.value = value; } - public Long(String str) throws NumberFormatException + /** + * Create a Long object representing the value of the + * argument after conversion to a long. + * + * @param s the string to convert. + */ + public Long(String s) throws NumberFormatException { - value = parseLong(str, 10); + value = parseLong(s, 10); } - public byte byteValue() + /** + * If the Object is not null, is an + * instanceof Long, and represents + * the same primitive long value return + * true. Otherwise false is returned. + */ + public boolean equals(Object obj) { - return (byte) value; + return obj instanceof Long && ((Long)obj).value == value; } - public double doubleValue() + /** + * Return a hashcode representing this Object. + * + * Long's hash code is calculated by simply returning its + * value. + * + * @return this Object's hash code. + */ + public int hashCode() { - return (double) value; + return (int)(value^(value>>>32)); } - public float floatValue() + /** + * Get the specified system property as a Long. + * + * A method similar to Integer's decode() will be + * used to interpret the value of the property. + * + * @param nm the name of the system property + * @return the system property as an Long, or + * null if the property is not found or cannot be + * decoded as a Long. + * @see java.lang.System#getProperty(java.lang.String) + * @see java.lang.Integer#decode(int) + */ + public static Long getLong(String nm) { - return (float) value; + return getLong(nm, null); } - public int intValue() + /** + * Get the specified system property as an Long, or use a + * default long value if the property is not found or is not + * decodable. + * + * A method similar to Integer's decode() 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 Long, or the default + * value if the property is not found or cannot be decoded as a + * Long. + * @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) { - return (int) value; + Long result = getLong(nm, null); + return (result == null) ? new Long(val) : result; } - public long longValue() + /** + * Get the specified system property as an Long, or use a + * default Long value if the property is not found or is + * not decodable. + * + * The decode() 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 Long, or the default + * value if the property is not found or cannot be decoded as an + * Long. + * @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) { - return value; + String val = System.getProperty(nm); + if (val == null) + return def; + try + { + return decode(nm); + } + catch (NumberFormatException e) + { + return def; + } } - public short shortValue() + private static String toUnsignedString(long num, int exp) { - return (short) value; + // Use an array large enough for a binary number. + int radix = 1 << exp; + int mask = radix - 1; + char[] buffer = new char[64]; + int i = 64; + do + { + buffer[--i] = Character.forDigit((int) num & mask, radix); + num = num >>> exp; + } + while (num != 0); + + return String.valueOf(buffer, i, 64-i); } - // Added in JDK 1.2 - public int compareTo(Long anotherLong) + /** + * Converts the long to a String assuming it is + * unsigned in base 16. + * @param i the long to convert to String + * @return the String representation of the argument. + */ + public static String toHexString(long i) { - 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; + return toUnsignedString(i, 4); } - // Added in JDK 1.2 - /** @throws ClassCastException */ - public int compareTo(Object o) + /** + * Converts the long to a String assuming it is + * unsigned in base 8. + * @param i the long to convert to String + * @return the String representation of the argument. + */ + public static String toOctalString(long i) { - return this.compareTo((Long) o); + return toUnsignedString(i, 3); } - // 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; + /** + * Converts the long to a String assuming it is + * unsigned in base 2. + * @param i the long to convert to String + * @return the String representation of the argument. + */ + public static String toBinaryString(long i) { + return toUnsignedString(i, 1); + } - if ((len = str.length()) == 0) - throw new NumberFormatException(); + /** + * Converts the long to a String and assumes + * a radix of 10. + * @param num the long to convert to String + * @return the String representation of the argument. + */ + public static String toString(long num) + { + // Use the Integer toString for efficiency if possible. + if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) + return Integer.toString((int) num); - // Negative numbers are always radix 10. - if (str.charAt(0) == '-') + // Use an array large enough for "-9223372036854775808"; i.e. 20 chars. + char[] buffer = new char[20]; + int i = 20; + boolean isNeg; + if (num < 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') + num = -(num); + if (num < 0) { - radix = 16; - index++; + // Must be MIN_VALUE, so handle this special case. + buffer[--i] = '8'; + num = 922337203685477580L; } - else - radix = 8; } + else + isNeg = false; - if (index >= len) - throw new NumberFormatException(); + do + { + buffer[--i] = (char) ((int) '0' + (num % 10)); + num /= 10; + } + while (num > 0); - return new Long(parseLong(str, index, len, isNeg, radix)); - } + if (isNeg) + buffer[--i] = '-'; - public boolean equals(Object obj) - { - return (obj instanceof Long && ((Long) obj).value == value); + return String.valueOf(buffer, i, 20-i); } - public static Long getLong(String prop) + /** + * Converts the Long value to a String and + * assumes a radix of 10. + * @return the String representation of this Long. + */ + public String toString() { - return getLong(prop, null); + return toString(value); } - - public static Long getLong(String prop, long defval) + + /** + * Converts the long to a String using + * the specified radix (base). + * @param num the long to convert to String. + * @param radix the radix (base) to use in the conversion. + * @return the String representation of the argument. + */ + public static String toString(long num, int radix) { - Long val = getLong(prop, null); - return val == null ? new Long(defval) : val; - } + // Use optimized method for the typical case. + if (radix == 10 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + return toString(num); - public static Long getLong(String prop, Long defobj) - { - try + // Use the Integer toString for efficiency if possible. + if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) + return Integer.toString((int) num, radix); + + // For negative numbers, print out the absolute value w/ a leading '-'. + // Use an array large enough for a binary number. + char[] buffer = new char[65]; + int i = 65; + boolean isNeg; + if (num < 0) { - String val = System.getProperty(prop); - if (val != null) - return decode(val); + isNeg = true; + num = -(num); + + // When the value is MIN_VALUE, it overflows when made positive + if (num < 0) + { + buffer[--i] = Character.forDigit((int) (-(num + radix) % radix), + radix); + num = -(num / radix); + } } - catch (NumberFormatException ex) + else + isNeg = false; + + do { + buffer[--i] = Character.forDigit((int) (num % radix), radix); + num /= radix; } - return defobj; + while (num > 0); + + if (isNeg) + buffer[--i] = '-'; + + return String.valueOf(buffer, i, 65-i); + } + + /** + * Creates a new Long object using the String, + * assuming a radix of 10. + * @param s the String to convert. + * @return the new Long. + * @see #Long(java.lang.String) + * @see #parseLong(java.lang.String) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a long. + */ + public static Long valueOf(String s) throws NumberFormatException + { + return new Long(parseLong(s)); } - public int hashCode() + /** + * Creates a new Long object using the String + * and specified radix (base). + * @param s the String to convert. + * @param radix the radix (base) to convert with. + * @return the new Long. + * @see #parseLong(java.lang.String,int) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a long. + */ + public static Long valueOf(String s, int radix) throws NumberFormatException { - return (int)(this.longValue()^(this.longValue()>>>32)); + return new Long(parseLong(s, radix)); } - public static long parseLong(String str) throws NumberFormatException + /** + * Converts the specified String into a long. + * This function assumes a radix of 10. + * + * @param s the String to convert + * @return the long value of the String + * argument. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a long. + */ + public static long parseLong(String s) throws NumberFormatException { - return parseLong(str, 10); + return parseLong(s, 10); } + /** + * Converts the specified String into a long + * using the specified radix (base). + * + * @param s the String to convert + * @param radix the radix (base) to use in the conversion + * @return the String argument converted to long. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a long. + */ public static long parseLong(String str, int radix) - throws NumberFormatException + throws NumberFormatException { final int len; @@ -200,6 +420,50 @@ public final class Long extends Number implements Comparable 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 { @@ -230,133 +494,89 @@ public final class Long extends Number implements Comparable return isNeg ? -(val) : val; } - public static String toBinaryString(long num) + /** Return the value of this Long as an short. + ** @return the value of this Long as an short. + **/ + public byte byteValue() { - return toUnsignedString(num, 1); + return (byte) value; } - public static String toHexString(long num) + /** Return the value of this Long as an short. + ** @return the value of this Long as an short. + **/ + public short shortValue() { - return toUnsignedString(num, 4); + return (short) value; } - public static String toOctalString(long num) + /** Return the value of this Long as an int. + ** @return the value of this Long as an int. + **/ + public int intValue() { - return toUnsignedString(num, 3); + return (int) value; } - private static String toUnsignedString(long num, int exp) + /** Return the value of this Long as a long. + ** @return the value of this Long as a long. + **/ + public long longValue() { - // Use an array large enough for a binary number. - int radix = 1 << exp; - long mask = radix - 1; - char[] buffer = new char[64]; - int i = 64; - do - { - buffer[--i] = Character.forDigit((int) (num & mask), radix); - num = num >>> exp; - } - while (num != 0); - - return String.valueOf(buffer, i, 64-i); + return value; } - public String toString() + /** Return the value of this Long as a float. + ** @return the value of this Long as a float. + **/ + public float floatValue() { - return toString(this.value); + return value; } - public static String toString(long num) + /** Return the value of this Long as a double. + ** @return the value of this Long as a double. + **/ + public double doubleValue() { - // Use the Integer toString for efficiency if possible. - if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) - return Integer.toString((int) num); - - // Use an array large enough for "-9223372036854775808"; i.e. 20 chars. - char[] buffer = new char[20]; - int i = 20; - boolean isNeg; - if (num < 0) - { - isNeg = true; - num = -(num); - if (num < 0) - { - // Must be MIN_VALUE, so handle this special case. - buffer[--i] = '8'; - num = 922337203685477580L; - } - } - else - isNeg = false; - - do - { - buffer[--i] = (char) ((int) '0' + (num % 10)); - num /= 10; - } - while (num > 0); - - if (isNeg) - buffer[--i] = '-'; - - return String.valueOf(buffer, i, 20-i); + return value; } - public static String toString(long num, int radix) + /** + * Compare two Longs numerically by comparing their + * long values. + * @return a positive value if this Long is greater + * in value than the argument Long; a negative value + * if this Long is smaller in value than the argument + * Long; and 0, zero, if this + * Long is equal in value to the argument + * Long. + * + * @since 1.2 + */ + public int compareTo(Long l) { - // Use optimized method for the typical case. - if (radix == 10 || - radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) - return toString(num); - - // Use the Integer toString for efficiency if possible. - if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) - return Integer.toString((int) num, radix); - - // For negative numbers, print out the absolute value w/ a leading '-'. - // Use an array large enough for a binary number. - char[] buffer = new char[65]; - int i = 65; - boolean isNeg; - if (num < 0) - { - isNeg = true; - num = -(num); - - // When the value is MIN_VALUE, it overflows when made positive - if (num < 0) - { - buffer[--i] = Character.forDigit((int) (-(num + radix) % radix), - radix); - num = -(num / radix); - } - } - else - isNeg = false; - - do - { - buffer[--i] = Character.forDigit((int) (num % radix), radix); - num /= radix; - } - while (num > 0); - - if (isNeg) - buffer[--i] = '-'; + if (this.value == l.value) + return 0; - return String.valueOf(buffer, i, 65-i); - } + // Returns just -1 or 1 on inequality; doing math might overflow the long. + if (this.value > l.value) + return 1; - public static Long valueOf(String str) throws NumberFormatException - { - return new Long(parseLong(str, 10)); + return -1; } - - public static Long valueOf(String str, int radix) - throws NumberFormatException + + /** + * Behaves like compareTo(java.lang.Long) unless the Object + * is not a Long. Then it throws a + * ClassCastException. + * @exception ClassCastException if the argument is not a + * Long. + * + * @since 1.2 + */ + public int compareTo(Object o) { - return new Long(parseLong(str, radix)); + return compareTo((Long)o); } } diff --git a/libjava/java/lang/Number.java b/libjava/java/lang/Number.java index 92d98afbfb67..7eb8bee22da5 100644 --- a/libjava/java/lang/Number.java +++ b/libjava/java/lang/Number.java @@ -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 - * @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 + ** Byte, Short, Integer, + ** Long, Float, and Double. + ** + ** 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 Number as a byte. + ** @return the value of this Number as a byte. + **/ + 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 Number as a short. + ** @return the value of this Number as a short. + **/ + public short shortValue() { return (short) intValue(); } + /** Return the value of this Number as an int. + ** @return the value of this Number as an int. + **/ + public abstract int intValue(); + + /** Return the value of this Number as a long. + ** @return the value of this Number as a long. + **/ + public abstract long longValue(); + + /** Return the value of this Number as a float. + ** @return the value of this Number as a float. + **/ + public abstract float floatValue(); + + /** Return the value of this Number as a float. + ** @return the value of this Number as a float. + **/ + public abstract double doubleValue(); + private static final long serialVersionUID = -8742448824652078965L; } diff --git a/libjava/java/lang/Short.java b/libjava/java/lang/Short.java index 66eb4fdfeedd..db3cac0f095b 100644 --- a/libjava/java/lang/Short.java +++ b/libjava/java/lang/Short.java @@ -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 - * @date April 17, 1998. + * Instances of class Short represent primitive + * short 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; + + /** + * The minimum value a short can represent is -32768. + */ + public static final short MIN_VALUE = -32768; - public final static short MIN_VALUE = -32768; - public final static short MAX_VALUE = 32767; + /** + * The minimum value a short can represent is 32767. + */ + public static final short MAX_VALUE = 32767; - // 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 primitive type short is represented by this + * Class object. + */ + public static final Class TYPE = VMClassLoader.getPrimitiveClass("short"); - private static final long serialVersionUID = 7515723908773894738L; + /** + * The immutable value of this Short. + */ + private final short value; + /** + * Create a Short object representing the value of the + * short argument. + * + * @param value the value to use + */ public Short(short value) { this.value = value; } - public Short(String str) - throws NumberFormatException + /** + * Create a Short object representing the value of the + * argument after conversion to a short. + * + * @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 a hashcode representing this Object. + * + * Short's hash code is calculated by simply returning its + * value. + * + * @return this Object's hash code. + */ + public int hashCode() { - return (byte) value; + return value; } - public short shortValue() + /** + * If the Object is not null, is an + * instanceof Short, and represents + * the same primitive short value return + * true. Otherwise false is returned. + */ + public boolean equals(Object obj) { - return value; + return obj instanceof Short && ((Short)obj).value == value; } - public int intValue() + /** + * Converts the short to a String and assumes + * a radix of 10. + * @param i the short to convert to String + * @return the String representation of the argument. + */ + public static String toString(short i) { - return value; + return Integer.toString((int) i); } - public long longValue () + /** + * Converts the Short value to a String and + * assumes a radix of 10. + * @return the String representation of this Short. + */ + public String toString() { - return value; + return Integer.toString ((int) value); } - public float floatValue () + /** + * Creates a new Short object using the String, + * assuming a radix of 10. + * @param s the String to convert. + * @return the new Short. + * @see #Short(java.lang.String) + * @see #parseShort(java.lang.String) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a short. + */ + public static Short valueOf(String s) throws NumberFormatException { - return (float) value; + return new Short(parseShort(s)); } - public double doubleValue () + /** + * Creates a new Short object using the String + * and specified radix (base). + * @param s the String to convert. + * @param radix the radix (base) to convert with. + * @return the new Short. + * @see #parseShort(java.lang.String,int) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a short. + */ + public static Short valueOf(String s, int radix) + throws NumberFormatException { - return (double) value; + return new Short(parseShort(s, radix)); } - public static Short decode(String str) - throws NumberFormatException + /** + * Converts the specified String into a short. + * This function assumes a radix of 10. + * + * @param s the String to convert + * @return the short value of the String + * argument. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a short. + */ + public static short parseShort(String s) throws NumberFormatException { - int i = (Integer.decode(str)).intValue(); - if (i < MIN_VALUE || i > MAX_VALUE) - throw new NumberFormatException(); - return new Short((short) i); + return parseShort(s, 10); } - public static short parseShort(String str, int radix) + /** + * Converts the specified String into a short + * using the specified radix (base). + * + * @param s the String to convert + * @param radix the radix (base) to use in the conversion + * @return the String argument converted to short. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a short. + */ + public static short parseShort(String s, int radix) throws NumberFormatException { - int i = Integer.parseInt(str, radix); + int i = Integer.parseInt(s, radix); if (i < MIN_VALUE || i > MAX_VALUE) throw new NumberFormatException(); return (short) i; } - public static short parseShort(String str) - throws NumberFormatException + /** + * Convert the specified String into a Short. + * The String may represent decimal, hexadecimal, or + * octal numbers. + * + * The String argument is interpreted based on the leading + * characters. Depending on what the String begins with, the base will be + * interpreted differently: + * + * + * + * + * + * + * + * + *
Leading
Characters		Base
#16
0x16
0X16
08
Anything
Else		10
+ * + * @param s the String to interpret. + * @return the value of the String as a Short. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a short. + */ + public static Short decode(String s) throws NumberFormatException { - return parseShort(str, 10); + int i = (Integer.decode(s)).intValue(); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return new Short((short) i); } - public static Short valueOf(String str, int radix) - throws NumberFormatException + /** Return the value of this Short as an short. + ** @return the value of this Short as an short. + **/ + public byte byteValue() { - return new Short(parseShort(str, radix)); + return (byte) value; } - public static Short valueOf(String str) - throws NumberFormatException + /** Return the value of this Short as an short. + ** @return the value of this Short as an short. + **/ + public short shortValue() { - return valueOf(str, 10); + return value; } - // Added in JDK 1.2 - public int compareTo(Short anotherShort) + /** Return the value of this Short as an int. + ** @return the value of this Short as an int. + **/ + public int intValue() { - return this.value - anotherShort.value; + return value; } - // Added in JDK 1.2 - /** @throws ClassCastException */ - public int compareTo(Object o) + /** Return the value of this Short as a long. + ** @return the value of this Short as a long. + **/ + public long longValue() { - return this.value - ((Short) o).value; + return value; } - public boolean equals(Object obj) + /** Return the value of this Short as a float. + ** @return the value of this Short as a float. + **/ + public float floatValue() { - return (obj instanceof Short) && ((Short) obj).value == value; + return value; } - // Verified that hashCode is returns plain value (see Short_1 test). - public int hashCode() + /** Return the value of this Short as a double. + ** @return the value of this Short as a double. + **/ + public double doubleValue() { return value; } - public String toString() + /** + * Compare two Shorts numerically by comparing their + * short values. + * @return a positive value if this Short is greater + * in value than the argument Short; a negative value + * if this Short is smaller in value than the argument + * Short; and 0, zero, if this + * Short is equal in value to the argument + * Short. + * + * @since 1.2 + */ + public int compareTo(Short s) { - return Integer.toString((int) value); + return value - s.value; } - - public static String toString(short value) + + /** + * Behaves like compareTo(java.lang.Short) unless the Object + * is not a Short. Then it throws a + * ClassCastException. + * @exception ClassCastException if the argument is not a + * Short. + * + * @since 1.2 + */ + public int compareTo(Object o) { - return Integer.toString((int) value); + return compareTo((Short)o); } } diff --git a/libjava/java/lang/VMClassLoader.java b/libjava/java/lang/VMClassLoader.java new file mode 100644 index 000000000000..de0db8874344 --- /dev/null +++ b/libjava/java/lang/VMClassLoader.java @@ -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; + } +}