harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r350181 [106/198] - in /incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core: ./ depends/ depends/files/ depends/jars/ depends/libs/ depends/libs/linux.IA32/ depends/libs/win.IA32/ depends/oss/ depends/oss/linux.IA32/ depends/oss/win....
Date Thu, 01 Dec 2005 06:04:00 GMT
Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Short.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Short.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Short.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Short.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,275 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * Shorts are objects (non-base types) which represent short values.
+ */
+public final class Short extends Number implements Comparable {
+
+	static final long serialVersionUID = 7515723908773894738L;
+
+	/**
+	 * The value which the receiver represents.
+	 */
+	final short value;
+
+	/**
+	 * Most positive and most negative possible short values.
+	 */
+	public static final short MAX_VALUE = (short) 0x7FFF;
+
+	public static final short MIN_VALUE = (short) 0x8000;
+
+	/**
+	 * The java.lang.Class that represents this class.
+	 */
+	public static final Class TYPE = new short[0].getClass().getComponentType();
+
+	// Note: This can't be set to "short.class", since *that* is
+	// defined to be "java.lang.Short.TYPE";
+
+	/**
+	 * Constructs a new instance of this class given a string.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public Short(String string) throws NumberFormatException {
+		this(parseShort(string));
+	}
+
+	/**
+	 * Constructs a new instance of the receiver which represents the short
+	 * valued argument.
+	 * 
+	 * @param value
+	 *            the short to store in the new instance.
+	 */
+	public Short(short value) {
+		this.value = value;
+	}
+
+	/**
+	 * Answers the byte value which the receiver represents
+	 * 
+	 * @return byte the value of the receiver.
+	 */
+	public byte byteValue() {
+		return (byte) value;
+	}
+
+	public int compareTo(Object object) {
+		return compareTo((Short) object);
+	}
+
+	public int compareTo(Short object) {
+		return value > object.value ? 1 : (value < object.value ? -1 : 0);
+	}
+
+	/**
+	 * Parses the string argument as if it was a short value and returns the
+	 * result. Throws NumberFormatException if the string does not represent an
+	 * int quantity. The string may be a hexadecimal ("0x..."), octal ("0..."),
+	 * or decimal ("...") representation of a byte.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @return Short the value represented by the argument
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public static Short decode(String string) throws NumberFormatException {
+		int intValue = Integer.decode(string).intValue();
+		short result = (short) intValue;
+		if (result == intValue)
+			return new Short(result);
+		throw new NumberFormatException();
+	}
+
+	/**
+	 * Answers the double value which the receiver represents
+	 * 
+	 * @return double the value of the receiver.
+	 */
+	public double doubleValue() {
+		return value;
+	}
+
+	/**
+	 * Compares the argument to the receiver, and answers true if they represent
+	 * the <em>same</em> object using a class specific comparison.
+	 * <p>
+	 * In this case, the argument must also be a Short, and the receiver and
+	 * argument must represent the same short value.
+	 * 
+	 * @param object
+	 *            the object to compare with this object
+	 * @return <code>true</code> if the object is the same as this object
+	 *         <code>false</code> if it is different from this object
+	 * @see #hashCode
+	 */
+	public boolean equals(Object object) {
+		return (object == this) || (object instanceof Short)
+				&& (value == ((Short) object).value);
+	}
+
+	/**
+	 * Answers the float value which the receiver represents
+	 * 
+	 * @return float the value of the receiver.
+	 */
+	public float floatValue() {
+		return value;
+	}
+
+	/**
+	 * Answers an integer hash code for the receiver. Any two objects which
+	 * answer <code>true</code> when passed to <code>equals</code> must
+	 * answer the same value for this method.
+	 * 
+	 * @return the receiver's hash
+	 * 
+	 * @see #equals
+	 */
+	public int hashCode() {
+		return value;
+	}
+
+	/**
+	 * Answers the int value which the receiver represents
+	 * 
+	 * @return int the value of the receiver.
+	 */
+	public int intValue() {
+		return value;
+	}
+
+	/**
+	 * Answers the long value which the receiver represents
+	 * 
+	 * @return long the value of the receiver.
+	 */
+	public long longValue() {
+		return value;
+	}
+
+	/**
+	 * Parses the string argument as if it was a short value and returns the
+	 * result. Throws NumberFormatException if the string does not represent an
+	 * short quantity.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @return short the value represented by the argument
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public static short parseShort(String string) throws NumberFormatException {
+		return parseShort(string, 10);
+	}
+
+	/**
+	 * Parses the string argument as if it was a short value and returns the
+	 * result. Throws NumberFormatException if the string does not represent a
+	 * single short quantity. The second argument specifies the radix to use
+	 * when parsing the value.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @param radix
+	 *            the radix to use when parsing.
+	 * @return short the value represented by the argument
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public static short parseShort(String string, int radix)
+			throws NumberFormatException {
+		int intValue = Integer.parseInt(string, radix);
+		short result = (short) intValue;
+		if (result == intValue)
+			return result;
+		throw new NumberFormatException();
+	}
+
+	/**
+	 * Answers the short value which the receiver represents
+	 * 
+	 * @return short the value of the receiver.
+	 */
+	public short shortValue() {
+		return value;
+	}
+
+	/**
+	 * Answers a string containing a concise, human-readable description of the
+	 * receiver.
+	 * 
+	 * @return a printable representation for the receiver.
+	 */
+	public String toString() {
+		return Integer.toString(value);
+	}
+
+	/**
+	 * Answers a string containing a concise, human-readable description of the
+	 * argument.
+	 * 
+	 * @param value
+	 *            short the short to convert.
+	 * @return String a printable representation for the short.
+	 */
+	public static String toString(short value) {
+		return Integer.toString(value);
+	}
+
+	/**
+	 * Parses the string argument as if it was a short value and returns a Short
+	 * representing the result. Throws NumberFormatException if the string does
+	 * not represent a single short quantity.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @return Short the value represented by the argument
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public static Short valueOf(String string) throws NumberFormatException {
+		return new Short(parseShort(string));
+	}
+
+	/**
+	 * Parses the string argument as if it was a short value and returns a Short
+	 * representing the result. Throws NumberFormatException if the string does
+	 * not represent a short quantity. The second argument specifies the radix
+	 * to use when parsing the value.
+	 * 
+	 * @param string
+	 *            a string representation of a short quantity.
+	 * @param radix
+	 *            the radix to use when parsing.
+	 * @return Short the value represented by the argument
+	 * @exception NumberFormatException
+	 *                if the argument could not be parsed as a short quantity.
+	 */
+	public static Short valueOf(String string, int radix)
+			throws NumberFormatException {
+		return new Short(parseShort(string, radix));
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StackOverflowError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StackOverflowError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StackOverflowError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StackOverflowError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,44 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This error is thrown when the depth of the callstack of the running program
+ * excedes some platform or virtual machine specific limit. Typically, this will
+ * occur only when a program becomes infinitely recursive, but can occur in
+ * correctly written (but deeply recursive) programs.
+ */
+public class StackOverflowError extends java.lang.VirtualMachineError {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public StackOverflowError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public StackOverflowError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StrictMath.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StrictMath.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StrictMath.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StrictMath.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,466 @@
+/* Copyright 2001, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+import java.util.Random;
+
+/**
+ * Class StrictMath provides various numeric operations using the standards set
+ * by the known "Freely Distributable Math Library" (fdlibm). The standard is
+ * set by the January 4th, 1995 version of the library.
+ */
+public final class StrictMath {
+
+	/**
+	 * Standard math constant
+	 */
+	public final static double E = Math.E;
+
+	/**
+	 * Standard math constant
+	 */
+	public final static double PI = Math.PI;
+
+	private static java.util.Random random;
+
+	/**
+	 * Prevents this class from being instantiated.
+	 */
+	private StrictMath() {
+	}
+
+	/**
+	 * Answers the absolute value of the argument.
+	 * 
+	 * @param d
+	 *            the value to be converted
+	 * @return the argument if it is positive, otherwise the negation of the
+	 *         argument.
+	 */
+	public static double abs(double d) {
+		long bits = Double.doubleToLongBits(d);
+		bits &= 0x7fffffffffffffffL;
+		return Double.longBitsToDouble(bits);
+	}
+
+	/**
+	 * Answers the absolute value of the argument.
+	 * 
+	 * @param f
+	 *            the value to be converted
+	 * @return the argument if it is positive, otherwise the negation of the
+	 *         argument.
+	 */
+	public static float abs(float f) {
+		int bits = Float.floatToIntBits(f);
+		bits &= 0x7fffffff;
+		return Float.intBitsToFloat(bits);
+	}
+
+	/**
+	 * Answers the absolute value of the argument.
+	 * 
+	 * @param i
+	 *            the value to be converted
+	 * @return the argument if it is positive, otherwise the negation of the
+	 *         argument.
+	 */
+	public static int abs(int i) {
+		return i >= 0 ? i : -i;
+	}
+
+	/**
+	 * Answers the absolute value of the argument.
+	 * 
+	 * @param l
+	 *            the value to be converted
+	 * @return the argument if it is positive, otherwise the negation of the
+	 *         argument.
+	 */
+	public static long abs(long l) {
+		return l >= 0 ? l : -l;
+	}
+
+	/**
+	 * Answers the closest double approximation of the arc cosine of the
+	 * argument
+	 * 
+	 * @param d
+	 *            the value to compute acos of
+	 * @return the arc cosine of the argument.
+	 */
+	public static native double acos(double d);
+
+	/**
+	 * Answers the closest double approximation of the arc sine of the argument
+	 * 
+	 * @param d
+	 *            the value to compute asin of
+	 * @return the arc sine of the argument.
+	 */
+	public static native double asin(double d);
+
+	/**
+	 * Answers the closest double approximation of the arc tangent of the
+	 * argument
+	 * 
+	 * @param d
+	 *            the value to compute atan of
+	 * @return the arc tangent of the argument.
+	 */
+	public static native double atan(double d);
+
+	/**
+	 * Answers the closest double approximation of the arc tangent of the result
+	 * of dividing the first argument by the second argument.
+	 * 
+	 * @param d1
+	 *            the numerator of the value to compute atan of
+	 * @param d2
+	 *            the denominator of the value to compute atan of
+	 * @return the arc tangent of d1/d2.
+	 */
+	public static native double atan2(double d1, double d2);
+
+	/**
+	 * Answers the double conversion of the most negative (i.e. closest to
+	 * negative infinity) integer value which is greater than the argument.
+	 * 
+	 * @param d
+	 *            the value to be converted
+	 * @return the ceiling of the argument.
+	 */
+	public static native double ceil(double d);
+
+	/**
+	 * Answers the closest double approximation of the cosine of the argument
+	 * 
+	 * @param d
+	 *            the value to compute cos of
+	 * @return the cosine of the argument.
+	 */
+	public static native double cos(double d);
+
+	/**
+	 * Answers the closest double approximation of the raising "e" to the power
+	 * of the argument
+	 * 
+	 * @param d
+	 *            the value to compute the exponential of
+	 * @return the exponential of the argument.
+	 */
+	public static native double exp(double d);
+
+	/**
+	 * Answers the double conversion of the most positive (i.e. closest to
+	 * positive infinity) integer value which is less than the argument.
+	 * 
+	 * 
+	 * @param d
+	 *            the value to be converted
+	 * @return the ceiling of the argument.
+	 */
+	public static native double floor(double d);
+
+	/**
+	 * Answers the remainder of dividing the first argument by the second using
+	 * the IEEE 754 rules.
+	 * 
+	 * @param d1
+	 *            the numerator of the operation
+	 * @param d2
+	 *            the denominator of the operation
+	 * @return the result of d1/d2.
+	 */
+	public static native double IEEEremainder(double d1, double d2);
+
+	/**
+	 * Answers the closest double approximation of the natural logarithm of the
+	 * argument
+	 * 
+	 * @param d
+	 *            the value to compute the log of
+	 * @return the natural logarithm of the argument.
+	 */
+	public static native double log(double d);
+
+	/**
+	 * Answers the most positive (i.e. closest to positive infinity) of the two
+	 * arguments.
+	 * 
+	 * @param d1
+	 *            the first argument to check
+	 * @param d2
+	 *            the second argument
+	 * @return the larger of d1 and d2.
+	 */
+	public static double max(double d1, double d2) {
+		if (d1 > d2)
+			return d1;
+		if (d1 < d2)
+			return d2;
+		/* if either arg is NaN, return NaN */
+		if (d1 != d2)
+			return Double.NaN;
+		/* max( +0.0,-0.0) == +0.0 */
+		if (d1 == 0.0
+				&& ((Double.doubleToLongBits(d1) & Double.doubleToLongBits(d2)) & 0x8000000000000000L) == 0)
+			return 0.0;
+		return d1;
+	}
+
+	/**
+	 * Answers the most positive (i.e. closest to positive infinity) of the two
+	 * arguments.
+	 * 
+	 * @param f1
+	 *            the first argument to check
+	 * @param f2
+	 *            the second argument
+	 * @return the larger of f1 and f2.
+	 */
+	public static float max(float f1, float f2) {
+		if (f1 > f2)
+			return f1;
+		if (f1 < f2)
+			return f2;
+		/* if either arg is NaN, return NaN */
+		if (f1 != f2)
+			return Float.NaN;
+		/* max( +0.0,-0.0) == +0.0 */
+		if (f1 == 0.0f
+				&& ((Float.floatToIntBits(f1) & Float.floatToIntBits(f2)) & 0x80000000) == 0)
+			return 0.0f;
+		return f1;
+	}
+
+	/**
+	 * Answers the most positive (i.e. closest to positive infinity) of the two
+	 * arguments.
+	 * 
+	 * @param i1
+	 *            the first argument to check
+	 * @param i2
+	 *            the second argument
+	 * @return the larger of i1 and i2.
+	 */
+	public static int max(int i1, int i2) {
+		return i1 > i2 ? i1 : i2;
+	}
+
+	/**
+	 * Answers the most positive (i.e. closest to positive infinity) of the two
+	 * arguments.
+	 * 
+	 * @param l1
+	 *            the first argument to check
+	 * @param l2
+	 *            the second argument
+	 * @return the larger of l1 and l2.
+	 */
+	public static long max(long l1, long l2) {
+		return l1 > l2 ? l1 : l2;
+	}
+
+	/**
+	 * Answers the most negative (i.e. closest to negative infinity) of the two
+	 * arguments.
+	 * 
+	 * @param d1
+	 *            the first argument to check
+	 * @param d2
+	 *            the second argument
+	 * @return the smaller of d1 and d2.
+	 */
+	public static double min(double d1, double d2) {
+		if (d1 > d2)
+			return d2;
+		if (d1 < d2)
+			return d1;
+		/* if either arg is NaN, return NaN */
+		if (d1 != d2)
+			return Double.NaN;
+		/* min( +0.0,-0.0) == -0.0 */
+		if (d1 == 0.0
+				&& ((Double.doubleToLongBits(d1) | Double.doubleToLongBits(d2)) & 0x8000000000000000l) != 0)
+			return 0.0 * (-1.0);
+		return d1;
+	}
+
+	/**
+	 * Answers the most negative (i.e. closest to negative infinity) of the two
+	 * arguments.
+	 * 
+	 * @param f1
+	 *            the first argument to check
+	 * @param f2
+	 *            the second argument
+	 * @return the smaller of f1 and f2.
+	 */
+	public static float min(float f1, float f2) {
+		if (f1 > f2)
+			return f2;
+		if (f1 < f2)
+			return f1;
+		/* if either arg is NaN, return NaN */
+		if (f1 != f2)
+			return Float.NaN;
+		/* min( +0.0,-0.0) == -0.0 */
+		if (f1 == 0.0f
+				&& ((Float.floatToIntBits(f1) | Float.floatToIntBits(f2)) & 0x80000000) != 0)
+			return 0.0f * (-1.0f);
+		return f1;
+	}
+
+	/**
+	 * Answers the most negative (i.e. closest to negative infinity) of the two
+	 * arguments.
+	 * 
+	 * @param i1
+	 *            the first argument to check
+	 * @param i2
+	 *            the second argument
+	 * @return the smaller of i1 and i2.
+	 */
+	public static int min(int i1, int i2) {
+		return i1 < i2 ? i1 : i2;
+	}
+
+	/**
+	 * Answers the most negative (i.e. closest to negative infinity) of the two
+	 * arguments.
+	 * 
+	 * @param l1
+	 *            the first argument to check
+	 * @param l2
+	 *            the second argument
+	 * @return the smaller of l1 and l2.
+	 */
+	public static long min(long l1, long l2) {
+		return l1 < l2 ? l1 : l2;
+	}
+
+	/**
+	 * Answers the closest double approximation of the result of raising the
+	 * first argument to the power of the second.
+	 * 
+	 * @param d1
+	 *            the base of the operation.
+	 * @param d2
+	 *            the exponent of the operation.
+	 * @return d1 to the power of d2
+	 */
+	public static native double pow(double d1, double d2);
+
+	/**
+	 * Returns a pseudo-random number between 0.0 and 1.0.
+	 * 
+	 * @return a pseudo-random number
+	 */
+	public static double random() {
+		if (random == null)
+			random = new Random();
+		return random.nextDouble();
+	}
+
+	/**
+	 * Answers the double conversion of the result of rounding the argument to
+	 * an integer.
+	 * 
+	 * @param d
+	 *            the value to be converted
+	 * @return the closest integer to the argument (as a double).
+	 */
+	public static native double rint(double d);
+
+	/**
+	 * Answers the result of rounding the argument to an integer.
+	 * 
+	 * @param d
+	 *            the value to be converted
+	 * @return the closest integer to the argument.
+	 */
+	public static long round(double d) {
+		// check for NaN
+		if (d != d)
+			return 0L;
+		return (long) Math.floor(d + 0.5d);
+	}
+
+	/**
+	 * Answers the result of rounding the argument to an integer.
+	 * 
+	 * @param f
+	 *            the value to be converted
+	 * @return the closest integer to the argument.
+	 */
+	public static int round(float f) {
+		// check for NaN
+		if (f != f)
+			return 0;
+		return (int) Math.floor(f + 0.5f);
+	}
+
+	/**
+	 * Answers the closest double approximation of the sine of the argument
+	 * 
+	 * @param d
+	 *            the value to compute sin of
+	 * @return the sine of the argument.
+	 */
+	public static native double sin(double d);
+
+	/**
+	 * Answers the closest double approximation of the square root of the
+	 * argument
+	 * 
+	 * @param d
+	 *            the value to compute sqrt of
+	 * @return the square root of the argument.
+	 */
+	public static native double sqrt(double d);
+
+	/**
+	 * Answers the closest double approximation of the tangent of the argument
+	 * 
+	 * @param d
+	 *            the value to compute tan of
+	 * @return the tangent of the argument.
+	 */
+	public static native double tan(double d);
+
+	/**
+	 * Returns the measure in degrees of the supplied radian angle
+	 * 
+	 * @param angrad
+	 *            an angle in radians
+	 * @return the degree measure of the angle.
+	 */
+	public static double toDegrees(double angrad) {
+		return angrad * 180d / PI;
+	}
+
+	/**
+	 * Returns the measure in radians of the supplied degree angle
+	 * 
+	 * @param angdeg
+	 *            an angle in degrees
+	 * @return the radian measure of the angle.
+	 */
+	public static double toRadians(double angdeg) {
+		return angdeg / 180d * PI;
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringBuffer.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringBuffer.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringBuffer.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringBuffer.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,1084 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+import java.io.IOException;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Arrays;
+
+/**
+ * StringBuffer is a variable size contiguous indexable array of characters. The
+ * length of the StringBuffer is the number of characters it contains. The
+ * capacity of the StringBuffer is the number of characters it can hold.
+ * <p>
+ * Characters may be inserted at any position up to the length of the
+ * StringBuffer, increasing the length of the StringBuffer. Characters at any
+ * position in the StringBuffer may be replaced, which does not affect the
+ * StringBuffer length.
+ * <p>
+ * The capacity of a StringBuffer may be specified when the StringBuffer is
+ * created. If the capacity of the StringBuffer is exceeded, the capacity is
+ * increased.
+ * 
+ * @see String
+ */
+public final class StringBuffer implements Serializable, CharSequence {
+	
+	static final long serialVersionUID = 3388685877147921107L;
+
+	private static final int INITIAL_SIZE = 16;
+
+	private int count;
+
+	private boolean shared;
+
+	private char[] value;
+
+	/**
+	 * Constructs a new StringBuffer using the default capacity.
+	 */
+	public StringBuffer() {
+		this(INITIAL_SIZE);
+	}
+
+	/**
+	 * Constructs a new StringBuffer using the specified capacity.
+	 * 
+	 * @param capacity
+	 *            the initial capacity
+	 */
+	public StringBuffer(int capacity) {
+		count = 0;
+		shared = false;
+		value = new char[capacity];
+	}
+
+	/**
+	 * Constructs a new StringBuffer containing the characters in the specified
+	 * string and the default capacity.
+	 * 
+	 * @param string
+	 *            the string content with which to initialize the new
+	 *            <code>StringBuffer</code> instance
+	 * @exception NullPointerException
+	 *                on supplying a <code>null</code> value of
+	 *                <code>string</code>
+	 */
+	public StringBuffer(String string) {
+		count = string.length();
+		shared = false;
+		value = new char[count + INITIAL_SIZE];
+		string.getChars(0, count, value, 0);
+	}
+
+	/**
+	 * Adds the character array to the end of this StringBuffer.
+	 * 
+	 * @param chars
+	 *            the character array
+	 * @return this StringBuffer
+	 * 
+	 * @exception NullPointerException
+	 *                when chars is null
+	 */
+	public synchronized StringBuffer append(char chars[]) {
+		int newSize = count + chars.length;
+		if (newSize > value.length) {
+			ensureCapacityImpl(newSize);
+		} else if (shared) {
+			value = (char[]) value.clone();
+			shared = false;
+		}
+		System.arraycopy(chars, 0, value, count, chars.length);
+		count = newSize;
+		return this;
+	}
+
+	/**
+	 * Adds the specified sequence of characters to the end of this
+	 * StringBuffer.
+	 * 
+	 * @param chars
+	 *            a character array
+	 * @param start
+	 *            the starting offset
+	 * @param length
+	 *            the number of characters
+	 * @return this StringBuffer
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>length < 0, start < 0</code> or
+	 *                <code>start + length > chars.length</code>
+	 * @exception NullPointerException
+	 *                when chars is null
+	 */
+	public synchronized StringBuffer append(char chars[], int start, int length) {
+		// start + length could overflow, start/length maybe MaxInt
+		if (start >= 0 && 0 <= length && length <= chars.length - start) {
+			int newSize = count + length;
+			if (newSize > value.length) {
+				ensureCapacityImpl(newSize);
+			} else if (shared) {
+				value = (char[]) value.clone();
+				shared = false;
+			}
+			System.arraycopy(chars, start, value, count, length);
+			count = newSize;
+			return this;
+		}
+		throw new StringIndexOutOfBoundsException();
+	}
+
+	/**
+	 * Adds the specified character to the end of this StringBuffer.
+	 * 
+	 * @param ch
+	 *            a character
+	 * @return this StringBuffer
+	 */
+	public synchronized StringBuffer append(char ch) {
+		if (count >= value.length) {
+			ensureCapacityImpl(count + 1);
+		}
+		if (shared) {
+			value = (char[]) value.clone();
+			shared = false;
+		}
+		value[count] = ch;
+		count++;
+		return this;
+	}
+
+	/**
+	 * Adds the string representation of the specified double to the end of this
+	 * StringBuffer.
+	 * 
+	 * @param d
+	 *            the double
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(double d) {
+		return append(String.valueOf(d));
+	}
+
+	/**
+	 * Adds the string representation of the specified float to the end of this
+	 * StringBuffer.
+	 * 
+	 * @param f
+	 *            the float
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(float f) {
+		return append(String.valueOf(f));
+	}
+
+	/**
+	 * Adds the string representation of the specified integer to the end of
+	 * this StringBuffer.
+	 * 
+	 * @param value
+	 *            the integer
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(int i) {
+		return append(Integer.toString(i));
+	}
+
+	/**
+	 * Adds the string representation of the specified long to the end of this
+	 * StringBuffer.
+	 * 
+	 * @param l
+	 *            the long
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(long l) {
+		return append(Long.toString(l));
+	}
+
+	/**
+	 * Adds the string representation of the specified object to the end of this
+	 * StringBuffer.
+	 * 
+	 * @param obj
+	 *            the object
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(Object obj) {
+		return append(String.valueOf(obj));
+	}
+
+	/**
+	 * Adds the specified string to the end of this StringBuffer.
+	 * 
+	 * @param string
+	 *            the string
+	 * @return this StringBuffer
+	 */
+	public synchronized StringBuffer append(String string) {
+		if (string == null)
+			string = String.valueOf(string);
+		int adding = string.length();
+		int newSize = count + adding;
+		if (newSize > value.length) {
+			ensureCapacityImpl(newSize);
+		} else if (shared) {
+			value = (char[]) value.clone();
+			shared = false;
+		}
+		string.getChars(0, adding, value, count);
+		count = newSize;
+		return this;
+	}
+
+	/**
+	 * Adds the string representation of the specified boolean to the end of
+	 * this StringBuffer.
+	 * 
+	 * @param b
+	 *            the boolean
+	 * @return this StringBuffer
+	 */
+	public StringBuffer append(boolean b) {
+		return append(String.valueOf(b));
+	}
+
+	/**
+	 * Answers the number of characters this StringBuffer can hold without
+	 * growing.
+	 * 
+	 * @return the capacity of this StringBuffer
+	 * 
+	 * @see #ensureCapacity
+	 * @see #length
+	 */
+	public int capacity() {
+		return value.length;
+	}
+
+	/**
+	 * Answers the character at the specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the zero-based index in this StringBuffer
+	 * @return the character at the index
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index >= length()</code>
+	 */
+	public synchronized char charAt(int index) {
+		try {
+			if (index < count)
+				return value[index];
+		} catch (IndexOutOfBoundsException e) {
+		}
+		throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Deletes a range of characters.
+	 * 
+	 * @param start
+	 *            the offset of the first character
+	 * @param end
+	 *            the offset one past the last character
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>start < 0, start > end</code> or
+	 *                <code>end > length()</code>
+	 */
+	public synchronized StringBuffer delete(int start, int end) {
+		if (start >= 0) {
+			if (end > count)
+				end = count;
+			if (end > start) {
+				int length = count - end;
+				if (length > 0) {
+					try {
+						if (!shared) {
+							System.arraycopy(value, end, value, start, length);
+						} else {
+							char[] newData = new char[value.length];
+							System.arraycopy(value, 0, newData, 0, start);
+							System
+									.arraycopy(value, end, newData, start,
+											length);
+							value = newData;
+							shared = false;
+						}
+					} catch (IndexOutOfBoundsException e) {
+						throw new StringIndexOutOfBoundsException();
+					}
+				}
+				count -= end - start;
+				return this;
+			}
+			if (start == end)
+				return this;
+		}
+		throw new StringIndexOutOfBoundsException();
+	}
+
+	/**
+	 * Deletes a single character
+	 * 
+	 * @param location
+	 *            the offset of the character to delete
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>location < 0</code> or
+	 *                <code>location >= length()</code>
+	 */
+	public synchronized StringBuffer deleteCharAt(int location) {
+		if (0 <= location && location < count) {
+			int length = count - location - 1;
+			if (length > 0) {
+				try {
+					if (!shared) {
+						System.arraycopy(value, location + 1, value, location,
+								length);
+					} else {
+						char[] newData = new char[value.length];
+						System.arraycopy(value, 0, newData, 0, location);
+						System.arraycopy(value, location + 1, newData,
+								location, length);
+						value = newData;
+						shared = false;
+					}
+				} catch (IndexOutOfBoundsException e) {
+					throw new StringIndexOutOfBoundsException(location);
+				}
+			}
+			count--;
+			return this;
+		}
+		throw new StringIndexOutOfBoundsException(location);
+	}
+
+	/**
+	 * Ensures that this StringBuffer can hold the specified number of
+	 * characters without growing.
+	 * 
+	 * @param min
+	 *            the minimum number of elements that this StringBuffer will
+	 *            hold before growing
+	 */
+	public synchronized void ensureCapacity(int min) {
+		if (min > value.length)
+			ensureCapacityImpl(min);
+	}
+
+	private void ensureCapacityImpl(int min) {
+		int twice = (value.length << 1) + 2;
+		char[] newData = new char[min > twice ? min : twice];
+		System.arraycopy(value, 0, newData, 0, count);
+		value = newData;
+		shared = false;
+	}
+
+	/**
+	 * Copies the specified characters in this StringBuffer to the character
+	 * array starting at the specified offset in the character array.
+	 * 
+	 * @param start
+	 *            the starting offset of characters to copy
+	 * @param end
+	 *            the ending offset of characters to copy
+	 * @param buffer
+	 *            the destination character array
+	 * @param index
+	 *            the starting offset in the character array
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>start < 0, end > length(),
+	 *				start > end, index < 0, end - start > buffer.length - index</code>
+	 * @exception NullPointerException
+	 *                when buffer is null
+	 */
+	public synchronized void getChars(int start, int end, char[] buffer,
+			int index) {
+		// NOTE last character not copied!
+		try {
+			if (start <= count && end <= count) {
+				System.arraycopy(value, start, buffer, index, end - start);
+				return;
+			}
+		} catch (IndexOutOfBoundsException e) {
+		}
+		throw new StringIndexOutOfBoundsException();
+	}
+
+	/**
+	 * Inserts the character array at the specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param chars
+	 *            the character array to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 * @exception NullPointerException
+	 *                when chars is null
+	 */
+	public synchronized StringBuffer insert(int index, char[] chars) {
+		if (0 <= index && index <= count) {
+			move(chars.length, index);
+			System.arraycopy(chars, 0, value, index, chars.length);
+			count += chars.length;
+			return this;
+		}
+		throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Inserts the specified sequence of characters at the specified offset in
+	 * this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param chars
+	 *            a character array
+	 * @param start
+	 *            the starting offset
+	 * @param length
+	 *            the number of characters
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>length < 0, start < 0,</code>
+	 *				<code>start + length > chars.length, index < 0</code>
+	 *                or <code>index > length()</code>
+	 * @exception NullPointerException
+	 *                when chars is null
+	 */
+	public synchronized StringBuffer insert(int index, char chars[], int start,
+			int length) {
+		if (0 <= index && index <= count) {
+			// start + length could overflow, start/length maybe MaxInt
+			if (start >= 0 && 0 <= length && length <= chars.length - start) {
+				move(length, index);
+				System.arraycopy(chars, start, value, index, length);
+				count += length;
+				return this;
+			}
+			throw new StringIndexOutOfBoundsException();
+		}
+		throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Inserts the character at the specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param ch
+	 *            the character to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public synchronized StringBuffer insert(int index, char ch) {
+		if (0 <= index && index <= count) {
+			move(1, index);
+			value[index] = ch;
+			count++;
+			return this;
+		}
+		throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Inserts the string representation of the specified double at the
+	 * specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param d
+	 *            the double to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, double d) {
+		return insert(index, String.valueOf(d));
+	}
+
+	/**
+	 * Inserts the string representation of the specified float at the specified
+	 * offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param f
+	 *            the float to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, float f) {
+		return insert(index, String.valueOf(f));
+	}
+
+	/**
+	 * Inserts the string representation of the specified integer at the
+	 * specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param i
+	 *            the integer to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, int i) {
+		return insert(index, Integer.toString(i));
+	}
+
+	/**
+	 * Inserts the string representation of the specified long at the specified
+	 * offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param l
+	 *            the long to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, long l) {
+		return insert(index, Long.toString(l));
+	}
+
+	/**
+	 * Inserts the string representation of the specified object at the
+	 * specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param obj
+	 *            the object to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, Object obj) {
+		return insert(index, String.valueOf(obj));
+	}
+
+	/**
+	 * Inserts the string at the specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param string
+	 *            the string to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public synchronized StringBuffer insert(int index, String string) {
+		if (0 <= index && index <= count) {
+			if (string == null)
+				string = String.valueOf(string);
+			int min = string.length();
+			move(min, index);
+			string.getChars(0, min, value, index);
+			count += min;
+			return this;
+		}
+		throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Inserts the string representation of the specified boolean at the
+	 * specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the index at which to insert
+	 * @param b
+	 *            the boolean to insert
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index > length()</code>
+	 */
+	public StringBuffer insert(int index, boolean b) {
+		return insert(index, String.valueOf(b));
+	}
+
+	/**
+	 * Answers the size of this StringBuffer.
+	 * 
+	 * @return the number of characters in this StringBuffer
+	 */
+	public int length() {
+		return count;
+	}
+
+	private void move(int size, int index) {
+		int newSize;
+		if (value.length - count >= size) {
+			if (!shared) {
+				System.arraycopy(value, index, value, index + size, count
+						- index); // index == count case is no-op
+				return;
+			}
+			newSize = value.length;
+		} else {
+			int a = count + size, b = (value.length << 1) + 2;
+			newSize = a > b ? a : b;
+		}
+
+		char[] newData = new char[newSize];
+		System.arraycopy(value, 0, newData, 0, index);
+		// index == count case is no-op
+		System.arraycopy(value, index, newData, index + size, count - index); 
+		value = newData;
+		shared = false;
+	}
+
+	/**
+	 * Replace a range of characters with the characters in the specified
+	 * String.
+	 * 
+	 * @param start
+	 *            the offset of the first character
+	 * @param end
+	 *            the offset one past the last character
+	 * @param string
+	 *            a String
+	 * @return this StringBuffer
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>start < 0</code> or <code>start > end</code>
+	 */
+	public synchronized StringBuffer replace(int start, int end, String string) {
+		if (start >= 0) {
+			if (end > count)
+				end = count;
+			if (end > start) {
+				int stringLength = string.length();
+				int diff = end - start - stringLength;
+				if (diff > 0) { // replacing with fewer characters
+					if (!shared) {
+						 // index == count case is no-op
+						System.arraycopy(value, end, value, start
+								+ stringLength, count - end);
+					} else {
+						char[] newData = new char[value.length];
+						System.arraycopy(value, 0, newData, 0, start);
+						// index == count case is no-op
+						System.arraycopy(value, end, newData, start
+								+ stringLength, count - end);
+						value = newData;
+						shared = false;
+					}
+				} else if (diff < 0) {
+					// replacing with more characters...need some room
+					move(-diff, end);
+				} else if (shared) {
+					value = (char[]) value.clone();
+					shared = false;
+				}
+				string.getChars(0, stringLength, value, start);
+				count -= diff;
+				return this;
+			}
+			if (start == end) {
+				if (string == null)
+					throw new NullPointerException();
+				return insert(start, string);
+			}
+		}
+		throw new StringIndexOutOfBoundsException();
+	}
+
+	/**
+	 * Reverses the order of characters in this StringBuffer.
+	 * 
+	 * @return this StringBuffer
+	 */
+	public synchronized StringBuffer reverse() {
+		if (count < 2) {
+			return this;
+		}
+		if (!shared) {
+			for (int i = 0, end = count, mid = count / 2; i < mid; i++) {
+				char temp = value[--end];
+				value[end] = value[i];
+				value[i] = temp;
+			}
+		} else {
+			char[] newData = new char[value.length];
+			for (int i = 0, end = count; i < count; i++) {
+				newData[--end] = value[i];
+			}
+			value = newData;
+			shared = false;
+		}
+		return this;
+	}
+
+	/**
+	 * Sets the character at the specified offset in this StringBuffer.
+	 * 
+	 * @param index
+	 *            the zero-based index in this StringBuffer
+	 * @param ch
+	 *            the character
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>index < 0</code> or
+	 *                <code>index >= length()</code>
+	 */
+	public synchronized void setCharAt(int index, char ch) {
+		if (shared) {
+			value = (char[]) value.clone();
+			shared = false;
+		}
+		if (0 <= index && index < count)
+			value[index] = ch;
+		else
+			throw new StringIndexOutOfBoundsException(index);
+	}
+
+	/**
+	 * Sets the length of this StringBuffer to the specified length. If there
+	 * are more than length characters in this StringBuffer, the characters at
+	 * end are lost. If there are less than length characters in the
+	 * StringBuffer, the additional characters are set to <code>\\u0000</code>.
+	 * 
+	 * @param length
+	 *            the new length of this StringBuffer
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>length < 0</code>
+	 * 
+	 * @see #length
+	 */
+	public synchronized void setLength(int length) {
+		if (length > value.length)
+			ensureCapacityImpl(length);
+		if (count > length) {
+			if (!shared) {
+				// NOTE: delete & replace do not void characters orphaned at the
+				// end
+				try {
+					Arrays.fill(value, length, count, (char) 0);
+				} catch (ArrayIndexOutOfBoundsException e) {
+					throw new IndexOutOfBoundsException();
+				}
+			} else {
+				char[] newData = new char[value.length];
+				if (length > 0) {
+					System.arraycopy(value, 0, newData, 0, length);
+				}
+				value = newData;
+				shared = false;
+			}
+		}
+		count = length;
+	}
+
+	/**
+	 * Copies a range of characters into a new String.
+	 * 
+	 * @param start
+	 *            the offset of the first character
+	 * @return a new String containing the characters from start to the end of
+	 *         the string
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>start < 0</code> or
+	 *                <code>start > length()</code>
+	 */
+	public synchronized String substring(int start) {
+		if (0 <= start && start <= count) {
+			shared = true;
+			return new String(start, count - start, value);
+		}
+		throw new StringIndexOutOfBoundsException(start);
+	}
+
+	/**
+	 * Copies a range of characters into a new String.
+	 * 
+	 * @param start
+	 *            the offset of the first character
+	 * @param end
+	 *            the offset one past the last character
+	 * @return a new String containing the characters from start to end - 1
+	 * 
+	 * @exception StringIndexOutOfBoundsException
+	 *                when <code>start < 0, start > end</code> or
+	 *                <code>end > length()</code>
+	 */
+	public synchronized String substring(int start, int end) {
+		if (0 <= start && start <= end && end <= count) {
+			shared = true;
+			return new String(value, start, end - start);
+		}
+		throw new StringIndexOutOfBoundsException();
+	}
+
+	/**
+	 * Answers the contents of this StringBuffer.
+	 * 
+	 * @return a String containing the characters in this StringBuffer
+	 */
+	public synchronized String toString() {
+		if (count >= 256 && count <= (value.length >> 1))
+			return new String(value, 0, count);
+		shared = true;
+		return new String(0, count, value);
+	}
+
+	/*
+	 * Return the underlying buffer and set the shared flag.
+	 * 
+	 */
+	char[] shareValue() {
+		shared = true;
+		return value;
+	}
+
+	private synchronized void writeObject(ObjectOutputStream stream)
+			throws IOException {
+		stream.defaultWriteObject();
+	}
+
+	private void readObject(ObjectInputStream stream) throws IOException,
+			ClassNotFoundException {
+		stream.defaultReadObject();
+		if (count > value.length)
+			throw new InvalidObjectException(com.ibm.oti.util.Msg
+					.getString("K0199"));
+		shared = false;
+	}
+
+	/**
+	 * Adds the specified StringBuffer to the end of this StringBuffer.
+	 * 
+	 * @param sbuffer
+	 *            the StringBuffer
+	 * @return this StringBuffer
+	 * 
+	 * @since 1.4
+	 */
+	public synchronized StringBuffer append(StringBuffer sbuffer) {
+		if (sbuffer == null)
+			return append((String) null);
+		synchronized (sbuffer) {
+			int adding = sbuffer.count;
+			int newSize = count + adding;
+			if (newSize > value.length) {
+				ensureCapacityImpl(newSize);
+			} else if (shared) {
+				value = (char[]) value.clone();
+				shared = false;
+			}
+			System.arraycopy(sbuffer.value, 0, value, count, adding);
+			count = newSize;
+		}
+		return this;
+	}
+
+	/**
+	 * Copies a range of characters into a new String.
+	 * 
+	 * @param start
+	 *            the offset of the first character
+	 * @param end
+	 *            the offset one past the last character
+	 * @return a new String containing the characters from start to end - 1
+	 * 
+	 * @exception IndexOutOfBoundsException
+	 *                when <code>start < 0, start > end</code> or
+	 *                <code>end > length()</code>
+	 * 
+	 * @since 1.4
+	 */
+	public CharSequence subSequence(int start, int end) {
+		return substring(start, end);
+	}
+
+	/**
+	 * Searches in this StringBuffer for the first index of the specified
+	 * character. The search for the character starts at the beginning and moves
+	 * towards the end.
+	 * 
+	 * 
+	 * @param string
+	 *            the string to find
+	 * @return the index in this StringBuffer of the specified character, -1 if
+	 *         the character isn't found
+	 * 
+	 * @see #lastIndexOf(String)
+	 * 
+	 * @since 1.4
+	 */
+	public int indexOf(String string) {
+		return indexOf(string, 0);
+	}
+
+	/**
+	 * Searches in this StringBuffer for the index of the specified character.
+	 * The search for the character starts at the specified offset and moves
+	 * towards the end.
+	 * 
+	 * @param subString
+	 *            the string to find
+	 * @param start
+	 *            the starting offset
+	 * @return the index in this StringBuffer of the specified character, -1 if
+	 *         the character isn't found
+	 * 
+	 * @see #lastIndexOf(String,int)
+	 * 
+	 * @since 1.4
+	 */
+	public synchronized int indexOf(String subString, int start) {
+		if (start < 0)
+			start = 0;
+		int subCount = subString.length();
+		if (subCount > 0) {
+			if (subCount + start > count)
+				return -1;
+			char firstChar = subString.charAt(0);
+			while (true) {
+				int i = start;
+				boolean found = false;
+				for (; i < count; i++)
+					if (value[i] == firstChar) {
+						found = true;
+						break;
+					}
+				if (!found || subCount + i > count)
+					return -1; // handles subCount > count || start >= count
+				int o1 = i, o2 = 0;
+				while (++o2 < subCount && value[++o1] == subString.charAt(o2)) {
+					// Intentionally empty
+				}
+				if (o2 == subCount)
+					return i;
+				start = i + 1;
+			}
+		}
+		return (start < count || start == 0) ? start : count;
+	}
+
+	/**
+	 * Searches in this StringBuffer for the last index of the specified
+	 * character. The search for the character starts at the end and moves
+	 * towards the beginning.
+	 * 
+	 * @param string
+	 *            the string to find
+	 * @return the index in this StringBuffer of the specified character, -1 if
+	 *         the character isn't found
+	 * 
+	 * @see #indexOf(String)
+	 * 
+	 * @since 1.4
+	 */
+	public synchronized int lastIndexOf(String string) {
+		return lastIndexOf(string, count);
+	}
+
+	/**
+	 * Searches in this StringBuffer for the index of the specified character.
+	 * The search for the character starts at the specified offset and moves
+	 * towards the beginning.
+	 * 
+	 * @param subString
+	 *            the string to find
+	 * @param start
+	 *            the starting offset
+	 * @return the index in this StringBuffer of the specified character, -1 if
+	 *         the character isn't found
+	 * 
+	 * @see #indexOf(String,int)
+	 * 
+	 * @since 1.4
+	 */
+	public synchronized int lastIndexOf(String subString, int start) {
+		int subCount = subString.length();
+		if (subCount <= count && start >= 0) {
+			if (subCount > 0) {
+				if (start > count - subCount)
+					start = count - subCount; // count and subCount are both
+												// >= 1
+				char firstChar = subString.charAt(0);
+				while (true) {
+					int i = start;
+					boolean found = false;
+					for (; i >= 0; --i)
+						if (value[i] == firstChar) {
+							found = true;
+							break;
+						}
+					if (!found)
+						return -1;
+					int o1 = i, o2 = 0;
+					while (++o2 < subCount
+							&& value[++o1] == subString.charAt(o2)) {
+						// Intentionally empty
+					}
+					if (o2 == subCount)
+						return i;
+					start = i - 1;
+				}
+			}
+			return start < count ? start : count;
+		}
+		return -1;
+	}
+
+	/*
+	 * Returns the character array for this StringBuffer.
+	 */
+	char[] getValue() {
+		return value;
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringIndexOutOfBoundsException.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringIndexOutOfBoundsException.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringIndexOutOfBoundsException.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/StringIndexOutOfBoundsException.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,57 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+import com.ibm.oti.util.Msg;
+
+/**
+ * This runtime exception is thrown when the a String is indexed with a value
+ * less than zero, or greater than or equal to the size of the array.
+ */
+
+public class StringIndexOutOfBoundsException extends IndexOutOfBoundsException {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public StringIndexOutOfBoundsException() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * (which is based on the argument which is the index which failed) filled
+	 * in.
+	 * 
+	 * @param index
+	 *            int the index which is out of bounds
+	 */
+	public StringIndexOutOfBoundsException(int index) {
+		super(Msg.getString("K0055", index));
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public StringIndexOutOfBoundsException(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadDeath.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadDeath.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadDeath.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadDeath.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,32 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * ThreadDeath is thrown when a thread stops executing. It is used to aid in the
+ * orderly unrolling of the thread's stack (eg. cleanup of monitors).
+ */
+public class ThreadDeath extends Error {
+
+	/**
+	 * Constructs a new instance of this class. Note that in the case of
+	 * ThreadDeath, the walkback may <em>not</em> be filled in a way which
+	 * allows a stack trace to be printed.
+	 */
+	public ThreadDeath() {
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadLocal.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadLocal.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadLocal.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ThreadLocal.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,56 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * A ThreadLocal is a variable that has a per-thread value. Different Threads
+ * may reference the same ThreadLocal object, but the values they observe will
+ * not be <code>==</code>. This provides Thread local storage.
+ * 
+ * @see java.lang.Thread
+ */
+public class ThreadLocal {
+	/**
+	 * Constructs a new ThreadLocal object
+	 */
+	public ThreadLocal() {
+		super();
+	}
+
+	/**
+	 * Return the value of this variable under
+	 * <code>Thread.currentThread()</code>
+	 */
+	public Object get() {
+		return Thread.currentThread().getThreadLocal(this);
+	}
+
+	/**
+	 * Return the initial value of this variable under
+	 * <code>Thread.currentThread()</code>
+	 */
+	protected Object initialValue() {
+		return null;
+	}
+
+	/**
+	 * Set the value of this variable under <code>Thread.currentThread()</code>
+	 */
+	public void set(Object value) {
+		Thread.currentThread().setThreadLocal(this, value);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnknownError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnknownError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnknownError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnknownError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,42 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This error is thrown when the virtual machine must throw an error which does
+ * not match any known exceptional condition.
+ */
+public class UnknownError extends VirtualMachineError {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public UnknownError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public UnknownError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsatisfiedLinkError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsatisfiedLinkError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsatisfiedLinkError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsatisfiedLinkError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,42 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This error is thrown when an attempt is made to invoke a native for which an
+ * implementation could not be found.
+ */
+public class UnsatisfiedLinkError extends LinkageError {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public UnsatisfiedLinkError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public UnsatisfiedLinkError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedClassVersionError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedClassVersionError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedClassVersionError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedClassVersionError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,43 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This error is thrown when an attempt is made to load a class with a format
+ * version that is not supported by the VM.
+ */
+
+public class UnsupportedClassVersionError extends ClassFormatError {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public UnsupportedClassVersionError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public UnsupportedClassVersionError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedOperationException.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedOperationException.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedOperationException.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/UnsupportedOperationException.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,40 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This runtime exception is thrown when an unsupported operation is attempted.
+ */
+public class UnsupportedOperationException extends RuntimeException {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public UnsupportedOperationException() {
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public UnsupportedOperationException(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VerifyError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VerifyError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VerifyError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VerifyError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,42 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This error is thrown when the VM notices that an attempt is made to load a
+ * class which does not pass the class verification phase.
+ */
+public class VerifyError extends LinkageError {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public VerifyError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public VerifyError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VirtualMachineError.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VirtualMachineError.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VirtualMachineError.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/VirtualMachineError.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,44 @@
+/* Copyright 1998, 2002 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This class is the superclass of all classes which represent errors that occur
+ * during the operation of the virtual machine.
+ * 
+ * @see Error
+ */
+public abstract class VirtualMachineError extends Error {
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	public VirtualMachineError() {
+		super();
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and message
+	 * filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 */
+	public VirtualMachineError(String detailMessage) {
+		super(detailMessage);
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Void.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Void.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Void.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/Void.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,44 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang;
+
+
+/**
+ * This class is a placeholder class for the Java keyword <code>void</code>
+ */
+public final class Void extends Object {
+	/**
+	 * The java.lang.Class that represents this class.
+	 */
+	public static final Class TYPE;
+	// Note: This can't be set to "void.class", since *that* is
+	// defined to be "java.lang.Void.TYPE";
+
+	static {
+		Class voidType = null;
+		try {
+			java.lang.reflect.Method method = Runnable.class.getMethod("run",
+					new Class[0]);
+			voidType = method.getReturnType();
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+		TYPE = voidType;
+	}
+
+	private Void() {
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ref/ReferenceQueue.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ref/ReferenceQueue.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ref/ReferenceQueue.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/ref/ReferenceQueue.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,158 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang.ref;
+
+
+/**
+ * The implementation of this class is provided. The non-public implementation
+ * details are documented so the vm vendor can use the implementation.
+ * 
+ * ReferenceQueue is the container on which reference objects are enqueued when
+ * their reachability type is detected for the referent.
+ * 
+ * @since JDK1.2
+ */
+public class ReferenceQueue extends Object {
+	private Reference[] references;
+
+	private int head, tail;
+
+	private boolean empty;
+
+	static private final int DEFAULT_QUEUE_SIZE = 128;
+
+	/**
+	 * Returns the next available reference from the queue if one is enqueued,
+	 * null otherwise. Does not wait for a reference to become available.
+	 * 
+	 * @return Reference next available Reference or NULL.
+	 */
+	public Reference poll() {
+		Reference ref;
+
+		synchronized (this) {
+			if (empty) {
+				return null;
+			}
+			ref = references[head++];
+			ref.dequeue();
+			if (head == references.length) {
+				head = 0;
+			}
+			if (head == tail) {
+				empty = true;
+			}
+		}
+		return ref;
+	}
+
+	/**
+	 * Return the next available enqueued reference on the queue, blocking
+	 * indefinately until one is available.
+	 * 
+	 * @return Reference a Reference object if one is available, null otherwise.
+	 * @exception InterruptedException
+	 *                to interrupt the wait.
+	 */
+	public Reference remove() throws InterruptedException {
+		return remove(0L);
+	}
+
+	/**
+	 * Return the next available enqueued reference on the queue, blocking up to
+	 * the time given until one is available. Return null if no reference became
+	 * available.
+	 * 
+	 * @param timeout
+	 *            maximum time spent waiting for a reference object to become
+	 *            available.
+	 * @return Reference a Reference object if one is available, null otherwise.
+	 * @exception IllegalArgumentException
+	 *                if the wait period is negative. InterruptedException to
+	 *                interrupt the wait.
+	 */
+	public Reference remove(long timeout) throws IllegalArgumentException,
+			InterruptedException {
+		if (timeout < 0) {
+			throw new IllegalArgumentException();
+		}
+
+		Reference ref;
+		synchronized (this) {
+			if (empty) {
+				wait(timeout);
+				if (empty) {
+					return null;
+				}
+			}
+			ref = references[head++];
+			ref.dequeue();
+			if (head == references.length) {
+				head = 0;
+			}
+			if (head == tail) {
+				empty = true;
+			} else {
+				notifyAll();
+			}
+		}
+		return ref;
+	}
+
+	/**
+	 * Enqueue the reference object on the receiver.
+	 * 
+	 * @param reference
+	 *            reference object to be enqueued.
+	 * @return boolean true if reference is enqueued. false if reference failed
+	 *         to enqueue.
+	 */
+	boolean enqueue(Reference reference) {
+		synchronized (this) {
+			if (!empty && head == tail) {
+				/* Queue is full - grow */
+				int newQueueSize = (int) (references.length * 1.10);
+				Reference newQueue[] = new Reference[newQueueSize];
+				System.arraycopy(references, head, newQueue, 0,
+						references.length - head);
+				if (tail > 0) {
+					System.arraycopy(references, 0, newQueue, references.length
+							- head, tail);
+				}
+				head = 0;
+				tail = references.length;
+				references = newQueue;
+			}
+			references[tail++] = reference;
+			if (tail == references.length) {
+				tail = 0;
+			}
+			empty = false;
+			notifyAll();
+		}
+		return true;
+	}
+
+	/**
+	 * Constructs a new instance of this class.
+	 */
+	public ReferenceQueue() {
+		references = new Reference[DEFAULT_QUEUE_SIZE];
+		head = 0;
+		tail = 0;
+		empty = true;
+	}
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationHandler.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationHandler.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationHandler.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationHandler.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,48 @@
+/* Copyright 2001, 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang.reflect;
+
+
+/**
+ * Implementors of this interface decode and dispatch methods sent to proxy
+ * instances.
+ * 
+ * @see Proxy
+ */
+public interface InvocationHandler {
+	/**
+	 * Return the result of decoding and dispatching the method which was
+	 * originally sent to the proxy instance.
+	 * 
+	 * @param proxy
+	 *            the proxy instance which was the receiver of the method.
+	 * @param method
+	 *            the Method invoked on the proxy instance.
+	 * @param args
+	 *            an array of objects containing the parameters passed to the
+	 *            method, or null if no arguments are expected. primitive types
+	 *            are wrapped in the appropriate class.
+	 * @return the result of executing the method
+	 * 
+	 * @throws Throwable
+	 *             if an exception was thrown by the invoked method. The
+	 *             exception must match one of the declared exception types for
+	 *             the invoked method or any unchecked exception type. If not
+	 *             then an UndeclaredThrowableException is thrown.
+	 */
+	public Object invoke(Object proxy, Method method, Object[] args)
+			throws Throwable;
+}

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationTargetException.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationTargetException.java?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationTargetException.java (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/java-src/luni/src/java/lang/reflect/InvocationTargetException.java Wed Nov 30 21:29:27 2005
@@ -0,0 +1,82 @@
+/* Copyright 1998, 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.lang.reflect;
+
+
+/**
+ * This class provides a wrapper for an exception thrown by a Method or
+ * Constructor invocation.
+ * 
+ * @see java.lang.reflect.Method#invoke
+ * @see java.lang.reflect.Constructor#newInstance
+ */
+public class InvocationTargetException extends Exception {
+
+	static final long serialVersionUID = 4085088731926701167L;
+
+	private Throwable target;
+
+	/**
+	 * Constructs a new instance of this class with its walkback filled in.
+	 */
+	protected InvocationTargetException() {
+		super((Throwable) null);
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback and target
+	 * exception filled in.
+	 * 
+	 * @param exception
+	 *            Throwable The exception which occurred while running the
+	 *            Method or Constructor.
+	 */
+	public InvocationTargetException(Throwable exception) {
+		super(null, exception);
+		target = exception;
+	}
+
+	/**
+	 * Constructs a new instance of this class with its walkback, target
+	 * exception and message filled in.
+	 * 
+	 * @param detailMessage
+	 *            String The detail message for the exception.
+	 * @param exception
+	 *            Throwable The exception which occurred while running the
+	 *            Method or Constructor.
+	 */
+	public InvocationTargetException(Throwable exception, String detailMessage) {
+		super(detailMessage, exception);
+		target = exception;
+	}
+
+	/**
+	 * Answers the exception which caused the receiver to be thrown.
+	 */
+	public Throwable getTargetException() {
+		return target;
+	}
+
+	/**
+	 * Answers the cause of this Throwable, or null if there is no cause.
+	 * 
+	 * @return Throwable The receiver's cause.
+	 */
+	public Throwable getCause() {
+		return target;
+	}
+}



Mime
View raw message