# HG changeset patch # User Jaroslav Tulach # Date 1348847943 -7200 # Node ID 0a115f1c6f3c70458fc479ae82b4d7fcdeb7e95a # Parent 4fca8ddf46deb916941a4d6996a657b6ffeae199 Bringing in core Java classes as of OpenJDK tag jdk7-b147 diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/pom.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/pom.xml Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,40 @@ + + + 4.0.0 + + org.apidesign + bck2brwsr + 1.0-SNAPSHOT + + org.apidesign.bck2brwsr + emul + 1.0-SNAPSHOT + Java API Emulation + http://maven.apache.org + + UTF-8 + + + + junit + junit + 3.8.1 + test + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.5.1 + + + non-existing + + + + + + diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/CloneNotSupportedException.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/CloneNotSupportedException.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,65 @@ +/* + * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * Thrown to indicate that the clone method in class + * Object has been called to clone an object, but that + * the object's class does not implement the Cloneable + * interface. + *

+ * Applications that override the clone method can also + * throw this exception to indicate that an object could not or + * should not be cloned. + * + * @author unascribed + * @see java.lang.Cloneable + * @see java.lang.Object#clone() + * @since JDK1.0 + */ + +public +class CloneNotSupportedException extends Exception { + private static final long serialVersionUID = 5195511250079656443L; + + /** + * Constructs a CloneNotSupportedException with no + * detail message. + */ + public CloneNotSupportedException() { + super(); + } + + /** + * Constructs a CloneNotSupportedException with the + * specified detail message. + * + * @param s the detail message. + */ + public CloneNotSupportedException(String s) { + super(s); + } +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/IllegalArgumentException.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/IllegalArgumentException.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,95 @@ +/* + * Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * Thrown to indicate that a method has been passed an illegal or + * inappropriate argument. + * + * @author unascribed + * @see java.lang.Thread#setPriority(int) + * @since JDK1.0 + */ +public +class IllegalArgumentException extends RuntimeException { + /** + * Constructs an IllegalArgumentException with no + * detail message. + */ + public IllegalArgumentException() { + super(); + } + + /** + * Constructs an IllegalArgumentException with the + * specified detail message. + * + * @param s the detail message. + */ + public IllegalArgumentException(String s) { + super(s); + } + + /** + * Constructs a new exception with the specified detail message and + * cause. + * + *

Note that the detail message associated with cause is + * not automatically incorporated in this exception's detail + * message. + * + * @param message the detail message (which is saved for later retrieval + * by the {@link Throwable#getMessage()} method). + * @param cause the cause (which is saved for later retrieval by the + * {@link Throwable#getCause()} method). (A null value + * is permitted, and indicates that the cause is nonexistent or + * unknown.) + * @since 1.5 + */ + public IllegalArgumentException(String message, Throwable cause) { + super(message, cause); + } + + /** + * Constructs a new exception with the specified cause and a detail + * message of (cause==null ? null : cause.toString()) (which + * typically contains the class and detail message of cause). + * This constructor is useful for exceptions that are little more than + * wrappers for other throwables (for example, {@link + * java.security.PrivilegedActionException}). + * + * @param cause the cause (which is saved for later retrieval by the + * {@link Throwable#getCause()} method). (A null value is + * permitted, and indicates that the cause is nonexistent or + * unknown.) + * @since 1.5 + */ + public IllegalArgumentException(Throwable cause) { + super(cause); + } + + private static final long serialVersionUID = -5365630128856068164L; +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/Integer.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/Integer.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,1244 @@ +/* + * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +import java.util.Properties; + +/** + * The {@code Integer} class wraps a value of the primitive type + * {@code int} in an object. An object of type {@code Integer} + * contains a single field whose type is {@code int}. + * + *

In addition, this class provides several methods for converting + * an {@code int} to a {@code String} and a {@code String} to an + * {@code int}, as well as other constants and methods useful when + * dealing with an {@code int}. + * + *

Implementation note: The implementations of the "bit twiddling" + * methods (such as {@link #highestOneBit(int) highestOneBit} and + * {@link #numberOfTrailingZeros(int) numberOfTrailingZeros}) are + * based on material from Henry S. Warren, Jr.'s Hacker's + * Delight, (Addison Wesley, 2002). + * + * @author Lee Boynton + * @author Arthur van Hoff + * @author Josh Bloch + * @author Joseph D. Darcy + * @since JDK1.0 + */ +public final class Integer extends Number implements Comparable { + /** + * A constant holding the minimum value an {@code int} can + * have, -231. + */ + public static final int MIN_VALUE = 0x80000000; + + /** + * A constant holding the maximum value an {@code int} can + * have, 231-1. + */ + public static final int MAX_VALUE = 0x7fffffff; + + /** + * The {@code Class} instance representing the primitive type + * {@code int}. + * + * @since JDK1.1 + */ + public static final Class TYPE = (Class) Class.getPrimitiveClass("int"); + + /** + * All possible chars for representing a number as a String + */ + final static char[] digits = { + '0' , '1' , '2' , '3' , '4' , '5' , + '6' , '7' , '8' , '9' , 'a' , 'b' , + 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , + 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , + 'o' , 'p' , 'q' , 'r' , 's' , 't' , + 'u' , 'v' , 'w' , 'x' , 'y' , 'z' + }; + + /** + * Returns a string representation of the first argument in the + * radix specified by the second argument. + * + *

If the radix is smaller than {@code Character.MIN_RADIX} + * or larger than {@code Character.MAX_RADIX}, then the radix + * {@code 10} is used instead. + * + *

If the first argument is negative, the first element of the + * result is the ASCII minus character {@code '-'} + * ('\u002D'). If the first argument is not + * negative, no sign character appears in the result. + * + *

The remaining characters of the result represent the magnitude + * of the first argument. If the magnitude is zero, it is + * represented by a single zero character {@code '0'} + * ('\u0030'); otherwise, the first character of + * the representation of the magnitude will not be the zero + * character. The following ASCII characters are used as digits: + * + *

+ * {@code 0123456789abcdefghijklmnopqrstuvwxyz} + *
+ * + * These are '\u0030' through + * '\u0039' and '\u0061' through + * '\u007A'. If {@code radix} is + * N, then the first N of these characters + * are used as radix-N digits in the order shown. Thus, + * the digits for hexadecimal (radix 16) are + * {@code 0123456789abcdef}. If uppercase letters are + * desired, the {@link java.lang.String#toUpperCase()} method may + * be called on the result: + * + *
+ * {@code Integer.toString(n, 16).toUpperCase()} + *
+ * + * @param i an integer to be converted to a string. + * @param radix the radix to use in the string representation. + * @return a string representation of the argument in the specified radix. + * @see java.lang.Character#MAX_RADIX + * @see java.lang.Character#MIN_RADIX + */ + public static String toString(int i, int radix) { + + if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + radix = 10; + + /* Use the faster version */ + if (radix == 10) { + return toString(i); + } + + char buf[] = new char[33]; + boolean negative = (i < 0); + int charPos = 32; + + if (!negative) { + i = -i; + } + + while (i <= -radix) { + buf[charPos--] = digits[-(i % radix)]; + i = i / radix; + } + buf[charPos] = digits[-i]; + + if (negative) { + buf[--charPos] = '-'; + } + + return new String(buf, charPos, (33 - charPos)); + } + + /** + * Returns a string representation of the integer argument as an + * unsigned integer in base 16. + * + *

The unsigned integer value is the argument plus 232 + * if the argument is negative; otherwise, it is equal to the + * argument. This value is converted to a string of ASCII digits + * in hexadecimal (base 16) with no extra leading + * {@code 0}s. If the unsigned magnitude is zero, it is + * represented by a single zero character {@code '0'} + * ('\u0030'); otherwise, the first character of + * the representation of the unsigned magnitude will not be the + * zero character. The following characters are used as + * hexadecimal digits: + * + *

+ * {@code 0123456789abcdef} + *
+ * + * These are the characters '\u0030' through + * '\u0039' and '\u0061' through + * '\u0066'. If uppercase letters are + * desired, the {@link java.lang.String#toUpperCase()} method may + * be called on the result: + * + *
+ * {@code Integer.toHexString(n).toUpperCase()} + *
+ * + * @param i an integer to be converted to a string. + * @return the string representation of the unsigned integer value + * represented by the argument in hexadecimal (base 16). + * @since JDK1.0.2 + */ + public static String toHexString(int i) { + return toUnsignedString(i, 4); + } + + /** + * Returns a string representation of the integer argument as an + * unsigned integer in base 8. + * + *

The unsigned integer value is the argument plus 232 + * if the argument is negative; otherwise, it is equal to the + * argument. This value is converted to a string of ASCII digits + * in octal (base 8) with no extra leading {@code 0}s. + * + *

If the unsigned magnitude is zero, it is represented by a + * single zero character {@code '0'} + * ('\u0030'); otherwise, the first character of + * the representation of the unsigned magnitude will not be the + * zero character. The following characters are used as octal + * digits: + * + *

+ * {@code 01234567} + *
+ * + * These are the characters '\u0030' through + * '\u0037'. + * + * @param i an integer to be converted to a string. + * @return the string representation of the unsigned integer value + * represented by the argument in octal (base 8). + * @since JDK1.0.2 + */ + public static String toOctalString(int i) { + return toUnsignedString(i, 3); + } + + /** + * Returns a string representation of the integer argument as an + * unsigned integer in base 2. + * + *

The unsigned integer value is the argument plus 232 + * if the argument is negative; otherwise it is equal to the + * argument. This value is converted to a string of ASCII digits + * in binary (base 2) with no extra leading {@code 0}s. + * If the unsigned magnitude is zero, it is represented by a + * single zero character {@code '0'} + * ('\u0030'); otherwise, the first character of + * the representation of the unsigned magnitude will not be the + * zero character. The characters {@code '0'} + * ('\u0030') and {@code '1'} + * ('\u0031') are used as binary digits. + * + * @param i an integer to be converted to a string. + * @return the string representation of the unsigned integer value + * represented by the argument in binary (base 2). + * @since JDK1.0.2 + */ + public static String toBinaryString(int i) { + return toUnsignedString(i, 1); + } + + /** + * Convert the integer to an unsigned number. + */ + private static String toUnsignedString(int i, int shift) { + char[] buf = new char[32]; + int charPos = 32; + int radix = 1 << shift; + int mask = radix - 1; + do { + buf[--charPos] = digits[i & mask]; + i >>>= shift; + } while (i != 0); + + return new String(buf, charPos, (32 - charPos)); + } + + + final static char [] DigitTens = { + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', + '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', + '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', + '4', '4', '4', '4', '4', '4', '4', '4', '4', '4', + '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', + '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', + '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', + '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', + '9', '9', '9', '9', '9', '9', '9', '9', '9', '9', + } ; + + final static char [] DigitOnes = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + } ; + + // I use the "invariant division by multiplication" trick to + // accelerate Integer.toString. In particular we want to + // avoid division by 10. + // + // The "trick" has roughly the same performance characteristics + // as the "classic" Integer.toString code on a non-JIT VM. + // The trick avoids .rem and .div calls but has a longer code + // path and is thus dominated by dispatch overhead. In the + // JIT case the dispatch overhead doesn't exist and the + // "trick" is considerably faster than the classic code. + // + // TODO-FIXME: convert (x * 52429) into the equiv shift-add + // sequence. + // + // RE: Division by Invariant Integers using Multiplication + // T Gralund, P Montgomery + // ACM PLDI 1994 + // + + /** + * Returns a {@code String} object representing the + * specified integer. The argument is converted to signed decimal + * representation and returned as a string, exactly as if the + * argument and radix 10 were given as arguments to the {@link + * #toString(int, int)} method. + * + * @param i an integer to be converted. + * @return a string representation of the argument in base 10. + */ + public static String toString(int i) { + if (i == Integer.MIN_VALUE) + return "-2147483648"; + int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i); + char[] buf = new char[size]; + getChars(i, size, buf); + return new String(0, size, buf); + } + + /** + * Places characters representing the integer i into the + * character array buf. The characters are placed into + * the buffer backwards starting with the least significant + * digit at the specified index (exclusive), and working + * backwards from there. + * + * Will fail if i == Integer.MIN_VALUE + */ + static void getChars(int i, int index, char[] buf) { + int q, r; + int charPos = index; + char sign = 0; + + if (i < 0) { + sign = '-'; + i = -i; + } + + // Generate two digits per iteration + while (i >= 65536) { + q = i / 100; + // really: r = i - (q * 100); + r = i - ((q << 6) + (q << 5) + (q << 2)); + i = q; + buf [--charPos] = DigitOnes[r]; + buf [--charPos] = DigitTens[r]; + } + + // Fall thru to fast mode for smaller numbers + // assert(i <= 65536, i); + for (;;) { + q = (i * 52429) >>> (16+3); + r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ... + buf [--charPos] = digits [r]; + i = q; + if (i == 0) break; + } + if (sign != 0) { + buf [--charPos] = sign; + } + } + + final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999, + 99999999, 999999999, Integer.MAX_VALUE }; + + // Requires positive x + static int stringSize(int x) { + for (int i=0; ; i++) + if (x <= sizeTable[i]) + return i+1; + } + + /** + * Parses the string argument as a signed integer in the radix + * specified by the second argument. The characters in the string + * must all be digits of the specified radix (as determined by + * whether {@link java.lang.Character#digit(char, int)} returns a + * nonnegative value), except that the first character may be an + * ASCII minus sign {@code '-'} ('\u002D') to + * indicate a negative value or an ASCII plus sign {@code '+'} + * ('\u002B') to indicate a positive value. The + * resulting integer value is returned. + * + *

An exception of type {@code NumberFormatException} is + * thrown if any of the following situations occurs: + *

+ * + *

Examples: + * 

+     * parseInt("0", 10) returns 0
+     * parseInt("473", 10) returns 473
+     * parseInt("+42", 10) returns 42
+     * parseInt("-0", 10) returns 0
+     * parseInt("-FF", 16) returns -255
+     * parseInt("1100110", 2) returns 102
+     * parseInt("2147483647", 10) returns 2147483647
+     * parseInt("-2147483648", 10) returns -2147483648
+     * parseInt("2147483648", 10) throws a NumberFormatException
+     * parseInt("99", 8) throws a NumberFormatException
+     * parseInt("Kona", 10) throws a NumberFormatException
+     * parseInt("Kona", 27) returns 411787
+     *
+ * + * @param s the {@code String} containing the integer + * representation to be parsed + * @param radix the radix to be used while parsing {@code s}. + * @return the integer represented by the string argument in the + * specified radix. + * @exception NumberFormatException if the {@code String} + * does not contain a parsable {@code int}. + */ + public static int parseInt(String s, int radix) + throws NumberFormatException + { + /* + * WARNING: This method may be invoked early during VM initialization + * before IntegerCache is initialized. Care must be taken to not use + * the valueOf method. + */ + + if (s == null) { + throw new NumberFormatException("null"); + } + + if (radix < Character.MIN_RADIX) { + throw new NumberFormatException("radix " + radix + + " less than Character.MIN_RADIX"); + } + + if (radix > Character.MAX_RADIX) { + throw new NumberFormatException("radix " + radix + + " greater than Character.MAX_RADIX"); + } + + int result = 0; + boolean negative = false; + int i = 0, len = s.length(); + int limit = -Integer.MAX_VALUE; + int multmin; + int digit; + + if (len > 0) { + char firstChar = s.charAt(0); + if (firstChar < '0') { // Possible leading "+" or "-" + if (firstChar == '-') { + negative = true; + limit = Integer.MIN_VALUE; + } else if (firstChar != '+') + throw NumberFormatException.forInputString(s); + + if (len == 1) // Cannot have lone "+" or "-" + throw NumberFormatException.forInputString(s); + i++; + } + multmin = limit / radix; + while (i < len) { + // Accumulating negatively avoids surprises near MAX_VALUE + digit = Character.digit(s.charAt(i++),radix); + if (digit < 0) { + throw NumberFormatException.forInputString(s); + } + if (result < multmin) { + throw NumberFormatException.forInputString(s); + } + result *= radix; + if (result < limit + digit) { + throw NumberFormatException.forInputString(s); + } + result -= digit; + } + } else { + throw NumberFormatException.forInputString(s); + } + return negative ? result : -result; + } + + /** + * Parses the string argument as a signed decimal integer. The + * characters in the string must all be decimal digits, except + * that the first character may be an ASCII minus sign {@code '-'} + * ('\u002D') to indicate a negative value or an + * ASCII plus sign {@code '+'} ('\u002B') to + * indicate a positive value. The resulting integer value is + * returned, exactly as if the argument and the radix 10 were + * given as arguments to the {@link #parseInt(java.lang.String, + * int)} method. + * + * @param s a {@code String} containing the {@code int} + * representation to be parsed + * @return the integer value represented by the argument in decimal. + * @exception NumberFormatException if the string does not contain a + * parsable integer. + */ + public static int parseInt(String s) throws NumberFormatException { + return parseInt(s,10); + } + + /** + * Returns an {@code Integer} object holding the value + * extracted from the specified {@code String} when parsed + * with the radix given by the second argument. The first argument + * is interpreted as representing a signed integer in the radix + * specified by the second argument, exactly as if the arguments + * were given to the {@link #parseInt(java.lang.String, int)} + * method. The result is an {@code Integer} object that + * represents the integer value specified by the string. + * + *

In other words, this method returns an {@code Integer} + * object equal to the value of: + * + *

+ * {@code new Integer(Integer.parseInt(s, radix))} + *
+ * + * @param s the string to be parsed. + * @param radix the radix to be used in interpreting {@code s} + * @return an {@code Integer} object holding the value + * represented by the string argument in the specified + * radix. + * @exception NumberFormatException if the {@code String} + * does not contain a parsable {@code int}. + */ + public static Integer valueOf(String s, int radix) throws NumberFormatException { + return Integer.valueOf(parseInt(s,radix)); + } + + /** + * Returns an {@code Integer} object holding the + * value of the specified {@code String}. The argument is + * interpreted as representing a signed decimal integer, exactly + * as if the argument were given to the {@link + * #parseInt(java.lang.String)} method. The result is an + * {@code Integer} object that represents the integer value + * specified by the string. + * + *

In other words, this method returns an {@code Integer} + * object equal to the value of: + * + *

+ * {@code new Integer(Integer.parseInt(s))} + *
+ * + * @param s the string to be parsed. + * @return an {@code Integer} object holding the value + * represented by the string argument. + * @exception NumberFormatException if the string cannot be parsed + * as an integer. + */ + public static Integer valueOf(String s) throws NumberFormatException { + return Integer.valueOf(parseInt(s, 10)); + } + + /** + * Cache to support the object identity semantics of autoboxing for values between + * -128 and 127 (inclusive) as required by JLS. + * + * The cache is initialized on first usage. The size of the cache + * may be controlled by the -XX:AutoBoxCacheMax= option. + * During VM initialization, java.lang.Integer.IntegerCache.high property + * may be set and saved in the private system properties in the + * sun.misc.VM class. + */ + + private static class IntegerCache { + static final int low = -128; + static final int high; + static final Integer cache[]; + + static { + // high value may be configured by property + int h = 127; + String integerCacheHighPropValue = + sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); + if (integerCacheHighPropValue != null) { + int i = parseInt(integerCacheHighPropValue); + i = Math.max(i, 127); + // Maximum array size is Integer.MAX_VALUE + h = Math.min(i, Integer.MAX_VALUE - (-low)); + } + high = h; + + cache = new Integer[(high - low) + 1]; + int j = low; + for(int k = 0; k < cache.length; k++) + cache[k] = new Integer(j++); + } + + private IntegerCache() {} + } + + /** + * Returns an {@code Integer} instance representing the specified + * {@code int} value. If a new {@code Integer} instance is not + * required, this method should generally be used in preference to + * the constructor {@link #Integer(int)}, as this method is likely + * to yield significantly better space and time performance by + * caching frequently requested values. + * + * This method will always cache values in the range -128 to 127, + * inclusive, and may cache other values outside of this range. + * + * @param i an {@code int} value. + * @return an {@code Integer} instance representing {@code i}. + * @since 1.5 + */ + public static Integer valueOf(int i) { + assert IntegerCache.high >= 127; + if (i >= IntegerCache.low && i <= IntegerCache.high) + return IntegerCache.cache[i + (-IntegerCache.low)]; + return new Integer(i); + } + + /** + * The value of the {@code Integer}. + * + * @serial + */ + private final int value; + + /** + * Constructs a newly allocated {@code Integer} object that + * represents the specified {@code int} value. + * + * @param value the value to be represented by the + * {@code Integer} object. + */ + public Integer(int value) { + this.value = value; + } + + /** + * Constructs a newly allocated {@code Integer} object that + * represents the {@code int} value indicated by the + * {@code String} parameter. The string is converted to an + * {@code int} value in exactly the manner used by the + * {@code parseInt} method for radix 10. + * + * @param s the {@code String} to be converted to an + * {@code Integer}. + * @exception NumberFormatException if the {@code String} does not + * contain a parsable integer. + * @see java.lang.Integer#parseInt(java.lang.String, int) + */ + public Integer(String s) throws NumberFormatException { + this.value = parseInt(s, 10); + } + + /** + * Returns the value of this {@code Integer} as a + * {@code byte}. + */ + public byte byteValue() { + return (byte)value; + } + + /** + * Returns the value of this {@code Integer} as a + * {@code short}. + */ + public short shortValue() { + return (short)value; + } + + /** + * Returns the value of this {@code Integer} as an + * {@code int}. + */ + public int intValue() { + return value; + } + + /** + * Returns the value of this {@code Integer} as a + * {@code long}. + */ + public long longValue() { + return (long)value; + } + + /** + * Returns the value of this {@code Integer} as a + * {@code float}. + */ + public float floatValue() { + return (float)value; + } + + /** + * Returns the value of this {@code Integer} as a + * {@code double}. + */ + public double doubleValue() { + return (double)value; + } + + /** + * Returns a {@code String} object representing this + * {@code Integer}'s value. The value is converted to signed + * decimal representation and returned as a string, exactly as if + * the integer value were given as an argument to the {@link + * java.lang.Integer#toString(int)} method. + * + * @return a string representation of the value of this object in + * base 10. + */ + public String toString() { + return toString(value); + } + + /** + * Returns a hash code for this {@code Integer}. + * + * @return a hash code value for this object, equal to the + * primitive {@code int} value represented by this + * {@code Integer} object. + */ + public int hashCode() { + return value; + } + + /** + * Compares this object to the specified object. The result is + * {@code true} if and only if the argument is not + * {@code null} and is an {@code Integer} object that + * contains the same {@code int} value as this object. + * + * @param obj the object to compare with. + * @return {@code true} if the objects are the same; + * {@code false} otherwise. + */ + public boolean equals(Object obj) { + if (obj instanceof Integer) { + return value == ((Integer)obj).intValue(); + } + return false; + } + + /** + * Determines the integer value of the system property with the + * specified name. + * + *

The first argument is treated as the name of a system property. + * System properties are accessible through the + * {@link java.lang.System#getProperty(java.lang.String)} method. The + * string value of this property is then interpreted as an integer + * value and an {@code Integer} object representing this value is + * returned. Details of possible numeric formats can be found with + * the definition of {@code getProperty}. + * + *

If there is no property with the specified name, if the specified name + * is empty or {@code null}, or if the property does not have + * the correct numeric format, then {@code null} is returned. + * + *

In other words, this method returns an {@code Integer} + * object equal to the value of: + * + *

+ * {@code getInteger(nm, null)} + *
+ * + * @param nm property name. + * @return the {@code Integer} value of the property. + * @see java.lang.System#getProperty(java.lang.String) + * @see java.lang.System#getProperty(java.lang.String, java.lang.String) + */ + public static Integer getInteger(String nm) { + return getInteger(nm, null); + } + + /** + * Determines the integer value of the system property with the + * specified name. + * + *

The first argument is treated as the name of a system property. + * System properties are accessible through the {@link + * java.lang.System#getProperty(java.lang.String)} method. The + * string value of this property is then interpreted as an integer + * value and an {@code Integer} object representing this value is + * returned. Details of possible numeric formats can be found with + * the definition of {@code getProperty}. + * + *

The second argument is the default value. An {@code Integer} object + * that represents the value of the second argument is returned if there + * is no property of the specified name, if the property does not have + * the correct numeric format, or if the specified name is empty or + * {@code null}. + * + *

In other words, this method returns an {@code Integer} object + * equal to the value of: + * + *

+ * {@code getInteger(nm, new Integer(val))} + *
+ * + * but in practice it may be implemented in a manner such as: + * + * 
+     * Integer result = getInteger(nm, null);
+     * return (result == null) ? new Integer(val) : result;
+     *
+ * + * to avoid the unnecessary allocation of an {@code Integer} + * object when the default value is not needed. + * + * @param nm property name. + * @param val default value. + * @return the {@code Integer} value of the property. + * @see java.lang.System#getProperty(java.lang.String) + * @see java.lang.System#getProperty(java.lang.String, java.lang.String) + */ + public static Integer getInteger(String nm, int val) { + Integer result = getInteger(nm, null); + return (result == null) ? Integer.valueOf(val) : result; + } + + /** + * Returns the integer value of the system property with the + * specified name. The first argument is treated as the name of a + * system property. System properties are accessible through the + * {@link java.lang.System#getProperty(java.lang.String)} method. + * The string value of this property is then interpreted as an + * integer value, as per the {@code Integer.decode} method, + * and an {@code Integer} object representing this value is + * returned. + * + * + * + *

The second argument is the default value. The default value is + * returned if there is no property of the specified name, if the + * property does not have the correct numeric format, or if the + * specified name is empty or {@code null}. + * + * @param nm property name. + * @param val default value. + * @return the {@code Integer} value of the property. + * @see java.lang.System#getProperty(java.lang.String) + * @see java.lang.System#getProperty(java.lang.String, java.lang.String) + * @see java.lang.Integer#decode + */ + public static Integer getInteger(String nm, Integer val) { + String v = null; + try { + v = System.getProperty(nm); + } catch (IllegalArgumentException e) { + } catch (NullPointerException e) { + } + if (v != null) { + try { + return Integer.decode(v); + } catch (NumberFormatException e) { + } + } + return val; + } + + /** + * Decodes a {@code String} into an {@code Integer}. + * Accepts decimal, hexadecimal, and octal numbers given + * by the following grammar: + * + *

+ *
+ *
DecodableString: + *
Signopt DecimalNumeral + *
Signopt {@code 0x} HexDigits + *
Signopt {@code 0X} HexDigits + *
Signopt {@code #} HexDigits + *
Signopt {@code 0} OctalDigits + *

+ *

Sign: + *
{@code -} + *
{@code +} + *
+ *
+ * + * DecimalNumeral, HexDigits, and OctalDigits + * are as defined in section 3.10.1 of + * The Java™ Language Specification, + * except that underscores are not accepted between digits. + * + *

The sequence of characters following an optional + * sign and/or radix specifier ("{@code 0x}", "{@code 0X}", + * "{@code #}", or leading zero) is parsed as by the {@code + * Integer.parseInt} method with the indicated radix (10, 16, or + * 8). This sequence of characters must represent a positive + * value or a {@link NumberFormatException} will be thrown. The + * result is negated if first character of the specified {@code + * String} is the minus sign. No whitespace characters are + * permitted in the {@code String}. + * + * @param nm the {@code String} to decode. + * @return an {@code Integer} object holding the {@code int} + * value represented by {@code nm} + * @exception NumberFormatException if the {@code String} does not + * contain a parsable integer. + * @see java.lang.Integer#parseInt(java.lang.String, int) + */ + public static Integer decode(String nm) throws NumberFormatException { + int radix = 10; + int index = 0; + boolean negative = false; + Integer result; + + if (nm.length() == 0) + throw new NumberFormatException("Zero length string"); + char firstChar = nm.charAt(0); + // Handle sign, if present + if (firstChar == '-') { + negative = true; + index++; + } else if (firstChar == '+') + index++; + + // Handle radix specifier, if present + if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) { + index += 2; + radix = 16; + } + else if (nm.startsWith("#", index)) { + index ++; + radix = 16; + } + else if (nm.startsWith("0", index) && nm.length() > 1 + index) { + index ++; + radix = 8; + } + + if (nm.startsWith("-", index) || nm.startsWith("+", index)) + throw new NumberFormatException("Sign character in wrong position"); + + try { + result = Integer.valueOf(nm.substring(index), radix); + result = negative ? Integer.valueOf(-result.intValue()) : result; + } catch (NumberFormatException e) { + // If number is Integer.MIN_VALUE, we'll end up here. The next line + // handles this case, and causes any genuine format error to be + // rethrown. + String constant = negative ? ("-" + nm.substring(index)) + : nm.substring(index); + result = Integer.valueOf(constant, radix); + } + return result; + } + + /** + * Compares two {@code Integer} objects numerically. + * + * @param anotherInteger the {@code Integer} to be compared. + * @return the value {@code 0} if this {@code Integer} is + * equal to the argument {@code Integer}; a value less than + * {@code 0} if this {@code Integer} is numerically less + * than the argument {@code Integer}; and a value greater + * than {@code 0} if this {@code Integer} is numerically + * greater than the argument {@code Integer} (signed + * comparison). + * @since 1.2 + */ + public int compareTo(Integer anotherInteger) { + return compare(this.value, anotherInteger.value); + } + + /** + * Compares two {@code int} values numerically. + * The value returned is identical to what would be returned by: + * 

+     *    Integer.valueOf(x).compareTo(Integer.valueOf(y))
+     *
+ * + * @param x the first {@code int} to compare + * @param y the second {@code int} to compare + * @return the value {@code 0} if {@code x == y}; + * a value less than {@code 0} if {@code x < y}; and + * a value greater than {@code 0} if {@code x > y} + * @since 1.7 + */ + public static int compare(int x, int y) { + return (x < y) ? -1 : ((x == y) ? 0 : 1); + } + + + // Bit twiddling + + /** + * The number of bits used to represent an {@code int} value in two's + * complement binary form. + * + * @since 1.5 + */ + public static final int SIZE = 32; + + /** + * Returns an {@code int} value with at most a single one-bit, in the + * position of the highest-order ("leftmost") one-bit in the specified + * {@code int} value. Returns zero if the specified value has no + * one-bits in its two's complement binary representation, that is, if it + * is equal to zero. + * + * @return an {@code int} value with a single one-bit, in the position + * of the highest-order one-bit in the specified value, or zero if + * the specified value is itself equal to zero. + * @since 1.5 + */ + public static int highestOneBit(int i) { + // HD, Figure 3-1 + i |= (i >> 1); + i |= (i >> 2); + i |= (i >> 4); + i |= (i >> 8); + i |= (i >> 16); + return i - (i >>> 1); + } + + /** + * Returns an {@code int} value with at most a single one-bit, in the + * position of the lowest-order ("rightmost") one-bit in the specified + * {@code int} value. Returns zero if the specified value has no + * one-bits in its two's complement binary representation, that is, if it + * is equal to zero. + * + * @return an {@code int} value with a single one-bit, in the position + * of the lowest-order one-bit in the specified value, or zero if + * the specified value is itself equal to zero. + * @since 1.5 + */ + public static int lowestOneBit(int i) { + // HD, Section 2-1 + return i & -i; + } + + /** + * Returns the number of zero bits preceding the highest-order + * ("leftmost") one-bit in the two's complement binary representation + * of the specified {@code int} value. Returns 32 if the + * specified value has no one-bits in its two's complement representation, + * in other words if it is equal to zero. + * + *

Note that this method is closely related to the logarithm base 2. + * For all positive {@code int} values x: + *

+ * + * @return the number of zero bits preceding the highest-order + * ("leftmost") one-bit in the two's complement binary representation + * of the specified {@code int} value, or 32 if the value + * is equal to zero. + * @since 1.5 + */ + public static int numberOfLeadingZeros(int i) { + // HD, Figure 5-6 + if (i == 0) + return 32; + int n = 1; + if (i >>> 16 == 0) { n += 16; i <<= 16; } + if (i >>> 24 == 0) { n += 8; i <<= 8; } + if (i >>> 28 == 0) { n += 4; i <<= 4; } + if (i >>> 30 == 0) { n += 2; i <<= 2; } + n -= i >>> 31; + return n; + } + + /** + * Returns the number of zero bits following the lowest-order ("rightmost") + * one-bit in the two's complement binary representation of the specified + * {@code int} value. Returns 32 if the specified value has no + * one-bits in its two's complement representation, in other words if it is + * equal to zero. + * + * @return the number of zero bits following the lowest-order ("rightmost") + * one-bit in the two's complement binary representation of the + * specified {@code int} value, or 32 if the value is equal + * to zero. + * @since 1.5 + */ + public static int numberOfTrailingZeros(int i) { + // HD, Figure 5-14 + int y; + if (i == 0) return 32; + int n = 31; + y = i <<16; if (y != 0) { n = n -16; i = y; } + y = i << 8; if (y != 0) { n = n - 8; i = y; } + y = i << 4; if (y != 0) { n = n - 4; i = y; } + y = i << 2; if (y != 0) { n = n - 2; i = y; } + return n - ((i << 1) >>> 31); + } + + /** + * Returns the number of one-bits in the two's complement binary + * representation of the specified {@code int} value. This function is + * sometimes referred to as the population count. + * + * @return the number of one-bits in the two's complement binary + * representation of the specified {@code int} value. + * @since 1.5 + */ + public static int bitCount(int i) { + // HD, Figure 5-2 + i = i - ((i >>> 1) & 0x55555555); + i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); + i = (i + (i >>> 4)) & 0x0f0f0f0f; + i = i + (i >>> 8); + i = i + (i >>> 16); + return i & 0x3f; + } + + /** + * Returns the value obtained by rotating the two's complement binary + * representation of the specified {@code int} value left by the + * specified number of bits. (Bits shifted out of the left hand, or + * high-order, side reenter on the right, or low-order.) + * + *

Note that left rotation with a negative distance is equivalent to + * right rotation: {@code rotateLeft(val, -distance) == rotateRight(val, + * distance)}. Note also that rotation by any multiple of 32 is a + * no-op, so all but the last five bits of the rotation distance can be + * ignored, even if the distance is negative: {@code rotateLeft(val, + * distance) == rotateLeft(val, distance & 0x1F)}. + * + * @return the value obtained by rotating the two's complement binary + * representation of the specified {@code int} value left by the + * specified number of bits. + * @since 1.5 + */ + public static int rotateLeft(int i, int distance) { + return (i << distance) | (i >>> -distance); + } + + /** + * Returns the value obtained by rotating the two's complement binary + * representation of the specified {@code int} value right by the + * specified number of bits. (Bits shifted out of the right hand, or + * low-order, side reenter on the left, or high-order.) + * + *

Note that right rotation with a negative distance is equivalent to + * left rotation: {@code rotateRight(val, -distance) == rotateLeft(val, + * distance)}. Note also that rotation by any multiple of 32 is a + * no-op, so all but the last five bits of the rotation distance can be + * ignored, even if the distance is negative: {@code rotateRight(val, + * distance) == rotateRight(val, distance & 0x1F)}. + * + * @return the value obtained by rotating the two's complement binary + * representation of the specified {@code int} value right by the + * specified number of bits. + * @since 1.5 + */ + public static int rotateRight(int i, int distance) { + return (i >>> distance) | (i << -distance); + } + + /** + * Returns the value obtained by reversing the order of the bits in the + * two's complement binary representation of the specified {@code int} + * value. + * + * @return the value obtained by reversing order of the bits in the + * specified {@code int} value. + * @since 1.5 + */ + public static int reverse(int i) { + // HD, Figure 7-1 + i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555; + i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333; + i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f; + i = (i << 24) | ((i & 0xff00) << 8) | + ((i >>> 8) & 0xff00) | (i >>> 24); + return i; + } + + /** + * Returns the signum function of the specified {@code int} value. (The + * return value is -1 if the specified value is negative; 0 if the + * specified value is zero; and 1 if the specified value is positive.) + * + * @return the signum function of the specified {@code int} value. + * @since 1.5 + */ + public static int signum(int i) { + // HD, Section 2-7 + return (i >> 31) | (-i >>> 31); + } + + /** + * Returns the value obtained by reversing the order of the bytes in the + * two's complement representation of the specified {@code int} value. + * + * @return the value obtained by reversing the bytes in the specified + * {@code int} value. + * @since 1.5 + */ + public static int reverseBytes(int i) { + return ((i >>> 24) ) | + ((i >> 8) & 0xFF00) | + ((i << 8) & 0xFF0000) | + ((i << 24)); + } + + /** use serialVersionUID from JDK 1.0.2 for interoperability */ + private static final long serialVersionUID = 1360826667806852920L; +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/InterruptedException.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/InterruptedException.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,69 @@ +/* + * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * Thrown when a thread is waiting, sleeping, or otherwise occupied, + * and the thread is interrupted, either before or during the activity. + * Occasionally a method may wish to test whether the current + * thread has been interrupted, and if so, to immediately throw + * this exception. The following code can be used to achieve + * this effect: + * 

+ *  if (Thread.interrupted())  // Clears interrupted status!
+ *      throw new InterruptedException();
+ *
+ * + * @author Frank Yellin + * @see java.lang.Object#wait() + * @see java.lang.Object#wait(long) + * @see java.lang.Object#wait(long, int) + * @see java.lang.Thread#sleep(long) + * @see java.lang.Thread#interrupt() + * @see java.lang.Thread#interrupted() + * @since JDK1.0 + */ +public +class InterruptedException extends Exception { + private static final long serialVersionUID = 6700697376100628473L; + + /** + * Constructs an InterruptedException with no detail message. + */ + public InterruptedException() { + super(); + } + + /** + * Constructs an InterruptedException with the + * specified detail message. + * + * @param s the detail message. + */ + public InterruptedException(String s) { + super(s); + } +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/Number.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/Number.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,112 @@ +/* + * Copyright (c) 1994, 2001, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * The abstract class Number is the superclass of classes + * BigDecimal, BigInteger, + * Byte, Double, Float, + * Integer, Long, and Short. + *

+ * Subclasses of Number must provide methods to convert + * the represented numeric value to byte, double, + * float, int, long, and + * short. + * + * @author Lee Boynton + * @author Arthur van Hoff + * @see java.lang.Byte + * @see java.lang.Double + * @see java.lang.Float + * @see java.lang.Integer + * @see java.lang.Long + * @see java.lang.Short + * @since JDK1.0 + */ +public abstract class Number implements java.io.Serializable { + /** + * Returns the value of the specified number as an int. + * This may involve rounding or truncation. + * + * @return the numeric value represented by this object after conversion + * to type int. + */ + public abstract int intValue(); + + /** + * Returns the value of the specified number as a long. + * This may involve rounding or truncation. + * + * @return the numeric value represented by this object after conversion + * to type long. + */ + public abstract long longValue(); + + /** + * Returns the value of the specified number as a float. + * This may involve rounding. + * + * @return the numeric value represented by this object after conversion + * to type float. + */ + public abstract float floatValue(); + + /** + * Returns the value of the specified number as a double. + * This may involve rounding. + * + * @return the numeric value represented by this object after conversion + * to type double. + */ + public abstract double doubleValue(); + + /** + * Returns the value of the specified number as a byte. + * This may involve rounding or truncation. + * + * @return the numeric value represented by this object after conversion + * to type byte. + * @since JDK1.1 + */ + public byte byteValue() { + return (byte)intValue(); + } + + /** + * Returns the value of the specified number as a short. + * This may involve rounding or truncation. + * + * @return the numeric value represented by this object after conversion + * to type short. + * @since JDK1.1 + */ + public short shortValue() { + return (short)intValue(); + } + + /** use serialVersionUID from JDK 1.0.2 for interoperability */ + private static final long serialVersionUID = -8742448824652078965L; +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/Object.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/Object.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,554 @@ +/* + * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * Class {@code Object} is the root of the class hierarchy. + * Every class has {@code Object} as a superclass. All objects, + * including arrays, implement the methods of this class. + * + * @author unascribed + * @see java.lang.Class + * @since JDK1.0 + */ +public class Object { + + private static native void registerNatives(); + static { + registerNatives(); + } + + /** + * Returns the runtime class of this {@code Object}. The returned + * {@code Class} object is the object that is locked by {@code + * static synchronized} methods of the represented class. + * + *

The actual result type is {@code Class} + * where {@code |X|} is the erasure of the static type of the + * expression on which {@code getClass} is called. For + * example, no cast is required in this code fragment:

+ * + *

+ * {@code Number n = 0; }
+ * {@code Class c = n.getClass(); } + *

+ * + * @return The {@code Class} object that represents the runtime + * class of this object. + * @see Class Literals, section 15.8.2 of + * The Java™ Language Specification. + */ + public final native Class getClass(); + + /** + * Returns a hash code value for the object. This method is + * supported for the benefit of hash tables such as those provided by + * {@link java.util.HashMap}. + *

+ * The general contract of {@code hashCode} is: + *

+ *

+ * As much as is reasonably practical, the hashCode method defined by + * class {@code Object} does return distinct integers for distinct + * objects. (This is typically implemented by converting the internal + * address of the object into an integer, but this implementation + * technique is not required by the + * JavaTM programming language.) + * + * @return a hash code value for this object. + * @see java.lang.Object#equals(java.lang.Object) + * @see java.lang.System#identityHashCode + */ + public native int hashCode(); + + /** + * Indicates whether some other object is "equal to" this one. + *

+ * The {@code equals} method implements an equivalence relation + * on non-null object references: + *

+ *

+ * The {@code equals} method for class {@code Object} implements + * the most discriminating possible equivalence relation on objects; + * that is, for any non-null reference values {@code x} and + * {@code y}, this method returns {@code true} if and only + * if {@code x} and {@code y} refer to the same object + * ({@code x == y} has the value {@code true}). + *

+ * Note that it is generally necessary to override the {@code hashCode} + * method whenever this method is overridden, so as to maintain the + * general contract for the {@code hashCode} method, which states + * that equal objects must have equal hash codes. + * + * @param obj the reference object with which to compare. + * @return {@code true} if this object is the same as the obj + * argument; {@code false} otherwise. + * @see #hashCode() + * @see java.util.HashMap + */ + public boolean equals(Object obj) { + return (this == obj); + } + + /** + * Creates and returns a copy of this object. The precise meaning + * of "copy" may depend on the class of the object. The general + * intent is that, for any object {@code x}, the expression: + *

+ * 
+     * x.clone() != x
+ * will be true, and that the expression: + *
+ * 
+     * x.clone().getClass() == x.getClass()
+ * will be {@code true}, but these are not absolute requirements. + * While it is typically the case that: + *
+ * 
+     * x.clone().equals(x)
+ * will be {@code true}, this is not an absolute requirement. + *

+ * By convention, the returned object should be obtained by calling + * {@code super.clone}. If a class and all of its superclasses (except + * {@code Object}) obey this convention, it will be the case that + * {@code x.clone().getClass() == x.getClass()}. + *

+ * By convention, the object returned by this method should be independent + * of this object (which is being cloned). To achieve this independence, + * it may be necessary to modify one or more fields of the object returned + * by {@code super.clone} before returning it. Typically, this means + * copying any mutable objects that comprise the internal "deep structure" + * of the object being cloned and replacing the references to these + * objects with references to the copies. If a class contains only + * primitive fields or references to immutable objects, then it is usually + * the case that no fields in the object returned by {@code super.clone} + * need to be modified. + *

+ * The method {@code clone} for class {@code Object} performs a + * specific cloning operation. First, if the class of this object does + * not implement the interface {@code Cloneable}, then a + * {@code CloneNotSupportedException} is thrown. Note that all arrays + * are considered to implement the interface {@code Cloneable} and that + * the return type of the {@code clone} method of an array type {@code T[]} + * is {@code T[]} where T is any reference or primitive type. + * Otherwise, this method creates a new instance of the class of this + * object and initializes all its fields with exactly the contents of + * the corresponding fields of this object, as if by assignment; the + * contents of the fields are not themselves cloned. Thus, this method + * performs a "shallow copy" of this object, not a "deep copy" operation. + *

+ * The class {@code Object} does not itself implement the interface + * {@code Cloneable}, so calling the {@code clone} method on an object + * whose class is {@code Object} will result in throwing an + * exception at run time. + * + * @return a clone of this instance. + * @exception CloneNotSupportedException if the object's class does not + * support the {@code Cloneable} interface. Subclasses + * that override the {@code clone} method can also + * throw this exception to indicate that an instance cannot + * be cloned. + * @see java.lang.Cloneable + */ + protected native Object clone() throws CloneNotSupportedException; + + /** + * Returns a string representation of the object. In general, the + * {@code toString} method returns a string that + * "textually represents" this object. The result should + * be a concise but informative representation that is easy for a + * person to read. + * It is recommended that all subclasses override this method. + *

+ * The {@code toString} method for class {@code Object} + * returns a string consisting of the name of the class of which the + * object is an instance, the at-sign character `{@code @}', and + * the unsigned hexadecimal representation of the hash code of the + * object. In other words, this method returns a string equal to the + * value of: + *

+ * 
+     * getClass().getName() + '@' + Integer.toHexString(hashCode())
+     *
+ * + * @return a string representation of the object. + */ + public String toString() { + return getClass().getName() + "@" + Integer.toHexString(hashCode()); + } + + /** + * Wakes up a single thread that is waiting on this object's + * monitor. If any threads are waiting on this object, one of them + * is chosen to be awakened. The choice is arbitrary and occurs at + * the discretion of the implementation. A thread waits on an object's + * monitor by calling one of the {@code wait} methods. + *

+ * The awakened thread will not be able to proceed until the current + * thread relinquishes the lock on this object. The awakened thread will + * compete in the usual manner with any other threads that might be + * actively competing to synchronize on this object; for example, the + * awakened thread enjoys no reliable privilege or disadvantage in being + * the next thread to lock this object. + *

+ * This method should only be called by a thread that is the owner + * of this object's monitor. A thread becomes the owner of the + * object's monitor in one of three ways: + *

+ *

+ * Only one thread at a time can own an object's monitor. + * + * @exception IllegalMonitorStateException if the current thread is not + * the owner of this object's monitor. + * @see java.lang.Object#notifyAll() + * @see java.lang.Object#wait() + */ + public final native void notify(); + + /** + * Wakes up all threads that are waiting on this object's monitor. A + * thread waits on an object's monitor by calling one of the + * {@code wait} methods. + *

+ * The awakened threads will not be able to proceed until the current + * thread relinquishes the lock on this object. The awakened threads + * will compete in the usual manner with any other threads that might + * be actively competing to synchronize on this object; for example, + * the awakened threads enjoy no reliable privilege or disadvantage in + * being the next thread to lock this object. + *

+ * This method should only be called by a thread that is the owner + * of this object's monitor. See the {@code notify} method for a + * description of the ways in which a thread can become the owner of + * a monitor. + * + * @exception IllegalMonitorStateException if the current thread is not + * the owner of this object's monitor. + * @see java.lang.Object#notify() + * @see java.lang.Object#wait() + */ + public final native void notifyAll(); + + /** + * Causes the current thread to wait until either another thread invokes the + * {@link java.lang.Object#notify()} method or the + * {@link java.lang.Object#notifyAll()} method for this object, or a + * specified amount of time has elapsed. + *

+ * The current thread must own this object's monitor. + *

+ * This method causes the current thread (call it T) to + * place itself in the wait set for this object and then to relinquish + * any and all synchronization claims on this object. Thread T + * becomes disabled for thread scheduling purposes and lies dormant + * until one of four things happens: + *

+ * The thread T is then removed from the wait set for this + * object and re-enabled for thread scheduling. It then competes in the + * usual manner with other threads for the right to synchronize on the + * object; once it has gained control of the object, all its + * synchronization claims on the object are restored to the status quo + * ante - that is, to the situation as of the time that the {@code wait} + * method was invoked. Thread T then returns from the + * invocation of the {@code wait} method. Thus, on return from the + * {@code wait} method, the synchronization state of the object and of + * thread {@code T} is exactly as it was when the {@code wait} method + * was invoked. + *

+ * A thread can also wake up without being notified, interrupted, or + * timing out, a so-called spurious wakeup. While this will rarely + * occur in practice, applications must guard against it by testing for + * the condition that should have caused the thread to be awakened, and + * continuing to wait if the condition is not satisfied. In other words, + * waits should always occur in loops, like this one: + * 

+     *     synchronized (obj) {
+     *         while (<condition does not hold>)
+     *             obj.wait(timeout);
+     *         ... // Perform action appropriate to condition
+     *     }
+     *
+ * (For more information on this topic, see Section 3.2.3 in Doug Lea's + * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, + * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming + * Language Guide" (Addison-Wesley, 2001). + * + *

If the current thread is {@linkplain java.lang.Thread#interrupt() + * interrupted} by any thread before or while it is waiting, then an + * {@code InterruptedException} is thrown. This exception is not + * thrown until the lock status of this object has been restored as + * described above. + * + *

+ * Note that the {@code wait} method, as it places the current thread + * into the wait set for this object, unlocks only this object; any + * other objects on which the current thread may be synchronized remain + * locked while the thread waits. + *

+ * This method should only be called by a thread that is the owner + * of this object's monitor. See the {@code notify} method for a + * description of the ways in which a thread can become the owner of + * a monitor. + * + * @param timeout the maximum time to wait in milliseconds. + * @exception IllegalArgumentException if the value of timeout is + * negative. + * @exception IllegalMonitorStateException if the current thread is not + * the owner of the object's monitor. + * @exception InterruptedException if any thread interrupted the + * current thread before or while the current thread + * was waiting for a notification. The interrupted + * status of the current thread is cleared when + * this exception is thrown. + * @see java.lang.Object#notify() + * @see java.lang.Object#notifyAll() + */ + public final native void wait(long timeout) throws InterruptedException; + + /** + * Causes the current thread to wait until another thread invokes the + * {@link java.lang.Object#notify()} method or the + * {@link java.lang.Object#notifyAll()} method for this object, or + * some other thread interrupts the current thread, or a certain + * amount of real time has elapsed. + *

+ * This method is similar to the {@code wait} method of one + * argument, but it allows finer control over the amount of time to + * wait for a notification before giving up. The amount of real time, + * measured in nanoseconds, is given by: + *

+ * 
+     * 1000000*timeout+nanos
+ *

+ * In all other respects, this method does the same thing as the + * method {@link #wait(long)} of one argument. In particular, + * {@code wait(0, 0)} means the same thing as {@code wait(0)}. + *

+ * The current thread must own this object's monitor. The thread + * releases ownership of this monitor and waits until either of the + * following two conditions has occurred: + *

+ *

+ * The thread then waits until it can re-obtain ownership of the + * monitor and resumes execution. + *

+ * As in the one argument version, interrupts and spurious wakeups are + * possible, and this method should always be used in a loop: + * 

+     *     synchronized (obj) {
+     *         while (<condition does not hold>)
+     *             obj.wait(timeout, nanos);
+     *         ... // Perform action appropriate to condition
+     *     }
+     *
+ * This method should only be called by a thread that is the owner + * of this object's monitor. See the {@code notify} method for a + * description of the ways in which a thread can become the owner of + * a monitor. + * + * @param timeout the maximum time to wait in milliseconds. + * @param nanos additional time, in nanoseconds range + * 0-999999. + * @exception IllegalArgumentException if the value of timeout is + * negative or the value of nanos is + * not in the range 0-999999. + * @exception IllegalMonitorStateException if the current thread is not + * the owner of this object's monitor. + * @exception InterruptedException if any thread interrupted the + * current thread before or while the current thread + * was waiting for a notification. The interrupted + * status of the current thread is cleared when + * this exception is thrown. + */ + public final void wait(long timeout, int nanos) throws InterruptedException { + if (timeout < 0) { + throw new IllegalArgumentException("timeout value is negative"); + } + + if (nanos < 0 || nanos > 999999) { + throw new IllegalArgumentException( + "nanosecond timeout value out of range"); + } + + if (nanos >= 500000 || (nanos != 0 && timeout == 0)) { + timeout++; + } + + wait(timeout); + } + + /** + * Causes the current thread to wait until another thread invokes the + * {@link java.lang.Object#notify()} method or the + * {@link java.lang.Object#notifyAll()} method for this object. + * In other words, this method behaves exactly as if it simply + * performs the call {@code wait(0)}. + *

+ * The current thread must own this object's monitor. The thread + * releases ownership of this monitor and waits until another thread + * notifies threads waiting on this object's monitor to wake up + * either through a call to the {@code notify} method or the + * {@code notifyAll} method. The thread then waits until it can + * re-obtain ownership of the monitor and resumes execution. + *

+ * As in the one argument version, interrupts and spurious wakeups are + * possible, and this method should always be used in a loop: + * 

+     *     synchronized (obj) {
+     *         while (<condition does not hold>)
+     *             obj.wait();
+     *         ... // Perform action appropriate to condition
+     *     }
+     *
+ * This method should only be called by a thread that is the owner + * of this object's monitor. See the {@code notify} method for a + * description of the ways in which a thread can become the owner of + * a monitor. + * + * @exception IllegalMonitorStateException if the current thread is not + * the owner of the object's monitor. + * @exception InterruptedException if any thread interrupted the + * current thread before or while the current thread + * was waiting for a notification. The interrupted + * status of the current thread is cleared when + * this exception is thrown. + * @see java.lang.Object#notify() + * @see java.lang.Object#notifyAll() + */ + public final void wait() throws InterruptedException { + wait(0); + } + + /** + * Called by the garbage collector on an object when garbage collection + * determines that there are no more references to the object. + * A subclass overrides the {@code finalize} method to dispose of + * system resources or to perform other cleanup. + *

+ * The general contract of {@code finalize} is that it is invoked + * if and when the JavaTM virtual + * machine has determined that there is no longer any + * means by which this object can be accessed by any thread that has + * not yet died, except as a result of an action taken by the + * finalization of some other object or class which is ready to be + * finalized. The {@code finalize} method may take any action, including + * making this object available again to other threads; the usual purpose + * of {@code finalize}, however, is to perform cleanup actions before + * the object is irrevocably discarded. For example, the finalize method + * for an object that represents an input/output connection might perform + * explicit I/O transactions to break the connection before the object is + * permanently discarded. + *

+ * The {@code finalize} method of class {@code Object} performs no + * special action; it simply returns normally. Subclasses of + * {@code Object} may override this definition. + *

+ * The Java programming language does not guarantee which thread will + * invoke the {@code finalize} method for any given object. It is + * guaranteed, however, that the thread that invokes finalize will not + * be holding any user-visible synchronization locks when finalize is + * invoked. If an uncaught exception is thrown by the finalize method, + * the exception is ignored and finalization of that object terminates. + *

+ * After the {@code finalize} method has been invoked for an object, no + * further action is taken until the Java virtual machine has again + * determined that there is no longer any means by which this object can + * be accessed by any thread that has not yet died, including possible + * actions by other objects or classes which are ready to be finalized, + * at which point the object may be discarded. + *

+ * The {@code finalize} method is never invoked more than once by a Java + * virtual machine for any given object. + *

+ * Any exception thrown by the {@code finalize} method causes + * the finalization of this object to be halted, but is otherwise + * ignored. + * + * @throws Throwable the {@code Exception} raised by this method + */ + protected void finalize() throws Throwable { } +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/String.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/String.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,3077 @@ +/* + * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +import java.io.ObjectStreamClass; +import java.io.ObjectStreamField; +import java.io.UnsupportedEncodingException; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Formatter; +import java.util.Locale; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; + +/** + * The String class represents character strings. All + * string literals in Java programs, such as "abc", are + * implemented as instances of this class. + *

+ * Strings are constant; their values cannot be changed after they + * are created. String buffers support mutable strings. + * Because String objects are immutable they can be shared. For example: + * 

+ *     String str = "abc";
+ *

+ * is equivalent to: + * 

+ *     char data[] = {'a', 'b', 'c'};
+ *     String str = new String(data);
+ *

+ * Here are some more examples of how strings can be used: + * 

+ *     System.out.println("abc");
+ *     String cde = "cde";
+ *     System.out.println("abc" + cde);
+ *     String c = "abc".substring(2,3);
+ *     String d = cde.substring(1, 2);
+ *
+ *

+ * The class String includes methods for examining + * individual characters of the sequence, for comparing strings, for + * searching strings, for extracting substrings, and for creating a + * copy of a string with all characters translated to uppercase or to + * lowercase. Case mapping is based on the Unicode Standard version + * specified by the {@link java.lang.Character Character} class. + *

+ * The Java language provides special support for the string + * concatenation operator ( + ), and for conversion of + * other objects to strings. String concatenation is implemented + * through the StringBuilder(or StringBuffer) + * class and its append method. + * String conversions are implemented through the method + * toString, defined by Object and + * inherited by all classes in Java. For additional information on + * string concatenation and conversion, see Gosling, Joy, and Steele, + * The Java Language Specification. + * + *

Unless otherwise noted, passing a null argument to a constructor + * or method in this class will cause a {@link NullPointerException} to be + * thrown. + * + *

A String represents a string in the UTF-16 format + * in which supplementary characters are represented by surrogate + * pairs (see the section Unicode + * Character Representations in the Character class for + * more information). + * Index values refer to char code units, so a supplementary + * character uses two positions in a String. + *

The String class provides methods for dealing with + * Unicode code points (i.e., characters), in addition to those for + * dealing with Unicode code units (i.e., char values). + * + * @author Lee Boynton + * @author Arthur van Hoff + * @author Martin Buchholz + * @author Ulf Zibis + * @see java.lang.Object#toString() + * @see java.lang.StringBuffer + * @see java.lang.StringBuilder + * @see java.nio.charset.Charset + * @since JDK1.0 + */ + +public final class String + implements java.io.Serializable, Comparable, CharSequence +{ + /** The value is used for character storage. */ + private final char value[]; + + /** The offset is the first index of the storage that is used. */ + private final int offset; + + /** The count is the number of characters in the String. */ + private final int count; + + /** Cache the hash code for the string */ + private int hash; // Default to 0 + + /** use serialVersionUID from JDK 1.0.2 for interoperability */ + private static final long serialVersionUID = -6849794470754667710L; + + /** + * Class String is special cased within the Serialization Stream Protocol. + * + * A String instance is written initially into an ObjectOutputStream in the + * following format: + * 

+     *      TC_STRING (utf String)
+     *
+ * The String is written by method DataOutput.writeUTF. + * A new handle is generated to refer to all future references to the + * string instance within the stream. + */ + private static final ObjectStreamField[] serialPersistentFields = + new ObjectStreamField[0]; + + /** + * Initializes a newly created {@code String} object so that it represents + * an empty character sequence. Note that use of this constructor is + * unnecessary since Strings are immutable. + */ + public String() { + this.offset = 0; + this.count = 0; + this.value = new char[0]; + } + + /** + * Initializes a newly created {@code String} object so that it represents + * the same sequence of characters as the argument; in other words, the + * newly created string is a copy of the argument string. Unless an + * explicit copy of {@code original} is needed, use of this constructor is + * unnecessary since Strings are immutable. + * + * @param original + * A {@code String} + */ + public String(String original) { + int size = original.count; + char[] originalValue = original.value; + char[] v; + if (originalValue.length > size) { + // The array representing the String is bigger than the new + // String itself. Perhaps this constructor is being called + // in order to trim the baggage, so make a copy of the array. + int off = original.offset; + v = Arrays.copyOfRange(originalValue, off, off+size); + } else { + // The array representing the String is the same + // size as the String, so no point in making a copy. + v = originalValue; + } + this.offset = 0; + this.count = size; + this.value = v; + } + + /** + * Allocates a new {@code String} so that it represents the sequence of + * characters currently contained in the character array argument. The + * contents of the character array are copied; subsequent modification of + * the character array does not affect the newly created string. + * + * @param value + * The initial value of the string + */ + public String(char value[]) { + int size = value.length; + this.offset = 0; + this.count = size; + this.value = Arrays.copyOf(value, size); + } + + /** + * Allocates a new {@code String} that contains characters from a subarray + * of the character array argument. The {@code offset} argument is the + * index of the first character of the subarray and the {@code count} + * argument specifies the length of the subarray. The contents of the + * subarray are copied; subsequent modification of the character array does + * not affect the newly created string. + * + * @param value + * Array that is the source of characters + * + * @param offset + * The initial offset + * + * @param count + * The length + * + * @throws IndexOutOfBoundsException + * If the {@code offset} and {@code count} arguments index + * characters outside the bounds of the {@code value} array + */ + public String(char value[], int offset, int count) { + if (offset < 0) { + throw new StringIndexOutOfBoundsException(offset); + } + if (count < 0) { + throw new StringIndexOutOfBoundsException(count); + } + // Note: offset or count might be near -1>>>1. + if (offset > value.length - count) { + throw new StringIndexOutOfBoundsException(offset + count); + } + this.offset = 0; + this.count = count; + this.value = Arrays.copyOfRange(value, offset, offset+count); + } + + /** + * Allocates a new {@code String} that contains characters from a subarray + * of the Unicode code point array + * argument. The {@code offset} argument is the index of the first code + * point of the subarray and the {@code count} argument specifies the + * length of the subarray. The contents of the subarray are converted to + * {@code char}s; subsequent modification of the {@code int} array does not + * affect the newly created string. + * + * @param codePoints + * Array that is the source of Unicode code points + * + * @param offset + * The initial offset + * + * @param count + * The length + * + * @throws IllegalArgumentException + * If any invalid Unicode code point is found in {@code + * codePoints} + * + * @throws IndexOutOfBoundsException + * If the {@code offset} and {@code count} arguments index + * characters outside the bounds of the {@code codePoints} array + * + * @since 1.5 + */ + public String(int[] codePoints, int offset, int count) { + if (offset < 0) { + throw new StringIndexOutOfBoundsException(offset); + } + if (count < 0) { + throw new StringIndexOutOfBoundsException(count); + } + // Note: offset or count might be near -1>>>1. + if (offset > codePoints.length - count) { + throw new StringIndexOutOfBoundsException(offset + count); + } + + final int end = offset + count; + + // Pass 1: Compute precise size of char[] + int n = count; + for (int i = offset; i < end; i++) { + int c = codePoints[i]; + if (Character.isBmpCodePoint(c)) + continue; + else if (Character.isValidCodePoint(c)) + n++; + else throw new IllegalArgumentException(Integer.toString(c)); + } + + // Pass 2: Allocate and fill in char[] + final char[] v = new char[n]; + + for (int i = offset, j = 0; i < end; i++, j++) { + int c = codePoints[i]; + if (Character.isBmpCodePoint(c)) + v[j] = (char) c; + else + Character.toSurrogates(c, v, j++); + } + + this.value = v; + this.count = n; + this.offset = 0; + } + + /** + * Allocates a new {@code String} constructed from a subarray of an array + * of 8-bit integer values. + * + *

The {@code offset} argument is the index of the first byte of the + * subarray, and the {@code count} argument specifies the length of the + * subarray. + * + *

Each {@code byte} in the subarray is converted to a {@code char} as + * specified in the method above. + * + * @deprecated This method does not properly convert bytes into characters. + * As of JDK 1.1, the preferred way to do this is via the + * {@code String} constructors that take a {@link + * java.nio.charset.Charset}, charset name, or that use the platform's + * default charset. + * + * @param ascii + * The bytes to be converted to characters + * + * @param hibyte + * The top 8 bits of each 16-bit Unicode code unit + * + * @param offset + * The initial offset + * @param count + * The length + * + * @throws IndexOutOfBoundsException + * If the {@code offset} or {@code count} argument is invalid + * + * @see #String(byte[], int) + * @see #String(byte[], int, int, java.lang.String) + * @see #String(byte[], int, int, java.nio.charset.Charset) + * @see #String(byte[], int, int) + * @see #String(byte[], java.lang.String) + * @see #String(byte[], java.nio.charset.Charset) + * @see #String(byte[]) + */ + @Deprecated + public String(byte ascii[], int hibyte, int offset, int count) { + checkBounds(ascii, offset, count); + char value[] = new char[count]; + + if (hibyte == 0) { + for (int i = count ; i-- > 0 ;) { + value[i] = (char) (ascii[i + offset] & 0xff); + } + } else { + hibyte <<= 8; + for (int i = count ; i-- > 0 ;) { + value[i] = (char) (hibyte | (ascii[i + offset] & 0xff)); + } + } + this.offset = 0; + this.count = count; + this.value = value; + } + + /** + * Allocates a new {@code String} containing characters constructed from + * an array of 8-bit integer values. Each character cin the + * resulting string is constructed from the corresponding component + * b in the byte array such that: + * + * 

+     *     c == (char)(((hibyte & 0xff) << 8)
+     *                         | (b & 0xff))
+     *
+ * + * @deprecated This method does not properly convert bytes into + * characters. As of JDK 1.1, the preferred way to do this is via the + * {@code String} constructors that take a {@link + * java.nio.charset.Charset}, charset name, or that use the platform's + * default charset. + * + * @param ascii + * The bytes to be converted to characters + * + * @param hibyte + * The top 8 bits of each 16-bit Unicode code unit + * + * @see #String(byte[], int, int, java.lang.String) + * @see #String(byte[], int, int, java.nio.charset.Charset) + * @see #String(byte[], int, int) + * @see #String(byte[], java.lang.String) + * @see #String(byte[], java.nio.charset.Charset) + * @see #String(byte[]) + */ + @Deprecated + public String(byte ascii[], int hibyte) { + this(ascii, hibyte, 0, ascii.length); + } + + /* Common private utility method used to bounds check the byte array + * and requested offset & length values used by the String(byte[],..) + * constructors. + */ + private static void checkBounds(byte[] bytes, int offset, int length) { + if (length < 0) + throw new StringIndexOutOfBoundsException(length); + if (offset < 0) + throw new StringIndexOutOfBoundsException(offset); + if (offset > bytes.length - length) + throw new StringIndexOutOfBoundsException(offset + length); + } + + /** + * Constructs a new {@code String} by decoding the specified subarray of + * bytes using the specified charset. The length of the new {@code String} + * is a function of the charset, and hence may not be equal to the length + * of the subarray. + * + *

The behavior of this constructor when the given bytes are not valid + * in the given charset is unspecified. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @param offset + * The index of the first byte to decode + * + * @param length + * The number of bytes to decode + + * @param charsetName + * The name of a supported {@linkplain java.nio.charset.Charset + * charset} + * + * @throws UnsupportedEncodingException + * If the named charset is not supported + * + * @throws IndexOutOfBoundsException + * If the {@code offset} and {@code length} arguments index + * characters outside the bounds of the {@code bytes} array + * + * @since JDK1.1 + */ + public String(byte bytes[], int offset, int length, String charsetName) + throws UnsupportedEncodingException + { + if (charsetName == null) + throw new NullPointerException("charsetName"); + checkBounds(bytes, offset, length); + char[] v = StringCoding.decode(charsetName, bytes, offset, length); + this.offset = 0; + this.count = v.length; + this.value = v; + } + + /** + * Constructs a new {@code String} by decoding the specified subarray of + * bytes using the specified {@linkplain java.nio.charset.Charset charset}. + * The length of the new {@code String} is a function of the charset, and + * hence may not be equal to the length of the subarray. + * + *

This method always replaces malformed-input and unmappable-character + * sequences with this charset's default replacement string. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @param offset + * The index of the first byte to decode + * + * @param length + * The number of bytes to decode + * + * @param charset + * The {@linkplain java.nio.charset.Charset charset} to be used to + * decode the {@code bytes} + * + * @throws IndexOutOfBoundsException + * If the {@code offset} and {@code length} arguments index + * characters outside the bounds of the {@code bytes} array + * + * @since 1.6 + */ + public String(byte bytes[], int offset, int length, Charset charset) { + if (charset == null) + throw new NullPointerException("charset"); + checkBounds(bytes, offset, length); + char[] v = StringCoding.decode(charset, bytes, offset, length); + this.offset = 0; + this.count = v.length; + this.value = v; + } + + /** + * Constructs a new {@code String} by decoding the specified array of bytes + * using the specified {@linkplain java.nio.charset.Charset charset}. The + * length of the new {@code String} is a function of the charset, and hence + * may not be equal to the length of the byte array. + * + *

The behavior of this constructor when the given bytes are not valid + * in the given charset is unspecified. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @param charsetName + * The name of a supported {@linkplain java.nio.charset.Charset + * charset} + * + * @throws UnsupportedEncodingException + * If the named charset is not supported + * + * @since JDK1.1 + */ + public String(byte bytes[], String charsetName) + throws UnsupportedEncodingException + { + this(bytes, 0, bytes.length, charsetName); + } + + /** + * Constructs a new {@code String} by decoding the specified array of + * bytes using the specified {@linkplain java.nio.charset.Charset charset}. + * The length of the new {@code String} is a function of the charset, and + * hence may not be equal to the length of the byte array. + * + *

This method always replaces malformed-input and unmappable-character + * sequences with this charset's default replacement string. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @param charset + * The {@linkplain java.nio.charset.Charset charset} to be used to + * decode the {@code bytes} + * + * @since 1.6 + */ + public String(byte bytes[], Charset charset) { + this(bytes, 0, bytes.length, charset); + } + + /** + * Constructs a new {@code String} by decoding the specified subarray of + * bytes using the platform's default charset. The length of the new + * {@code String} is a function of the charset, and hence may not be equal + * to the length of the subarray. + * + *

The behavior of this constructor when the given bytes are not valid + * in the default charset is unspecified. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @param offset + * The index of the first byte to decode + * + * @param length + * The number of bytes to decode + * + * @throws IndexOutOfBoundsException + * If the {@code offset} and the {@code length} arguments index + * characters outside the bounds of the {@code bytes} array + * + * @since JDK1.1 + */ + public String(byte bytes[], int offset, int length) { + checkBounds(bytes, offset, length); + char[] v = StringCoding.decode(bytes, offset, length); + this.offset = 0; + this.count = v.length; + this.value = v; + } + + /** + * Constructs a new {@code String} by decoding the specified array of bytes + * using the platform's default charset. The length of the new {@code + * String} is a function of the charset, and hence may not be equal to the + * length of the byte array. + * + *

The behavior of this constructor when the given bytes are not valid + * in the default charset is unspecified. The {@link + * java.nio.charset.CharsetDecoder} class should be used when more control + * over the decoding process is required. + * + * @param bytes + * The bytes to be decoded into characters + * + * @since JDK1.1 + */ + public String(byte bytes[]) { + this(bytes, 0, bytes.length); + } + + /** + * Allocates a new string that contains the sequence of characters + * currently contained in the string buffer argument. The contents of the + * string buffer are copied; subsequent modification of the string buffer + * does not affect the newly created string. + * + * @param buffer + * A {@code StringBuffer} + */ + public String(StringBuffer buffer) { + String result = buffer.toString(); + this.value = result.value; + this.count = result.count; + this.offset = result.offset; + } + + /** + * Allocates a new string that contains the sequence of characters + * currently contained in the string builder argument. The contents of the + * string builder are copied; subsequent modification of the string builder + * does not affect the newly created string. + * + *

This constructor is provided to ease migration to {@code + * StringBuilder}. Obtaining a string from a string builder via the {@code + * toString} method is likely to run faster and is generally preferred. + * + * @param builder + * A {@code StringBuilder} + * + * @since 1.5 + */ + public String(StringBuilder builder) { + String result = builder.toString(); + this.value = result.value; + this.count = result.count; + this.offset = result.offset; + } + + + // Package private constructor which shares value array for speed. + String(int offset, int count, char value[]) { + this.value = value; + this.offset = offset; + this.count = count; + } + + /** + * Returns the length of this string. + * The length is equal to the number of Unicode + * code units in the string. + * + * @return the length of the sequence of characters represented by this + * object. + */ + public int length() { + return count; + } + + /** + * Returns true if, and only if, {@link #length()} is 0. + * + * @return true if {@link #length()} is 0, otherwise + * false + * + * @since 1.6 + */ + public boolean isEmpty() { + return count == 0; + } + + /** + * Returns the char value at the + * specified index. An index ranges from 0 to + * length() - 1. The first char value of the sequence + * is at index 0, the next at index 1, + * and so on, as for array indexing. + * + *

If the char value specified by the index is a + * surrogate, the surrogate + * value is returned. + * + * @param index the index of the char value. + * @return the char value at the specified index of this string. + * The first char value is at index 0. + * @exception IndexOutOfBoundsException if the index + * argument is negative or not less than the length of this + * string. + */ + public char charAt(int index) { + if ((index < 0) || (index >= count)) { + throw new StringIndexOutOfBoundsException(index); + } + return value[index + offset]; + } + + /** + * Returns the character (Unicode code point) at the specified + * index. The index refers to char values + * (Unicode code units) and ranges from 0 to + * {@link #length()} - 1. + * + *

If the char value specified at the given index + * is in the high-surrogate range, the following index is less + * than the length of this String, and the + * char value at the following index is in the + * low-surrogate range, then the supplementary code point + * corresponding to this surrogate pair is returned. Otherwise, + * the char value at the given index is returned. + * + * @param index the index to the char values + * @return the code point value of the character at the + * index + * @exception IndexOutOfBoundsException if the index + * argument is negative or not less than the length of this + * string. + * @since 1.5 + */ + public int codePointAt(int index) { + if ((index < 0) || (index >= count)) { + throw new StringIndexOutOfBoundsException(index); + } + return Character.codePointAtImpl(value, offset + index, offset + count); + } + + /** + * Returns the character (Unicode code point) before the specified + * index. The index refers to char values + * (Unicode code units) and ranges from 1 to {@link + * CharSequence#length() length}. + * + *

If the char value at (index - 1) + * is in the low-surrogate range, (index - 2) is not + * negative, and the char value at (index - + * 2) is in the high-surrogate range, then the + * supplementary code point value of the surrogate pair is + * returned. If the char value at index - + * 1 is an unpaired low-surrogate or a high-surrogate, the + * surrogate value is returned. + * + * @param index the index following the code point that should be returned + * @return the Unicode code point value before the given index. + * @exception IndexOutOfBoundsException if the index + * argument is less than 1 or greater than the length + * of this string. + * @since 1.5 + */ + public int codePointBefore(int index) { + int i = index - 1; + if ((i < 0) || (i >= count)) { + throw new StringIndexOutOfBoundsException(index); + } + return Character.codePointBeforeImpl(value, offset + index, offset); + } + + /** + * Returns the number of Unicode code points in the specified text + * range of this String. The text range begins at the + * specified beginIndex and extends to the + * char at index endIndex - 1. Thus the + * length (in chars) of the text range is + * endIndex-beginIndex. Unpaired surrogates within + * the text range count as one code point each. + * + * @param beginIndex the index to the first char of + * the text range. + * @param endIndex the index after the last char of + * the text range. + * @return the number of Unicode code points in the specified text + * range + * @exception IndexOutOfBoundsException if the + * beginIndex is negative, or endIndex + * is larger than the length of this String, or + * beginIndex is larger than endIndex. + * @since 1.5 + */ + public int codePointCount(int beginIndex, int endIndex) { + if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) { + throw new IndexOutOfBoundsException(); + } + return Character.codePointCountImpl(value, offset+beginIndex, endIndex-beginIndex); + } + + /** + * Returns the index within this String that is + * offset from the given index by + * codePointOffset code points. Unpaired surrogates + * within the text range given by index and + * codePointOffset count as one code point each. + * + * @param index the index to be offset + * @param codePointOffset the offset in code points + * @return the index within this String + * @exception IndexOutOfBoundsException if index + * is negative or larger then the length of this + * String, or if codePointOffset is positive + * and the substring starting with index has fewer + * than codePointOffset code points, + * or if codePointOffset is negative and the substring + * before index has fewer than the absolute value + * of codePointOffset code points. + * @since 1.5 + */ + public int offsetByCodePoints(int index, int codePointOffset) { + if (index < 0 || index > count) { + throw new IndexOutOfBoundsException(); + } + return Character.offsetByCodePointsImpl(value, offset, count, + offset+index, codePointOffset) - offset; + } + + /** + * Copy characters from this string into dst starting at dstBegin. + * This method doesn't perform any range checking. + */ + void getChars(char dst[], int dstBegin) { + System.arraycopy(value, offset, dst, dstBegin, count); + } + + /** + * Copies characters from this string into the destination character + * array. + *

+ * The first character to be copied is at index srcBegin; + * the last character to be copied is at index srcEnd-1 + * (thus the total number of characters to be copied is + * srcEnd-srcBegin). The characters are copied into the + * subarray of dst starting at index dstBegin + * and ending at index: + * 

+     *     dstbegin + (srcEnd-srcBegin) - 1
+     *
+ * + * @param srcBegin index of the first character in the string + * to copy. + * @param srcEnd index after the last character in the string + * to copy. + * @param dst the destination array. + * @param dstBegin the start offset in the destination array. + * @exception IndexOutOfBoundsException If any of the following + * is true: + * + */ + public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { + if (srcBegin < 0) { + throw new StringIndexOutOfBoundsException(srcBegin); + } + if (srcEnd > count) { + throw new StringIndexOutOfBoundsException(srcEnd); + } + if (srcBegin > srcEnd) { + throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); + } + System.arraycopy(value, offset + srcBegin, dst, dstBegin, + srcEnd - srcBegin); + } + + /** + * Copies characters from this string into the destination byte array. Each + * byte receives the 8 low-order bits of the corresponding character. The + * eight high-order bits of each character are not copied and do not + * participate in the transfer in any way. + * + *

The first character to be copied is at index {@code srcBegin}; the + * last character to be copied is at index {@code srcEnd-1}. The total + * number of characters to be copied is {@code srcEnd-srcBegin}. The + * characters, converted to bytes, are copied into the subarray of {@code + * dst} starting at index {@code dstBegin} and ending at index: + * + * 

+     *     dstbegin + (srcEnd-srcBegin) - 1
+     *
+ * + * @deprecated This method does not properly convert characters into + * bytes. As of JDK 1.1, the preferred way to do this is via the + * {@link #getBytes()} method, which uses the platform's default charset. + * + * @param srcBegin + * Index of the first character in the string to copy + * + * @param srcEnd + * Index after the last character in the string to copy + * + * @param dst + * The destination array + * + * @param dstBegin + * The start offset in the destination array + * + * @throws IndexOutOfBoundsException + * If any of the following is true: + * + */ + @Deprecated + public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) { + if (srcBegin < 0) { + throw new StringIndexOutOfBoundsException(srcBegin); + } + if (srcEnd > count) { + throw new StringIndexOutOfBoundsException(srcEnd); + } + if (srcBegin > srcEnd) { + throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); + } + int j = dstBegin; + int n = offset + srcEnd; + int i = offset + srcBegin; + char[] val = value; /* avoid getfield opcode */ + + while (i < n) { + dst[j++] = (byte)val[i++]; + } + } + + /** + * Encodes this {@code String} into a sequence of bytes using the named + * charset, storing the result into a new byte array. + * + *

The behavior of this method when this string cannot be encoded in + * the given charset is unspecified. The {@link + * java.nio.charset.CharsetEncoder} class should be used when more control + * over the encoding process is required. + * + * @param charsetName + * The name of a supported {@linkplain java.nio.charset.Charset + * charset} + * + * @return The resultant byte array + * + * @throws UnsupportedEncodingException + * If the named charset is not supported + * + * @since JDK1.1 + */ + public byte[] getBytes(String charsetName) + throws UnsupportedEncodingException + { + if (charsetName == null) throw new NullPointerException(); + return StringCoding.encode(charsetName, value, offset, count); + } + + /** + * Encodes this {@code String} into a sequence of bytes using the given + * {@linkplain java.nio.charset.Charset charset}, storing the result into a + * new byte array. + * + *

This method always replaces malformed-input and unmappable-character + * sequences with this charset's default replacement byte array. The + * {@link java.nio.charset.CharsetEncoder} class should be used when more + * control over the encoding process is required. + * + * @param charset + * The {@linkplain java.nio.charset.Charset} to be used to encode + * the {@code String} + * + * @return The resultant byte array + * + * @since 1.6 + */ + public byte[] getBytes(Charset charset) { + if (charset == null) throw new NullPointerException(); + return StringCoding.encode(charset, value, offset, count); + } + + /** + * Encodes this {@code String} into a sequence of bytes using the + * platform's default charset, storing the result into a new byte array. + * + *

The behavior of this method when this string cannot be encoded in + * the default charset is unspecified. The {@link + * java.nio.charset.CharsetEncoder} class should be used when more control + * over the encoding process is required. + * + * @return The resultant byte array + * + * @since JDK1.1 + */ + public byte[] getBytes() { + return StringCoding.encode(value, offset, count); + } + + /** + * Compares this string to the specified object. The result is {@code + * true} if and only if the argument is not {@code null} and is a {@code + * String} object that represents the same sequence of characters as this + * object. + * + * @param anObject + * The object to compare this {@code String} against + * + * @return {@code true} if the given object represents a {@code String} + * equivalent to this string, {@code false} otherwise + * + * @see #compareTo(String) + * @see #equalsIgnoreCase(String) + */ + public boolean equals(Object anObject) { + if (this == anObject) { + return true; + } + if (anObject instanceof String) { + String anotherString = (String)anObject; + int n = count; + if (n == anotherString.count) { + char v1[] = value; + char v2[] = anotherString.value; + int i = offset; + int j = anotherString.offset; + while (n-- != 0) { + if (v1[i++] != v2[j++]) + return false; + } + return true; + } + } + return false; + } + + /** + * Compares this string to the specified {@code StringBuffer}. The result + * is {@code true} if and only if this {@code String} represents the same + * sequence of characters as the specified {@code StringBuffer}. + * + * @param sb + * The {@code StringBuffer} to compare this {@code String} against + * + * @return {@code true} if this {@code String} represents the same + * sequence of characters as the specified {@code StringBuffer}, + * {@code false} otherwise + * + * @since 1.4 + */ + public boolean contentEquals(StringBuffer sb) { + synchronized(sb) { + return contentEquals((CharSequence)sb); + } + } + + /** + * Compares this string to the specified {@code CharSequence}. The result + * is {@code true} if and only if this {@code String} represents the same + * sequence of char values as the specified sequence. + * + * @param cs + * The sequence to compare this {@code String} against + * + * @return {@code true} if this {@code String} represents the same + * sequence of char values as the specified sequence, {@code + * false} otherwise + * + * @since 1.5 + */ + public boolean contentEquals(CharSequence cs) { + if (count != cs.length()) + return false; + // Argument is a StringBuffer, StringBuilder + if (cs instanceof AbstractStringBuilder) { + char v1[] = value; + char v2[] = ((AbstractStringBuilder)cs).getValue(); + int i = offset; + int j = 0; + int n = count; + while (n-- != 0) { + if (v1[i++] != v2[j++]) + return false; + } + return true; + } + // Argument is a String + if (cs.equals(this)) + return true; + // Argument is a generic CharSequence + char v1[] = value; + int i = offset; + int j = 0; + int n = count; + while (n-- != 0) { + if (v1[i++] != cs.charAt(j++)) + return false; + } + return true; + } + + /** + * Compares this {@code String} to another {@code String}, ignoring case + * considerations. Two strings are considered equal ignoring case if they + * are of the same length and corresponding characters in the two strings + * are equal ignoring case. + * + *

Two characters {@code c1} and {@code c2} are considered the same + * ignoring case if at least one of the following is true: + *

+ * + * @param anotherString + * The {@code String} to compare this {@code String} against + * + * @return {@code true} if the argument is not {@code null} and it + * represents an equivalent {@code String} ignoring case; {@code + * false} otherwise + * + * @see #equals(Object) + */ + public boolean equalsIgnoreCase(String anotherString) { + return (this == anotherString) ? true : + (anotherString != null) && (anotherString.count == count) && + regionMatches(true, 0, anotherString, 0, count); + } + + /** + * Compares two strings lexicographically. + * The comparison is based on the Unicode value of each character in + * the strings. The character sequence represented by this + * String object is compared lexicographically to the + * character sequence represented by the argument string. The result is + * a negative integer if this String object + * lexicographically precedes the argument string. The result is a + * positive integer if this String object lexicographically + * follows the argument string. The result is zero if the strings + * are equal; compareTo returns 0 exactly when + * the {@link #equals(Object)} method would return true. + *

+ * This is the definition of lexicographic ordering. If two strings are + * different, then either they have different characters at some index + * that is a valid index for both strings, or their lengths are different, + * or both. If they have different characters at one or more index + * positions, let k be the smallest such index; then the string + * whose character at position k has the smaller value, as + * determined by using the < operator, lexicographically precedes the + * other string. In this case, compareTo returns the + * difference of the two character values at position k in + * the two string -- that is, the value: + * 

+     * this.charAt(k)-anotherString.charAt(k)
+     *
+ * If there is no index position at which they differ, then the shorter + * string lexicographically precedes the longer string. In this case, + * compareTo returns the difference of the lengths of the + * strings -- that is, the value: + * 
+     * this.length()-anotherString.length()
+     *
+ * + * @param anotherString the String to be compared. + * @return the value 0 if the argument string is equal to + * this string; a value less than 0 if this string + * is lexicographically less than the string argument; and a + * value greater than 0 if this string is + * lexicographically greater than the string argument. + */ + public int compareTo(String anotherString) { + int len1 = count; + int len2 = anotherString.count; + int n = Math.min(len1, len2); + char v1[] = value; + char v2[] = anotherString.value; + int i = offset; + int j = anotherString.offset; + + if (i == j) { + int k = i; + int lim = n + i; + while (k < lim) { + char c1 = v1[k]; + char c2 = v2[k]; + if (c1 != c2) { + return c1 - c2; + } + k++; + } + } else { + while (n-- != 0) { + char c1 = v1[i++]; + char c2 = v2[j++]; + if (c1 != c2) { + return c1 - c2; + } + } + } + return len1 - len2; + } + + /** + * A Comparator that orders String objects as by + * compareToIgnoreCase. This comparator is serializable. + *

+ * Note that this Comparator does not take locale into account, + * and will result in an unsatisfactory ordering for certain locales. + * The java.text package provides Collators to allow + * locale-sensitive ordering. + * + * @see java.text.Collator#compare(String, String) + * @since 1.2 + */ + public static final Comparator CASE_INSENSITIVE_ORDER + = new CaseInsensitiveComparator(); + private static class CaseInsensitiveComparator + implements Comparator, java.io.Serializable { + // use serialVersionUID from JDK 1.2.2 for interoperability + private static final long serialVersionUID = 8575799808933029326L; + + public int compare(String s1, String s2) { + int n1 = s1.length(); + int n2 = s2.length(); + int min = Math.min(n1, n2); + for (int i = 0; i < min; i++) { + char c1 = s1.charAt(i); + char c2 = s2.charAt(i); + if (c1 != c2) { + c1 = Character.toUpperCase(c1); + c2 = Character.toUpperCase(c2); + if (c1 != c2) { + c1 = Character.toLowerCase(c1); + c2 = Character.toLowerCase(c2); + if (c1 != c2) { + // No overflow because of numeric promotion + return c1 - c2; + } + } + } + } + return n1 - n2; + } + } + + /** + * Compares two strings lexicographically, ignoring case + * differences. This method returns an integer whose sign is that of + * calling compareTo with normalized versions of the strings + * where case differences have been eliminated by calling + * Character.toLowerCase(Character.toUpperCase(character)) on + * each character. + *

+ * Note that this method does not take locale into account, + * and will result in an unsatisfactory ordering for certain locales. + * The java.text package provides collators to allow + * locale-sensitive ordering. + * + * @param str the String to be compared. + * @return a negative integer, zero, or a positive integer as the + * specified String is greater than, equal to, or less + * than this String, ignoring case considerations. + * @see java.text.Collator#compare(String, String) + * @since 1.2 + */ + public int compareToIgnoreCase(String str) { + return CASE_INSENSITIVE_ORDER.compare(this, str); + } + + /** + * Tests if two string regions are equal. + *

+ * A substring of this String object is compared to a substring + * of the argument other. The result is true if these substrings + * represent identical character sequences. The substring of this + * String object to be compared begins at index toffset + * and has length len. The substring of other to be compared + * begins at index ooffset and has length len. The + * result is false if and only if at least one of the following + * is true: + *

+ * + * @param toffset the starting offset of the subregion in this string. + * @param other the string argument. + * @param ooffset the starting offset of the subregion in the string + * argument. + * @param len the number of characters to compare. + * @return true if the specified subregion of this string + * exactly matches the specified subregion of the string argument; + * false otherwise. + */ + public boolean regionMatches(int toffset, String other, int ooffset, + int len) { + char ta[] = value; + int to = offset + toffset; + char pa[] = other.value; + int po = other.offset + ooffset; + // Note: toffset, ooffset, or len might be near -1>>>1. + if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) + || (ooffset > (long)other.count - len)) { + return false; + } + while (len-- > 0) { + if (ta[to++] != pa[po++]) { + return false; + } + } + return true; + } + + /** + * Tests if two string regions are equal. + *

+ * A substring of this String object is compared to a substring + * of the argument other. The result is true if these + * substrings represent character sequences that are the same, ignoring + * case if and only if ignoreCase is true. The substring of + * this String object to be compared begins at index + * toffset and has length len. The substring of + * other to be compared begins at index ooffset and + * has length len. The result is false if and only if + * at least one of the following is true: + *

+ * + * @param ignoreCase if true, ignore case when comparing + * characters. + * @param toffset the starting offset of the subregion in this + * string. + * @param other the string argument. + * @param ooffset the starting offset of the subregion in the string + * argument. + * @param len the number of characters to compare. + * @return true if the specified subregion of this string + * matches the specified subregion of the string argument; + * false otherwise. Whether the matching is exact + * or case insensitive depends on the ignoreCase + * argument. + */ + public boolean regionMatches(boolean ignoreCase, int toffset, + String other, int ooffset, int len) { + char ta[] = value; + int to = offset + toffset; + char pa[] = other.value; + int po = other.offset + ooffset; + // Note: toffset, ooffset, or len might be near -1>>>1. + if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) || + (ooffset > (long)other.count - len)) { + return false; + } + while (len-- > 0) { + char c1 = ta[to++]; + char c2 = pa[po++]; + if (c1 == c2) { + continue; + } + if (ignoreCase) { + // If characters don't match but case may be ignored, + // try converting both characters to uppercase. + // If the results match, then the comparison scan should + // continue. + char u1 = Character.toUpperCase(c1); + char u2 = Character.toUpperCase(c2); + if (u1 == u2) { + continue; + } + // Unfortunately, conversion to uppercase does not work properly + // for the Georgian alphabet, which has strange rules about case + // conversion. So we need to make one last check before + // exiting. + if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) { + continue; + } + } + return false; + } + return true; + } + + /** + * Tests if the substring of this string beginning at the + * specified index starts with the specified prefix. + * + * @param prefix the prefix. + * @param toffset where to begin looking in this string. + * @return true if the character sequence represented by the + * argument is a prefix of the substring of this object starting + * at index toffset; false otherwise. + * The result is false if toffset is + * negative or greater than the length of this + * String object; otherwise the result is the same + * as the result of the expression + * 
+     *          this.substring(toffset).startsWith(prefix)
+     *
+ */ + public boolean startsWith(String prefix, int toffset) { + char ta[] = value; + int to = offset + toffset; + char pa[] = prefix.value; + int po = prefix.offset; + int pc = prefix.count; + // Note: toffset might be near -1>>>1. + if ((toffset < 0) || (toffset > count - pc)) { + return false; + } + while (--pc >= 0) { + if (ta[to++] != pa[po++]) { + return false; + } + } + return true; + } + + /** + * Tests if this string starts with the specified prefix. + * + * @param prefix the prefix. + * @return true if the character sequence represented by the + * argument is a prefix of the character sequence represented by + * this string; false otherwise. + * Note also that true will be returned if the + * argument is an empty string or is equal to this + * String object as determined by the + * {@link #equals(Object)} method. + * @since 1. 0 + */ + public boolean startsWith(String prefix) { + return startsWith(prefix, 0); + } + + /** + * Tests if this string ends with the specified suffix. + * + * @param suffix the suffix. + * @return true if the character sequence represented by the + * argument is a suffix of the character sequence represented by + * this object; false otherwise. Note that the + * result will be true if the argument is the + * empty string or is equal to this String object + * as determined by the {@link #equals(Object)} method. + */ + public boolean endsWith(String suffix) { + return startsWith(suffix, count - suffix.count); + } + + /** + * Returns a hash code for this string. The hash code for a + * String object is computed as + * 
+     * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
+     *
+ * using int arithmetic, where s[i] is the + * ith character of the string, n is the length of + * the string, and ^ indicates exponentiation. + * (The hash value of the empty string is zero.) + * + * @return a hash code value for this object. + */ + public int hashCode() { + int h = hash; + if (h == 0 && count > 0) { + int off = offset; + char val[] = value; + int len = count; + + for (int i = 0; i < len; i++) { + h = 31*h + val[off++]; + } + hash = h; + } + return h; + } + + /** + * Returns the index within this string of the first occurrence of + * the specified character. If a character with value + * ch occurs in the character sequence represented by + * this String object, then the index (in Unicode + * code units) of the first such occurrence is returned. For + * values of ch in the range from 0 to 0xFFFF + * (inclusive), this is the smallest value k such that: + * 
+     * this.charAt(k) == ch
+     *
+ * is true. For other values of ch, it is the + * smallest value k such that: + * 
+     * this.codePointAt(k) == ch
+     *
+ * is true. In either case, if no such character occurs in this + * string, then -1 is returned. + * + * @param ch a character (Unicode code point). + * @return the index of the first occurrence of the character in the + * character sequence represented by this object, or + * -1 if the character does not occur. + */ + public int indexOf(int ch) { + return indexOf(ch, 0); + } + + /** + * Returns the index within this string of the first occurrence of the + * specified character, starting the search at the specified index. + *

+ * If a character with value ch occurs in the + * character sequence represented by this String + * object at an index no smaller than fromIndex, then + * the index of the first such occurrence is returned. For values + * of ch in the range from 0 to 0xFFFF (inclusive), + * this is the smallest value k such that: + * 

+     * (this.charAt(k) == ch) && (k >= fromIndex)
+     *
+ * is true. For other values of ch, it is the + * smallest value k such that: + * 
+     * (this.codePointAt(k) == ch) && (k >= fromIndex)
+     *
+ * is true. In either case, if no such character occurs in this + * string at or after position fromIndex, then + * -1 is returned. + * + *

+ * There is no restriction on the value of fromIndex. If it + * is negative, it has the same effect as if it were zero: this entire + * string may be searched. If it is greater than the length of this + * string, it has the same effect as if it were equal to the length of + * this string: -1 is returned. + * + *

All indices are specified in char values + * (Unicode code units). + * + * @param ch a character (Unicode code point). + * @param fromIndex the index to start the search from. + * @return the index of the first occurrence of the character in the + * character sequence represented by this object that is greater + * than or equal to fromIndex, or -1 + * if the character does not occur. + */ + public int indexOf(int ch, int fromIndex) { + if (fromIndex < 0) { + fromIndex = 0; + } else if (fromIndex >= count) { + // Note: fromIndex might be near -1>>>1. + return -1; + } + + if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { + // handle most cases here (ch is a BMP code point or a + // negative value (invalid code point)) + final char[] value = this.value; + final int offset = this.offset; + final int max = offset + count; + for (int i = offset + fromIndex; i < max ; i++) { + if (value[i] == ch) { + return i - offset; + } + } + return -1; + } else { + return indexOfSupplementary(ch, fromIndex); + } + } + + /** + * Handles (rare) calls of indexOf with a supplementary character. + */ + private int indexOfSupplementary(int ch, int fromIndex) { + if (Character.isValidCodePoint(ch)) { + final char[] value = this.value; + final int offset = this.offset; + final char hi = Character.highSurrogate(ch); + final char lo = Character.lowSurrogate(ch); + final int max = offset + count - 1; + for (int i = offset + fromIndex; i < max; i++) { + if (value[i] == hi && value[i+1] == lo) { + return i - offset; + } + } + } + return -1; + } + + /** + * Returns the index within this string of the last occurrence of + * the specified character. For values of ch in the + * range from 0 to 0xFFFF (inclusive), the index (in Unicode code + * units) returned is the largest value k such that: + * 

+     * this.charAt(k) == ch
+     *
+ * is true. For other values of ch, it is the + * largest value k such that: + * 
+     * this.codePointAt(k) == ch
+     *
+ * is true. In either case, if no such character occurs in this + * string, then -1 is returned. The + * String is searched backwards starting at the last + * character. + * + * @param ch a character (Unicode code point). + * @return the index of the last occurrence of the character in the + * character sequence represented by this object, or + * -1 if the character does not occur. + */ + public int lastIndexOf(int ch) { + return lastIndexOf(ch, count - 1); + } + + /** + * Returns the index within this string of the last occurrence of + * the specified character, searching backward starting at the + * specified index. For values of ch in the range + * from 0 to 0xFFFF (inclusive), the index returned is the largest + * value k such that: + * 
+     * (this.charAt(k) == ch) && (k <= fromIndex)
+     *
+ * is true. For other values of ch, it is the + * largest value k such that: + * 
+     * (this.codePointAt(k) == ch) && (k <= fromIndex)
+     *
+ * is true. In either case, if no such character occurs in this + * string at or before position fromIndex, then + * -1 is returned. + * + *

All indices are specified in char values + * (Unicode code units). + * + * @param ch a character (Unicode code point). + * @param fromIndex the index to start the search from. There is no + * restriction on the value of fromIndex. If it is + * greater than or equal to the length of this string, it has + * the same effect as if it were equal to one less than the + * length of this string: this entire string may be searched. + * If it is negative, it has the same effect as if it were -1: + * -1 is returned. + * @return the index of the last occurrence of the character in the + * character sequence represented by this object that is less + * than or equal to fromIndex, or -1 + * if the character does not occur before that point. + */ + public int lastIndexOf(int ch, int fromIndex) { + if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { + // handle most cases here (ch is a BMP code point or a + // negative value (invalid code point)) + final char[] value = this.value; + final int offset = this.offset; + int i = offset + Math.min(fromIndex, count - 1); + for (; i >= offset ; i--) { + if (value[i] == ch) { + return i - offset; + } + } + return -1; + } else { + return lastIndexOfSupplementary(ch, fromIndex); + } + } + + /** + * Handles (rare) calls of lastIndexOf with a supplementary character. + */ + private int lastIndexOfSupplementary(int ch, int fromIndex) { + if (Character.isValidCodePoint(ch)) { + final char[] value = this.value; + final int offset = this.offset; + char hi = Character.highSurrogate(ch); + char lo = Character.lowSurrogate(ch); + int i = offset + Math.min(fromIndex, count - 2); + for (; i >= offset; i--) { + if (value[i] == hi && value[i+1] == lo) { + return i - offset; + } + } + } + return -1; + } + + /** + * Returns the index within this string of the first occurrence of the + * specified substring. + * + *

The returned index is the smallest value k for which: + * 

+     * this.startsWith(str, k)
+     *
+ * If no such value of k exists, then {@code -1} is returned. + * + * @param str the substring to search for. + * @return the index of the first occurrence of the specified substring, + * or {@code -1} if there is no such occurrence. + */ + public int indexOf(String str) { + return indexOf(str, 0); + } + + /** + * Returns the index within this string of the first occurrence of the + * specified substring, starting at the specified index. + * + *

The returned index is the smallest value k for which: + * 

+     * k >= fromIndex && this.startsWith(str, k)
+     *
+ * If no such value of k exists, then {@code -1} is returned. + * + * @param str the substring to search for. + * @param fromIndex the index from which to start the search. + * @return the index of the first occurrence of the specified substring, + * starting at the specified index, + * or {@code -1} if there is no such occurrence. + */ + public int indexOf(String str, int fromIndex) { + return indexOf(value, offset, count, + str.value, str.offset, str.count, fromIndex); + } + + /** + * Code shared by String and StringBuffer to do searches. The + * source is the character array being searched, and the target + * is the string being searched for. + * + * @param source the characters being searched. + * @param sourceOffset offset of the source string. + * @param sourceCount count of the source string. + * @param target the characters being searched for. + * @param targetOffset offset of the target string. + * @param targetCount count of the target string. + * @param fromIndex the index to begin searching from. + */ + static int indexOf(char[] source, int sourceOffset, int sourceCount, + char[] target, int targetOffset, int targetCount, + int fromIndex) { + if (fromIndex >= sourceCount) { + return (targetCount == 0 ? sourceCount : -1); + } + if (fromIndex < 0) { + fromIndex = 0; + } + if (targetCount == 0) { + return fromIndex; + } + + char first = target[targetOffset]; + int max = sourceOffset + (sourceCount - targetCount); + + for (int i = sourceOffset + fromIndex; i <= max; i++) { + /* Look for first character. */ + if (source[i] != first) { + while (++i <= max && source[i] != first); + } + + /* Found first character, now look at the rest of v2 */ + if (i <= max) { + int j = i + 1; + int end = j + targetCount - 1; + for (int k = targetOffset + 1; j < end && source[j] == + target[k]; j++, k++); + + if (j == end) { + /* Found whole string. */ + return i - sourceOffset; + } + } + } + return -1; + } + + /** + * Returns the index within this string of the last occurrence of the + * specified substring. The last occurrence of the empty string "" + * is considered to occur at the index value {@code this.length()}. + * + *

The returned index is the largest value k for which: + * 

+     * this.startsWith(str, k)
+     *
+ * If no such value of k exists, then {@code -1} is returned. + * + * @param str the substring to search for. + * @return the index of the last occurrence of the specified substring, + * or {@code -1} if there is no such occurrence. + */ + public int lastIndexOf(String str) { + return lastIndexOf(str, count); + } + + /** + * Returns the index within this string of the last occurrence of the + * specified substring, searching backward starting at the specified index. + * + *

The returned index is the largest value k for which: + * 

+     * k <= fromIndex && this.startsWith(str, k)
+     *
+ * If no such value of k exists, then {@code -1} is returned. + * + * @param str the substring to search for. + * @param fromIndex the index to start the search from. + * @return the index of the last occurrence of the specified substring, + * searching backward from the specified index, + * or {@code -1} if there is no such occurrence. + */ + public int lastIndexOf(String str, int fromIndex) { + return lastIndexOf(value, offset, count, + str.value, str.offset, str.count, fromIndex); + } + + /** + * Code shared by String and StringBuffer to do searches. The + * source is the character array being searched, and the target + * is the string being searched for. + * + * @param source the characters being searched. + * @param sourceOffset offset of the source string. + * @param sourceCount count of the source string. + * @param target the characters being searched for. + * @param targetOffset offset of the target string. + * @param targetCount count of the target string. + * @param fromIndex the index to begin searching from. + */ + static int lastIndexOf(char[] source, int sourceOffset, int sourceCount, + char[] target, int targetOffset, int targetCount, + int fromIndex) { + /* + * Check arguments; return immediately where possible. For + * consistency, don't check for null str. + */ + int rightIndex = sourceCount - targetCount; + if (fromIndex < 0) { + return -1; + } + if (fromIndex > rightIndex) { + fromIndex = rightIndex; + } + /* Empty string always matches. */ + if (targetCount == 0) { + return fromIndex; + } + + int strLastIndex = targetOffset + targetCount - 1; + char strLastChar = target[strLastIndex]; + int min = sourceOffset + targetCount - 1; + int i = min + fromIndex; + + startSearchForLastChar: + while (true) { + while (i >= min && source[i] != strLastChar) { + i--; + } + if (i < min) { + return -1; + } + int j = i - 1; + int start = j - (targetCount - 1); + int k = strLastIndex - 1; + + while (j > start) { + if (source[j--] != target[k--]) { + i--; + continue startSearchForLastChar; + } + } + return start - sourceOffset + 1; + } + } + + /** + * Returns a new string that is a substring of this string. The + * substring begins with the character at the specified index and + * extends to the end of this string.

+ * Examples: + * 

+     * "unhappy".substring(2) returns "happy"
+     * "Harbison".substring(3) returns "bison"
+     * "emptiness".substring(9) returns "" (an empty string)
+     *
+ * + * @param beginIndex the beginning index, inclusive. + * @return the specified substring. + * @exception IndexOutOfBoundsException if + * beginIndex is negative or larger than the + * length of this String object. + */ + public String substring(int beginIndex) { + return substring(beginIndex, count); + } + + /** + * Returns a new string that is a substring of this string. The + * substring begins at the specified beginIndex and + * extends to the character at index endIndex - 1. + * Thus the length of the substring is endIndex-beginIndex. + *

+ * Examples: + * 

+     * "hamburger".substring(4, 8) returns "urge"
+     * "smiles".substring(1, 5) returns "mile"
+     *
+ * + * @param beginIndex the beginning index, inclusive. + * @param endIndex the ending index, exclusive. + * @return the specified substring. + * @exception IndexOutOfBoundsException if the + * beginIndex is negative, or + * endIndex is larger than the length of + * this String object, or + * beginIndex is larger than + * endIndex. + */ + public String substring(int beginIndex, int endIndex) { + if (beginIndex < 0) { + throw new StringIndexOutOfBoundsException(beginIndex); + } + if (endIndex > count) { + throw new StringIndexOutOfBoundsException(endIndex); + } + if (beginIndex > endIndex) { + throw new StringIndexOutOfBoundsException(endIndex - beginIndex); + } + return ((beginIndex == 0) && (endIndex == count)) ? this : + new String(offset + beginIndex, endIndex - beginIndex, value); + } + + /** + * Returns a new character sequence that is a subsequence of this sequence. + * + *

An invocation of this method of the form + * + * 

+     * str.subSequence(begin, end)
+ * + * behaves in exactly the same way as the invocation + * + * 
+     * str.substring(begin, end)
+ * + * This method is defined so that the String class can implement + * the {@link CharSequence} interface.

+ * + * @param beginIndex the begin index, inclusive. + * @param endIndex the end index, exclusive. + * @return the specified subsequence. + * + * @throws IndexOutOfBoundsException + * if beginIndex or endIndex are negative, + * if endIndex is greater than length(), + * or if beginIndex is greater than startIndex + * + * @since 1.4 + * @spec JSR-51 + */ + public CharSequence subSequence(int beginIndex, int endIndex) { + return this.substring(beginIndex, endIndex); + } + + /** + * Concatenates the specified string to the end of this string. + *

+ * If the length of the argument string is 0, then this + * String object is returned. Otherwise, a new + * String object is created, representing a character + * sequence that is the concatenation of the character sequence + * represented by this String object and the character + * sequence represented by the argument string.

+ * Examples: + * 

+     * "cares".concat("s") returns "caress"
+     * "to".concat("get").concat("her") returns "together"
+     *
+ * + * @param str the String that is concatenated to the end + * of this String. + * @return a string that represents the concatenation of this object's + * characters followed by the string argument's characters. + */ + public String concat(String str) { + int otherLen = str.length(); + if (otherLen == 0) { + return this; + } + char buf[] = new char[count + otherLen]; + getChars(0, count, buf, 0); + str.getChars(0, otherLen, buf, count); + return new String(0, count + otherLen, buf); + } + + /** + * Returns a new string resulting from replacing all occurrences of + * oldChar in this string with newChar. + *

+ * If the character oldChar does not occur in the + * character sequence represented by this String object, + * then a reference to this String object is returned. + * Otherwise, a new String object is created that + * represents a character sequence identical to the character sequence + * represented by this String object, except that every + * occurrence of oldChar is replaced by an occurrence + * of newChar. + *

+ * Examples: + * 

+     * "mesquite in your cellar".replace('e', 'o')
+     *         returns "mosquito in your collar"
+     * "the war of baronets".replace('r', 'y')
+     *         returns "the way of bayonets"
+     * "sparring with a purple porpoise".replace('p', 't')
+     *         returns "starring with a turtle tortoise"
+     * "JonL".replace('q', 'x') returns "JonL" (no change)
+     *
+ * + * @param oldChar the old character. + * @param newChar the new character. + * @return a string derived from this string by replacing every + * occurrence of oldChar with newChar. + */ + public String replace(char oldChar, char newChar) { + if (oldChar != newChar) { + int len = count; + int i = -1; + char[] val = value; /* avoid getfield opcode */ + int off = offset; /* avoid getfield opcode */ + + while (++i < len) { + if (val[off + i] == oldChar) { + break; + } + } + if (i < len) { + char buf[] = new char[len]; + for (int j = 0 ; j < i ; j++) { + buf[j] = val[off+j]; + } + while (i < len) { + char c = val[off + i]; + buf[i] = (c == oldChar) ? newChar : c; + i++; + } + return new String(0, len, buf); + } + } + return this; + } + + /** + * Tells whether or not this string matches the given regular expression. + * + *

An invocation of this method of the form + * str.matches(regex) yields exactly the + * same result as the expression + * + *

{@link java.util.regex.Pattern}.{@link + * java.util.regex.Pattern#matches(String,CharSequence) + * matches}(regex, str)
+ * + * @param regex + * the regular expression to which this string is to be matched + * + * @return true if, and only if, this string matches the + * given regular expression + * + * @throws PatternSyntaxException + * if the regular expression's syntax is invalid + * + * @see java.util.regex.Pattern + * + * @since 1.4 + * @spec JSR-51 + */ + public boolean matches(String regex) { + return Pattern.matches(regex, this); + } + + /** + * Returns true if and only if this string contains the specified + * sequence of char values. + * + * @param s the sequence to search for + * @return true if this string contains s, false otherwise + * @throws NullPointerException if s is null + * @since 1.5 + */ + public boolean contains(CharSequence s) { + return indexOf(s.toString()) > -1; + } + + /** + * Replaces the first substring of this string that matches the given regular expression with the + * given replacement. + * + *

An invocation of this method of the form + * str.replaceFirst(regex, repl) + * yields exactly the same result as the expression + * + *

+ * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile + * compile}(regex).{@link + * java.util.regex.Pattern#matcher(java.lang.CharSequence) + * matcher}(str).{@link java.util.regex.Matcher#replaceFirst + * replaceFirst}(repl)
+ * + *

+ * Note that backslashes (\) and dollar signs ($) in the + * replacement string may cause the results to be different than if it were + * being treated as a literal replacement string; see + * {@link java.util.regex.Matcher#replaceFirst}. + * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special + * meaning of these characters, if desired. + * + * @param regex + * the regular expression to which this string is to be matched + * @param replacement + * the string to be substituted for the first match + * + * @return The resulting String + * + * @throws PatternSyntaxException + * if the regular expression's syntax is invalid + * + * @see java.util.regex.Pattern + * + * @since 1.4 + * @spec JSR-51 + */ + public String replaceFirst(String regex, String replacement) { + return Pattern.compile(regex).matcher(this).replaceFirst(replacement); + } + + /** + * Replaces each substring of this string that matches the given regular expression with the + * given replacement. + * + *

An invocation of this method of the form + * str.replaceAll(regex, repl) + * yields exactly the same result as the expression + * + *

+ * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile + * compile}(regex).{@link + * java.util.regex.Pattern#matcher(java.lang.CharSequence) + * matcher}(str).{@link java.util.regex.Matcher#replaceAll + * replaceAll}(repl)
+ * + *

+ * Note that backslashes (\) and dollar signs ($) in the + * replacement string may cause the results to be different than if it were + * being treated as a literal replacement string; see + * {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}. + * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special + * meaning of these characters, if desired. + * + * @param regex + * the regular expression to which this string is to be matched + * @param replacement + * the string to be substituted for each match + * + * @return The resulting String + * + * @throws PatternSyntaxException + * if the regular expression's syntax is invalid + * + * @see java.util.regex.Pattern + * + * @since 1.4 + * @spec JSR-51 + */ + public String replaceAll(String regex, String replacement) { + return Pattern.compile(regex).matcher(this).replaceAll(replacement); + } + + /** + * Replaces each substring of this string that matches the literal target + * sequence with the specified literal replacement sequence. The + * replacement proceeds from the beginning of the string to the end, for + * example, replacing "aa" with "b" in the string "aaa" will result in + * "ba" rather than "ab". + * + * @param target The sequence of char values to be replaced + * @param replacement The replacement sequence of char values + * @return The resulting string + * @throws NullPointerException if target or + * replacement is null. + * @since 1.5 + */ + public String replace(CharSequence target, CharSequence replacement) { + return Pattern.compile(target.toString(), Pattern.LITERAL).matcher( + this).replaceAll(Matcher.quoteReplacement(replacement.toString())); + } + + /** + * Splits this string around matches of the given + * regular expression. + * + *

The array returned by this method contains each substring of this + * string that is terminated by another substring that matches the given + * expression or is terminated by the end of the string. The substrings in + * the array are in the order in which they occur in this string. If the + * expression does not match any part of the input then the resulting array + * has just one element, namely this string. + * + *

The limit parameter controls the number of times the + * pattern is applied and therefore affects the length of the resulting + * array. If the limit n is greater than zero then the pattern + * will be applied at most n - 1 times, the array's + * length will be no greater than n, and the array's last entry + * will contain all input beyond the last matched delimiter. If n + * is non-positive then the pattern will be applied as many times as + * possible and the array can have any length. If n is zero then + * the pattern will be applied as many times as possible, the array can + * have any length, and trailing empty strings will be discarded. + * + *

The string "boo:and:foo", for example, yields the + * following results with these parameters: + * + *

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
RegexLimitResult
:2{ "boo", "and:foo" }
:5{ "boo", "and", "foo" }
:-2{ "boo", "and", "foo" }
o5{ "b", "", ":and:f", "", "" }
o-2{ "b", "", ":and:f", "", "" }
o0{ "b", "", ":and:f" }
+ * + *

An invocation of this method of the form + * str.split(regex, n) + * yields the same result as the expression + * + *

+ * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile + * compile}(regex).{@link + * java.util.regex.Pattern#split(java.lang.CharSequence,int) + * split}(str, n) + *
+ * + * + * @param regex + * the delimiting regular expression + * + * @param limit + * the result threshold, as described above + * + * @return the array of strings computed by splitting this string + * around matches of the given regular expression + * + * @throws PatternSyntaxException + * if the regular expression's syntax is invalid + * + * @see java.util.regex.Pattern + * + * @since 1.4 + * @spec JSR-51 + */ + public String[] split(String regex, int limit) { + /* fastpath if the regex is a + (1)one-char String and this character is not one of the + RegEx's meta characters ".$|()[{^?*+\\", or + (2)two-char String and the first char is the backslash and + the second is not the ascii digit or ascii letter. + */ + char ch = 0; + if (((regex.count == 1 && + ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) || + (regex.length() == 2 && + regex.charAt(0) == '\\' && + (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 && + ((ch-'a')|('z'-ch)) < 0 && + ((ch-'A')|('Z'-ch)) < 0)) && + (ch < Character.MIN_HIGH_SURROGATE || + ch > Character.MAX_LOW_SURROGATE)) + { + int off = 0; + int next = 0; + boolean limited = limit > 0; + ArrayList list = new ArrayList<>(); + while ((next = indexOf(ch, off)) != -1) { + if (!limited || list.size() < limit - 1) { + list.add(substring(off, next)); + off = next + 1; + } else { // last one + //assert (list.size() == limit - 1); + list.add(substring(off, count)); + off = count; + break; + } + } + // If no match was found, return this + if (off == 0) + return new String[] { this }; + + // Add remaining segment + if (!limited || list.size() < limit) + list.add(substring(off, count)); + + // Construct result + int resultSize = list.size(); + if (limit == 0) + while (resultSize > 0 && list.get(resultSize-1).length() == 0) + resultSize--; + String[] result = new String[resultSize]; + return list.subList(0, resultSize).toArray(result); + } + return Pattern.compile(regex).split(this, limit); + } + + /** + * Splits this string around matches of the given regular expression. + * + *

This method works as if by invoking the two-argument {@link + * #split(String, int) split} method with the given expression and a limit + * argument of zero. Trailing empty strings are therefore not included in + * the resulting array. + * + *

The string "boo:and:foo", for example, yields the following + * results with these expressions: + * + *

+ * + * + * + * + * + * + * + * + *
RegexResult
:{ "boo", "and", "foo" }
o{ "b", "", ":and:f" }
+ * + * + * @param regex + * the delimiting regular expression + * + * @return the array of strings computed by splitting this string + * around matches of the given regular expression + * + * @throws PatternSyntaxException + * if the regular expression's syntax is invalid + * + * @see java.util.regex.Pattern + * + * @since 1.4 + * @spec JSR-51 + */ + public String[] split(String regex) { + return split(regex, 0); + } + + /** + * Converts all of the characters in this String to lower + * case using the rules of the given Locale. Case mapping is based + * on the Unicode Standard version specified by the {@link java.lang.Character Character} + * class. Since case mappings are not always 1:1 char mappings, the resulting + * String may be a different length than the original String. + *

+ * Examples of lowercase mappings are in the following table: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Language Code of LocaleUpper CaseLower CaseDescription
tr (Turkish)\u0130\u0069capital letter I with dot above -> small letter i
tr (Turkish)\u0049\u0131capital letter I -> small letter dotless i
(all)French Friesfrench frieslowercased all chars in String
(all)capiotacapchi + * capthetacapupsil + * capsigmaiotachi + * thetaupsilon + * sigmalowercased all chars in String
+ * + * @param locale use the case transformation rules for this locale + * @return the String, converted to lowercase. + * @see java.lang.String#toLowerCase() + * @see java.lang.String#toUpperCase() + * @see java.lang.String#toUpperCase(Locale) + * @since 1.1 + */ + public String toLowerCase(Locale locale) { + if (locale == null) { + throw new NullPointerException(); + } + + int firstUpper; + + /* Now check if there are any characters that need to be changed. */ + scan: { + for (firstUpper = 0 ; firstUpper < count; ) { + char c = value[offset+firstUpper]; + if ((c >= Character.MIN_HIGH_SURROGATE) && + (c <= Character.MAX_HIGH_SURROGATE)) { + int supplChar = codePointAt(firstUpper); + if (supplChar != Character.toLowerCase(supplChar)) { + break scan; + } + firstUpper += Character.charCount(supplChar); + } else { + if (c != Character.toLowerCase(c)) { + break scan; + } + firstUpper++; + } + } + return this; + } + + char[] result = new char[count]; + int resultOffset = 0; /* result may grow, so i+resultOffset + * is the write location in result */ + + /* Just copy the first few lowerCase characters. */ + System.arraycopy(value, offset, result, 0, firstUpper); + + String lang = locale.getLanguage(); + boolean localeDependent = + (lang == "tr" || lang == "az" || lang == "lt"); + char[] lowerCharArray; + int lowerChar; + int srcChar; + int srcCount; + for (int i = firstUpper; i < count; i += srcCount) { + srcChar = (int)value[offset+i]; + if ((char)srcChar >= Character.MIN_HIGH_SURROGATE && + (char)srcChar <= Character.MAX_HIGH_SURROGATE) { + srcChar = codePointAt(i); + srcCount = Character.charCount(srcChar); + } else { + srcCount = 1; + } + if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMA + lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale); + } else if (srcChar == '\u0130') { // LATIN CAPITAL LETTER I DOT + lowerChar = Character.ERROR; + } else { + lowerChar = Character.toLowerCase(srcChar); + } + if ((lowerChar == Character.ERROR) || + (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) { + if (lowerChar == Character.ERROR) { + if (!localeDependent && srcChar == '\u0130') { + lowerCharArray = + ConditionalSpecialCasing.toLowerCaseCharArray(this, i, Locale.ENGLISH); + } else { + lowerCharArray = + ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale); + } + } else if (srcCount == 2) { + resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount; + continue; + } else { + lowerCharArray = Character.toChars(lowerChar); + } + + /* Grow result if needed */ + int mapLen = lowerCharArray.length; + if (mapLen > srcCount) { + char[] result2 = new char[result.length + mapLen - srcCount]; + System.arraycopy(result, 0, result2, 0, + i + resultOffset); + result = result2; + } + for (int x=0; xString to lower + * case using the rules of the default locale. This is equivalent to calling + * toLowerCase(Locale.getDefault()). + *

+ * Note: This method is locale sensitive, and may produce unexpected + * results if used for strings that are intended to be interpreted locale + * independently. + * Examples are programming language identifiers, protocol keys, and HTML + * tags. + * For instance, "TITLE".toLowerCase() in a Turkish locale + * returns "t\u005Cu0131tle", where '\u005Cu0131' is the + * LATIN SMALL LETTER DOTLESS I character. + * To obtain correct results for locale insensitive strings, use + * toLowerCase(Locale.ENGLISH). + *

+ * @return the String, converted to lowercase. + * @see java.lang.String#toLowerCase(Locale) + */ + public String toLowerCase() { + return toLowerCase(Locale.getDefault()); + } + + /** + * Converts all of the characters in this String to upper + * case using the rules of the given Locale. Case mapping is based + * on the Unicode Standard version specified by the {@link java.lang.Character Character} + * class. Since case mappings are not always 1:1 char mappings, the resulting + * String may be a different length than the original String. + *

+ * Examples of locale-sensitive and 1:M case mappings are in the following table. + *

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Language Code of LocaleLower CaseUpper CaseDescription
tr (Turkish)\u0069\u0130small letter i -> capital letter I with dot above
tr (Turkish)\u0131\u0049small letter dotless i -> capital letter I
(all)\u00df\u0053 \u0053small letter sharp s -> two letters: SS
(all)FahrvergnügenFAHRVERGNÜGEN
+ * @param locale use the case transformation rules for this locale + * @return the String, converted to uppercase. + * @see java.lang.String#toUpperCase() + * @see java.lang.String#toLowerCase() + * @see java.lang.String#toLowerCase(Locale) + * @since 1.1 + */ + public String toUpperCase(Locale locale) { + if (locale == null) { + throw new NullPointerException(); + } + + int firstLower; + + /* Now check if there are any characters that need to be changed. */ + scan: { + for (firstLower = 0 ; firstLower < count; ) { + int c = (int)value[offset+firstLower]; + int srcCount; + if ((c >= Character.MIN_HIGH_SURROGATE) && + (c <= Character.MAX_HIGH_SURROGATE)) { + c = codePointAt(firstLower); + srcCount = Character.charCount(c); + } else { + srcCount = 1; + } + int upperCaseChar = Character.toUpperCaseEx(c); + if ((upperCaseChar == Character.ERROR) || + (c != upperCaseChar)) { + break scan; + } + firstLower += srcCount; + } + return this; + } + + char[] result = new char[count]; /* may grow */ + int resultOffset = 0; /* result may grow, so i+resultOffset + * is the write location in result */ + + /* Just copy the first few upperCase characters. */ + System.arraycopy(value, offset, result, 0, firstLower); + + String lang = locale.getLanguage(); + boolean localeDependent = + (lang == "tr" || lang == "az" || lang == "lt"); + char[] upperCharArray; + int upperChar; + int srcChar; + int srcCount; + for (int i = firstLower; i < count; i += srcCount) { + srcChar = (int)value[offset+i]; + if ((char)srcChar >= Character.MIN_HIGH_SURROGATE && + (char)srcChar <= Character.MAX_HIGH_SURROGATE) { + srcChar = codePointAt(i); + srcCount = Character.charCount(srcChar); + } else { + srcCount = 1; + } + if (localeDependent) { + upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale); + } else { + upperChar = Character.toUpperCaseEx(srcChar); + } + if ((upperChar == Character.ERROR) || + (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) { + if (upperChar == Character.ERROR) { + if (localeDependent) { + upperCharArray = + ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale); + } else { + upperCharArray = Character.toUpperCaseCharArray(srcChar); + } + } else if (srcCount == 2) { + resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount; + continue; + } else { + upperCharArray = Character.toChars(upperChar); + } + + /* Grow result if needed */ + int mapLen = upperCharArray.length; + if (mapLen > srcCount) { + char[] result2 = new char[result.length + mapLen - srcCount]; + System.arraycopy(result, 0, result2, 0, + i + resultOffset); + result = result2; + } + for (int x=0; xString to upper + * case using the rules of the default locale. This method is equivalent to + * toUpperCase(Locale.getDefault()). + *

+ * Note: This method is locale sensitive, and may produce unexpected + * results if used for strings that are intended to be interpreted locale + * independently. + * Examples are programming language identifiers, protocol keys, and HTML + * tags. + * For instance, "title".toUpperCase() in a Turkish locale + * returns "T\u005Cu0130TLE", where '\u005Cu0130' is the + * LATIN CAPITAL LETTER I WITH DOT ABOVE character. + * To obtain correct results for locale insensitive strings, use + * toUpperCase(Locale.ENGLISH). + *

+ * @return the String, converted to uppercase. + * @see java.lang.String#toUpperCase(Locale) + */ + public String toUpperCase() { + return toUpperCase(Locale.getDefault()); + } + + /** + * Returns a copy of the string, with leading and trailing whitespace + * omitted. + *

+ * If this String object represents an empty character + * sequence, or the first and last characters of character sequence + * represented by this String object both have codes + * greater than '\u0020' (the space character), then a + * reference to this String object is returned. + *

+ * Otherwise, if there is no character with a code greater than + * '\u0020' in the string, then a new + * String object representing an empty string is created + * and returned. + *

+ * Otherwise, let k be the index of the first character in the + * string whose code is greater than '\u0020', and let + * m be the index of the last character in the string whose code + * is greater than '\u0020'. A new String + * object is created, representing the substring of this string that + * begins with the character at index k and ends with the + * character at index m-that is, the result of + * this.substring(k, m+1). + *

+ * This method may be used to trim whitespace (as defined above) from + * the beginning and end of a string. + * + * @return A copy of this string with leading and trailing white + * space removed, or this string if it has no leading or + * trailing white space. + */ + public String trim() { + int len = count; + int st = 0; + int off = offset; /* avoid getfield opcode */ + char[] val = value; /* avoid getfield opcode */ + + while ((st < len) && (val[off + st] <= ' ')) { + st++; + } + while ((st < len) && (val[off + len - 1] <= ' ')) { + len--; + } + return ((st > 0) || (len < count)) ? substring(st, len) : this; + } + + /** + * This object (which is already a string!) is itself returned. + * + * @return the string itself. + */ + public String toString() { + return this; + } + + /** + * Converts this string to a new character array. + * + * @return a newly allocated character array whose length is the length + * of this string and whose contents are initialized to contain + * the character sequence represented by this string. + */ + public char[] toCharArray() { + char result[] = new char[count]; + getChars(0, count, result, 0); + return result; + } + + /** + * Returns a formatted string using the specified format string and + * arguments. + * + *

The locale always used is the one returned by {@link + * java.util.Locale#getDefault() Locale.getDefault()}. + * + * @param format + * A format string + * + * @param args + * Arguments referenced by the format specifiers in the format + * string. If there are more arguments than format specifiers, the + * extra arguments are ignored. The number of arguments is + * variable and may be zero. The maximum number of arguments is + * limited by the maximum dimension of a Java array as defined by + * The Java™ Virtual Machine Specification. + * The behaviour on a + * null argument depends on the conversion. + * + * @throws IllegalFormatException + * If a format string contains an illegal syntax, a format + * specifier that is incompatible with the given arguments, + * insufficient arguments given the format string, or other + * illegal conditions. For specification of all possible + * formatting errors, see the Details section of the + * formatter class specification. + * + * @throws NullPointerException + * If the format is null + * + * @return A formatted string + * + * @see java.util.Formatter + * @since 1.5 + */ + public static String format(String format, Object ... args) { + return new Formatter().format(format, args).toString(); + } + + /** + * Returns a formatted string using the specified locale, format string, + * and arguments. + * + * @param l + * The {@linkplain java.util.Locale locale} to apply during + * formatting. If l is null then no localization + * is applied. + * + * @param format + * A format string + * + * @param args + * Arguments referenced by the format specifiers in the format + * string. If there are more arguments than format specifiers, the + * extra arguments are ignored. The number of arguments is + * variable and may be zero. The maximum number of arguments is + * limited by the maximum dimension of a Java array as defined by + * The Java™ Virtual Machine Specification. + * The behaviour on a + * null argument depends on the conversion. + * + * @throws IllegalFormatException + * If a format string contains an illegal syntax, a format + * specifier that is incompatible with the given arguments, + * insufficient arguments given the format string, or other + * illegal conditions. For specification of all possible + * formatting errors, see the Details section of the + * formatter class specification + * + * @throws NullPointerException + * If the format is null + * + * @return A formatted string + * + * @see java.util.Formatter + * @since 1.5 + */ + public static String format(Locale l, String format, Object ... args) { + return new Formatter(l).format(format, args).toString(); + } + + /** + * Returns the string representation of the Object argument. + * + * @param obj an Object. + * @return if the argument is null, then a string equal to + * "null"; otherwise, the value of + * obj.toString() is returned. + * @see java.lang.Object#toString() + */ + public static String valueOf(Object obj) { + return (obj == null) ? "null" : obj.toString(); + } + + /** + * Returns the string representation of the char array + * argument. The contents of the character array are copied; subsequent + * modification of the character array does not affect the newly + * created string. + * + * @param data a char array. + * @return a newly allocated string representing the same sequence of + * characters contained in the character array argument. + */ + public static String valueOf(char data[]) { + return new String(data); + } + + /** + * Returns the string representation of a specific subarray of the + * char array argument. + *

+ * The offset argument is the index of the first + * character of the subarray. The count argument + * specifies the length of the subarray. The contents of the subarray + * are copied; subsequent modification of the character array does not + * affect the newly created string. + * + * @param data the character array. + * @param offset the initial offset into the value of the + * String. + * @param count the length of the value of the String. + * @return a string representing the sequence of characters contained + * in the subarray of the character array argument. + * @exception IndexOutOfBoundsException if offset is + * negative, or count is negative, or + * offset+count is larger than + * data.length. + */ + public static String valueOf(char data[], int offset, int count) { + return new String(data, offset, count); + } + + /** + * Returns a String that represents the character sequence in the + * array specified. + * + * @param data the character array. + * @param offset initial offset of the subarray. + * @param count length of the subarray. + * @return a String that contains the characters of the + * specified subarray of the character array. + */ + public static String copyValueOf(char data[], int offset, int count) { + // All public String constructors now copy the data. + return new String(data, offset, count); + } + + /** + * Returns a String that represents the character sequence in the + * array specified. + * + * @param data the character array. + * @return a String that contains the characters of the + * character array. + */ + public static String copyValueOf(char data[]) { + return copyValueOf(data, 0, data.length); + } + + /** + * Returns the string representation of the boolean argument. + * + * @param b a boolean. + * @return if the argument is true, a string equal to + * "true" is returned; otherwise, a string equal to + * "false" is returned. + */ + public static String valueOf(boolean b) { + return b ? "true" : "false"; + } + + /** + * Returns the string representation of the char + * argument. + * + * @param c a char. + * @return a string of length 1 containing + * as its single character the argument c. + */ + public static String valueOf(char c) { + char data[] = {c}; + return new String(0, 1, data); + } + + /** + * Returns the string representation of the int argument. + *

+ * The representation is exactly the one returned by the + * Integer.toString method of one argument. + * + * @param i an int. + * @return a string representation of the int argument. + * @see java.lang.Integer#toString(int, int) + */ + public static String valueOf(int i) { + return Integer.toString(i); + } + + /** + * Returns the string representation of the long argument. + *

+ * The representation is exactly the one returned by the + * Long.toString method of one argument. + * + * @param l a long. + * @return a string representation of the long argument. + * @see java.lang.Long#toString(long) + */ + public static String valueOf(long l) { + return Long.toString(l); + } + + /** + * Returns the string representation of the float argument. + *

+ * The representation is exactly the one returned by the + * Float.toString method of one argument. + * + * @param f a float. + * @return a string representation of the float argument. + * @see java.lang.Float#toString(float) + */ + public static String valueOf(float f) { + return Float.toString(f); + } + + /** + * Returns the string representation of the double argument. + *

+ * The representation is exactly the one returned by the + * Double.toString method of one argument. + * + * @param d a double. + * @return a string representation of the double argument. + * @see java.lang.Double#toString(double) + */ + public static String valueOf(double d) { + return Double.toString(d); + } + + /** + * Returns a canonical representation for the string object. + *

+ * A pool of strings, initially empty, is maintained privately by the + * class String. + *

+ * When the intern method is invoked, if the pool already contains a + * string equal to this String object as determined by + * the {@link #equals(Object)} method, then the string from the pool is + * returned. Otherwise, this String object is added to the + * pool and a reference to this String object is returned. + *

+ * It follows that for any two strings s and t, + * s.intern() == t.intern() is true + * if and only if s.equals(t) is true. + *

+ * All literal strings and string-valued constant expressions are + * interned. String literals are defined in section 3.10.5 of the + * The Java™ Language Specification. + * + * @return a string that has the same contents as this string, but is + * guaranteed to be from a pool of unique strings. + */ + public native String intern(); + +} diff -r 4fca8ddf46de -r 0a115f1c6f3c emul/src/main/java/java/lang/Throwable.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emul/src/main/java/java/lang/Throwable.java Fri Sep 28 17:59:03 2012 +0200 @@ -0,0 +1,1080 @@ +/* + * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; +import java.io.*; +import java.util.*; + +/** + * The {@code Throwable} class is the superclass of all errors and + * exceptions in the Java language. Only objects that are instances of this + * class (or one of its subclasses) are thrown by the Java Virtual Machine or + * can be thrown by the Java {@code throw} statement. Similarly, only + * this class or one of its subclasses can be the argument type in a + * {@code catch} clause. + * + * For the purposes of compile-time checking of exceptions, {@code + * Throwable} and any subclass of {@code Throwable} that is not also a + * subclass of either {@link RuntimeException} or {@link Error} are + * regarded as checked exceptions. + * + *

Instances of two subclasses, {@link java.lang.Error} and + * {@link java.lang.Exception}, are conventionally used to indicate + * that exceptional situations have occurred. Typically, these instances + * are freshly created in the context of the exceptional situation so + * as to include relevant information (such as stack trace data). + * + *

A throwable contains a snapshot of the execution stack of its + * thread at the time it was created. It can also contain a message + * string that gives more information about the error. Over time, a + * throwable can {@linkplain Throwable#addSuppressed suppress} other + * throwables from being propagated. Finally, the throwable can also + * contain a cause: another throwable that caused this + * throwable to be constructed. The recording of this causal information + * is referred to as the chained exception facility, as the + * cause can, itself, have a cause, and so on, leading to a "chain" of + * exceptions, each caused by another. + * + *

One reason that a throwable may have a cause is that the class that + * throws it is built atop a lower layered abstraction, and an operation on + * the upper layer fails due to a failure in the lower layer. It would be bad + * design to let the throwable thrown by the lower layer propagate outward, as + * it is generally unrelated to the abstraction provided by the upper layer. + * Further, doing so would tie the API of the upper layer to the details of + * its implementation, assuming the lower layer's exception was a checked + * exception. Throwing a "wrapped exception" (i.e., an exception containing a + * cause) allows the upper layer to communicate the details of the failure to + * its caller without incurring either of these shortcomings. It preserves + * the flexibility to change the implementation of the upper layer without + * changing its API (in particular, the set of exceptions thrown by its + * methods). + * + *

A second reason that a throwable may have a cause is that the method + * that throws it must conform to a general-purpose interface that does not + * permit the method to throw the cause directly. For example, suppose + * a persistent collection conforms to the {@link java.util.Collection + * Collection} interface, and that its persistence is implemented atop + * {@code java.io}. Suppose the internals of the {@code add} method + * can throw an {@link java.io.IOException IOException}. The implementation + * can communicate the details of the {@code IOException} to its caller + * while conforming to the {@code Collection} interface by wrapping the + * {@code IOException} in an appropriate unchecked exception. (The + * specification for the persistent collection should indicate that it is + * capable of throwing such exceptions.) + * + *

A cause can be associated with a throwable in two ways: via a + * constructor that takes the cause as an argument, or via the + * {@link #initCause(Throwable)} method. New throwable classes that + * wish to allow causes to be associated with them should provide constructors + * that take a cause and delegate (perhaps indirectly) to one of the + * {@code Throwable} constructors that takes a cause. + * + * Because the {@code initCause} method is public, it allows a cause to be + * associated with any throwable, even a "legacy throwable" whose + * implementation predates the addition of the exception chaining mechanism to + * {@code Throwable}. + * + *

By convention, class {@code Throwable} and its subclasses have two + * constructors, one that takes no arguments and one that takes a + * {@code String} argument that can be used to produce a detail message. + * Further, those subclasses that might likely have a cause associated with + * them should have two more constructors, one that takes a + * {@code Throwable} (the cause), and one that takes a + * {@code String} (the detail message) and a {@code Throwable} (the + * cause). + * + * @author unascribed + * @author Josh Bloch (Added exception chaining and programmatic access to + * stack trace in 1.4.) + * @jls 11.2 Compile-Time Checking of Exceptions + * @since JDK1.0 + */ +public class Throwable implements Serializable { + /** use serialVersionUID from JDK 1.0.2 for interoperability */ + private static final long serialVersionUID = -3042686055658047285L; + + /** + * Native code saves some indication of the stack backtrace in this slot. + */ + private transient Object backtrace; + + /** + * Specific details about the Throwable. For example, for + * {@code FileNotFoundException}, this contains the name of + * the file that could not be found. + * + * @serial + */ + private String detailMessage; + + + /** + * Holder class to defer initializing sentinel objects only used + * for serialization. + */ + private static class SentinelHolder { + /** + * {@linkplain #setStackTrace(StackTraceElement[]) Setting the + * stack trace} to a one-element array containing this sentinel + * value indicates future attempts to set the stack trace will be + * ignored. The sentinal is equal to the result of calling:
+ * {@code new StackTraceElement("", "", null, Integer.MIN_VALUE)} + */ + public static final StackTraceElement STACK_TRACE_ELEMENT_SENTINEL = + new StackTraceElement("", "", null, Integer.MIN_VALUE); + + /** + * Sentinel value used in the serial form to indicate an immutable + * stack trace. + */ + public static final StackTraceElement[] STACK_TRACE_SENTINEL = + new StackTraceElement[] {STACK_TRACE_ELEMENT_SENTINEL}; + } + + /** + * A shared value for an empty stack. + */ + private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0]; + + /* + * To allow Throwable objects to be made immutable and safely + * reused by the JVM, such as OutOfMemoryErrors, fields of + * Throwable that are writable in response to user actions, cause, + * stackTrace, and suppressedExceptions obey the following + * protocol: + * + * 1) The fields are initialized to a non-null sentinel value + * which indicates the value has logically not been set. + * + * 2) Writing a null to the field indicates further writes + * are forbidden + * + * 3) The sentinel value may be replaced with another non-null + * value. + * + * For example, implementations of the HotSpot JVM have + * preallocated OutOfMemoryError objects to provide for better + * diagnosability of that situation. These objects are created + * without calling the constructor for that class and the fields + * in question are initialized to null. To support this + * capability, any new fields added to Throwable that require + * being initialized to a non-null value require a coordinated JVM + * change. + */ + + /** + * The throwable that caused this throwable to get thrown, or null if this + * throwable was not caused by another throwable, or if the causative + * throwable is unknown. If this field is equal to this throwable itself, + * it indicates that the cause of this throwable has not yet been + * initialized. + * + * @serial + * @since 1.4 + */ + private Throwable cause = this; + + /** + * The stack trace, as returned by {@link #getStackTrace()}. + * + * The field is initialized to a zero-length array. A {@code + * null} value of this field indicates subsequent calls to {@link + * #setStackTrace(StackTraceElement[])} and {@link + * #fillInStackTrace()} will be be no-ops. + * + * @serial + * @since 1.4 + */ + private StackTraceElement[] stackTrace = UNASSIGNED_STACK; + + // Setting this static field introduces an acceptable + // initialization dependency on a few java.util classes. + private static final List SUPPRESSED_SENTINEL = + Collections.unmodifiableList(new ArrayList(0)); + + /** + * The list of suppressed exceptions, as returned by {@link + * #getSuppressed()}. The list is initialized to a zero-element + * unmodifiable sentinel list. When a serialized Throwable is + * read in, if the {@code suppressedExceptions} field points to a + * zero-element list, the field is reset to the sentinel value. + * + * @serial + * @since 1.7 + */ + private List suppressedExceptions = SUPPRESSED_SENTINEL; + + /** Message for trying to suppress a null exception. */ + private static final String NULL_CAUSE_MESSAGE = "Cannot suppress a null exception."; + + /** Message for trying to suppress oneself. */ + private static final String SELF_SUPPRESSION_MESSAGE = "Self-suppression not permitted"; + + /** Caption for labeling causative exception stack traces */ + private static final String CAUSE_CAPTION = "Caused by: "; + + /** Caption for labeling suppressed exception stack traces */ + private static final String SUPPRESSED_CAPTION = "Suppressed: "; + + /** + * Constructs a new throwable with {@code null} as its detail message. + * The cause is not initialized, and may subsequently be initialized by a + * call to {@link #initCause}. + * + *

The {@link #fillInStackTrace()} method is called to initialize + * the stack trace data in the newly created throwable. + */ + public Throwable() { + fillInStackTrace(); + } + + /** + * Constructs a new throwable with the specified detail message. The + * cause is not initialized, and may subsequently be initialized by + * a call to {@link #initCause}. + * + *

The {@link #fillInStackTrace()} method is called to initialize + * the stack trace data in the newly created throwable. + * + * @param message the detail message. The detail message is saved for + * later retrieval by the {@link #getMessage()} method. + */ + public Throwable(String message) { + fillInStackTrace(); + detailMessage = message; + } + + /** + * Constructs a new throwable with the specified detail message and + * cause.

Note that the detail message associated with + * {@code cause} is not automatically incorporated in + * this throwable's detail message. + * + *

The {@link #fillInStackTrace()} method is called to initialize + * the stack trace data in the newly created throwable. + * + * @param message the detail message (which is saved for later retrieval + * by the {@link #getMessage()} method). + * @param cause the cause (which is saved for later retrieval by the + * {@link #getCause()} method). (A {@code null} value is + * permitted, and indicates that the cause is nonexistent or + * unknown.) + * @since 1.4 + */ + public Throwable(String message, Throwable cause) { + fillInStackTrace(); + detailMessage = message; + this.cause = cause; + } + + /** + * Constructs a new throwable with the specified cause and a detail + * message of {@code (cause==null ? null : cause.toString())} (which + * typically contains the class and detail message of {@code cause}). + * This constructor is useful for throwables that are little more than + * wrappers for other throwables (for example, {@link + * java.security.PrivilegedActionException}). + * + *

The {@link #fillInStackTrace()} method is called to initialize + * the stack trace data in the newly created throwable. + * + * @param cause the cause (which is saved for later retrieval by the + * {@link #getCause()} method). (A {@code null} value is + * permitted, and indicates that the cause is nonexistent or + * unknown.) + * @since 1.4 + */ + public Throwable(Throwable cause) { + fillInStackTrace(); + detailMessage = (cause==null ? null : cause.toString()); + this.cause = cause; + } + + /** + * Constructs a new throwable with the specified detail message, + * cause, {@linkplain #addSuppressed suppression} enabled or + * disabled, and writable stack trace enabled or disabled. If + * suppression is disabled, {@link #getSuppressed} for this object + * will return a zero-length array and calls to {@link + * #addSuppressed} that would otherwise append an exception to the + * suppressed list will have no effect. If the writable stack + * trace is false, this constructor will not call {@link + * #fillInStackTrace()}, a {@code null} will be written to the + * {@code stackTrace} field, and subsequent calls to {@code + * fillInStackTrace} and {@link + * #setStackTrace(StackTraceElement[])} will not set the stack + * trace. If the writable stack trace is false, {@link + * #getStackTrace} will return a zero length array. + * + *

Note that the other constructors of {@code Throwable} treat + * suppression as being enabled and the stack trace as being + * writable. Subclasses of {@code Throwable} should document any + * conditions under which suppression is disabled and document + * conditions under which the stack trace is not writable. + * Disabling of suppression should only occur in exceptional + * circumstances where special requirements exist, such as a + * virtual machine reusing exception objects under low-memory + * situations. Circumstances where a given exception object is + * repeatedly caught and rethrown, such as to implement control + * flow between two sub-systems, is another situation where + * immutable throwable objects would be appropriate. + * + * @param message the detail message. + * @param cause the cause. (A {@code null} value is permitted, + * and indicates that the cause is nonexistent or unknown.) + * @param enableSuppression whether or not suppression is enabled or disabled + * @param writableStackTrace whether or not the stack trace should be + * writable + * + * @see OutOfMemoryError + * @see NullPointerException + * @see ArithmeticException + * @since 1.7 + */ + protected Throwable(String message, Throwable cause, + boolean enableSuppression, + boolean writableStackTrace) { + if (writableStackTrace) { + fillInStackTrace(); + } else { + stackTrace = null; + } + detailMessage = message; + this.cause = cause; + if (!enableSuppression) + suppressedExceptions = null; + } + + /** + * Returns the detail message string of this throwable. + * + * @return the detail message string of this {@code Throwable} instance + * (which may be {@code null}). + */ + public String getMessage() { + return detailMessage; + } + + /** + * Creates a localized description of this throwable. + * Subclasses may override this method in order to produce a + * locale-specific message. For subclasses that do not override this + * method, the default implementation returns the same result as + * {@code getMessage()}. + * + * @return The localized description of this throwable. + * @since JDK1.1 + */ + public String getLocalizedMessage() { + return getMessage(); + } + + /** + * Returns the cause of this throwable or {@code null} if the + * cause is nonexistent or unknown. (The cause is the throwable that + * caused this throwable to get thrown.) + * + *

This implementation returns the cause that was supplied via one of + * the constructors requiring a {@code Throwable}, or that was set after + * creation with the {@link #initCause(Throwable)} method. While it is + * typically unnecessary to override this method, a subclass can override + * it to return a cause set by some other means. This is appropriate for + * a "legacy chained throwable" that predates the addition of chained + * exceptions to {@code Throwable}. Note that it is not + * necessary to override any of the {@code PrintStackTrace} methods, + * all of which invoke the {@code getCause} method to determine the + * cause of a throwable. + * + * @return the cause of this throwable or {@code null} if the + * cause is nonexistent or unknown. + * @since 1.4 + */ + public synchronized Throwable getCause() { + return (cause==this ? null : cause); + } + + /** + * Initializes the cause of this throwable to the specified value. + * (The cause is the throwable that caused this throwable to get thrown.) + * + *

This method can be called at most once. It is generally called from + * within the constructor, or immediately after creating the + * throwable. If this throwable was created + * with {@link #Throwable(Throwable)} or + * {@link #Throwable(String,Throwable)}, this method cannot be called + * even once. + * + *

An example of using this method on a legacy throwable type + * without other support for setting the cause is: + * + * 

+     * try {
+     *     lowLevelOp();
+     * } catch (LowLevelException le) {
+     *     throw (HighLevelException)
+     *           new HighLevelException().initCause(le); // Legacy constructor
+     * }
+     *
+ * + * @param cause the cause (which is saved for later retrieval by the + * {@link #getCause()} method). (A {@code null} value is + * permitted, and indicates that the cause is nonexistent or + * unknown.) + * @return a reference to this {@code Throwable} instance. + * @throws IllegalArgumentException if {@code cause} is this + * throwable. (A throwable cannot be its own cause.) + * @throws IllegalStateException if this throwable was + * created with {@link #Throwable(Throwable)} or + * {@link #Throwable(String,Throwable)}, or this method has already + * been called on this throwable. + * @since 1.4 + */ + public synchronized Throwable initCause(Throwable cause) { + if (this.cause != this) + throw new IllegalStateException("Can't overwrite cause"); + if (cause == this) + throw new IllegalArgumentException("Self-causation not permitted"); + this.cause = cause; + return this; + } + + /** + * Returns a short description of this throwable. + * The result is the concatenation of: + *
    + *
  • the {@linkplain Class#getName() name} of the class of this object + *
  • ": " (a colon and a space) + *
  • the result of invoking this object's {@link #getLocalizedMessage} + * method + *
+ * If {@code getLocalizedMessage} returns {@code null}, then just + * the class name is returned. + * + * @return a string representation of this throwable. + */ + public String toString() { + String s = getClass().getName(); + String message = getLocalizedMessage(); + return (message != null) ? (s + ": " + message) : s; + } + + /** + * Prints this throwable and its backtrace to the + * standard error stream. This method prints a stack trace for this + * {@code Throwable} object on the error output stream that is + * the value of the field {@code System.err}. The first line of + * output contains the result of the {@link #toString()} method for + * this object. Remaining lines represent data previously recorded by + * the method {@link #fillInStackTrace()}. The format of this + * information depends on the implementation, but the following + * example may be regarded as typical: + * 
+     * java.lang.NullPointerException
+     *         at MyClass.mash(MyClass.java:9)
+     *         at MyClass.crunch(MyClass.java:6)
+     *         at MyClass.main(MyClass.java:3)
+     *
+ * This example was produced by running the program: + * 
+     * class MyClass {
+     *     public static void main(String[] args) {
+     *         crunch(null);
+     *     }
+     *     static void crunch(int[] a) {
+     *         mash(a);
+     *     }
+     *     static void mash(int[] b) {
+     *         System.out.println(b[0]);
+     *     }
+     * }
+     *
+ * The backtrace for a throwable with an initialized, non-null cause + * should generally include the backtrace for the cause. The format + * of this information depends on the implementation, but the following + * example may be regarded as typical: + * 
+     * HighLevelException: MidLevelException: LowLevelException
+     *         at Junk.a(Junk.java:13)
+     *         at Junk.main(Junk.java:4)
+     * Caused by: MidLevelException: LowLevelException
+     *         at Junk.c(Junk.java:23)
+     *         at Junk.b(Junk.java:17)
+     *         at Junk.a(Junk.java:11)
+     *         ... 1 more
+     * Caused by: LowLevelException
+     *         at Junk.e(Junk.java:30)
+     *         at Junk.d(Junk.java:27)
+     *         at Junk.c(Junk.java:21)
+     *         ... 3 more
+     *
+ * Note the presence of lines containing the characters {@code "..."}. + * These lines indicate that the remainder of the stack trace for this + * exception matches the indicated number of frames from the bottom of the + * stack trace of the exception that was caused by this exception (the + * "enclosing" exception). This shorthand can greatly reduce the length + * of the output in the common case where a wrapped exception is thrown + * from same method as the "causative exception" is caught. The above + * example was produced by running the program: + * 
+     * public class Junk {
+     *     public static void main(String args[]) {
+     *         try {
+     *             a();
+     *         } catch(HighLevelException e) {
+     *             e.printStackTrace();
+     *         }
+     *     }
+     *     static void a() throws HighLevelException {
+     *         try {
+     *             b();
+     *         } catch(MidLevelException e) {
+     *             throw new HighLevelException(e);
+     *         }
+     *     }
+     *     static void b() throws MidLevelException {
+     *         c();
+     *     }
+     *     static void c() throws MidLevelException {
+     *         try {
+     *             d();
+     *         } catch(LowLevelException e) {
+     *             throw new MidLevelException(e);
+     *         }
+     *     }
+     *     static void d() throws LowLevelException {
+     *        e();
+     *     }
+     *     static void e() throws LowLevelException {
+     *         throw new LowLevelException();
+     *     }
+     * }
+     *
+     * class HighLevelException extends Exception {
+     *     HighLevelException(Throwable cause) { super(cause); }
+     * }
+     *
+     * class MidLevelException extends Exception {
+     *     MidLevelException(Throwable cause)  { super(cause); }
+     * }
+     *
+     * class LowLevelException extends Exception {
+     * }
+     *
+ * As of release 7, the platform supports the notion of + * suppressed exceptions (in conjunction with the {@code + * try}-with-resources statement). Any exceptions that were + * suppressed in order to deliver an exception are printed out + * beneath the stack trace. The format of this information + * depends on the implementation, but the following example may be + * regarded as typical: + * + * 
+     * Exception in thread "main" java.lang.Exception: Something happened
+     *  at Foo.bar(Foo.java:10)
+     *  at Foo.main(Foo.java:5)
+     *  Suppressed: Resource$CloseFailException: Resource ID = 0
+     *          at Resource.close(Resource.java:26)
+     *          at Foo.bar(Foo.java:9)
+     *          ... 1 more
+     *
+ * Note that the "... n more" notation is used on suppressed exceptions + * just at it is used on causes. Unlike causes, suppressed exceptions are + * indented beyond their "containing exceptions." + * + *

An exception can have both a cause and one or more suppressed + * exceptions: + * 

+     * Exception in thread "main" java.lang.Exception: Main block
+     *  at Foo3.main(Foo3.java:7)
+     *  Suppressed: Resource$CloseFailException: Resource ID = 2
+     *          at Resource.close(Resource.java:26)
+     *          at Foo3.main(Foo3.java:5)
+     *  Suppressed: Resource$CloseFailException: Resource ID = 1
+     *          at Resource.close(Resource.java:26)
+     *          at Foo3.main(Foo3.java:5)
+     * Caused by: java.lang.Exception: I did it
+     *  at Foo3.main(Foo3.java:8)
+     *
+ * Likewise, a suppressed exception can have a cause: + * 
+     * Exception in thread "main" java.lang.Exception: Main block
+     *  at Foo4.main(Foo4.java:6)
+     *  Suppressed: Resource2$CloseFailException: Resource ID = 1
+     *          at Resource2.close(Resource2.java:20)
+     *          at Foo4.main(Foo4.java:5)
+     *  Caused by: java.lang.Exception: Rats, you caught me
+     *          at Resource2$CloseFailException.(Resource2.java:45)
+     *          ... 2 more
+     *
+ */ + public void printStackTrace() { + printStackTrace(System.err); + } + + /** + * Prints this throwable and its backtrace to the specified print stream. + * + * @param s {@code PrintStream} to use for output + */ + public void printStackTrace(PrintStream s) { + printStackTrace(new WrappedPrintStream(s)); + } + + private void printStackTrace(PrintStreamOrWriter s) { + // Guard against malicious overrides of Throwable.equals by + // using a Set with identity equality semantics. + Set dejaVu = + Collections.newSetFromMap(new IdentityHashMap()); + dejaVu.add(this); + + synchronized (s.lock()) { + // Print our stack trace + s.println(this); + StackTraceElement[] trace = getOurStackTrace(); + for (StackTraceElement traceElement : trace) + s.println("\tat " + traceElement); + + // Print suppressed exceptions, if any + for (Throwable se : getSuppressed()) + se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu); + + // Print cause, if any + Throwable ourCause = getCause(); + if (ourCause != null) + ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu); + } + } + + /** + * Print our stack trace as an enclosed exception for the specified + * stack trace. + */ + private void printEnclosedStackTrace(PrintStreamOrWriter s, + StackTraceElement[] enclosingTrace, + String caption, + String prefix, + Set dejaVu) { + assert Thread.holdsLock(s.lock()); + if (dejaVu.contains(this)) { + s.println("\t[CIRCULAR REFERENCE:" + this + "]"); + } else { + dejaVu.add(this); + // Compute number of frames in common between this and enclosing trace + StackTraceElement[] trace = getOurStackTrace(); + int m = trace.length - 1; + int n = enclosingTrace.length - 1; + while (m >= 0 && n >=0 && trace[m].equals(enclosingTrace[n])) { + m--; n--; + } + int framesInCommon = trace.length - 1 - m; + + // Print our stack trace + s.println(prefix + caption + this); + for (int i = 0; i <= m; i++) + s.println(prefix + "\tat " + trace[i]); + if (framesInCommon != 0) + s.println(prefix + "\t... " + framesInCommon + " more"); + + // Print suppressed exceptions, if any + for (Throwable se : getSuppressed()) + se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, + prefix +"\t", dejaVu); + + // Print cause, if any + Throwable ourCause = getCause(); + if (ourCause != null) + ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, prefix, dejaVu); + } + } + + /** + * Prints this throwable and its backtrace to the specified + * print writer. + * + * @param s {@code PrintWriter} to use for output + * @since JDK1.1 + */ + public void printStackTrace(PrintWriter s) { + printStackTrace(new WrappedPrintWriter(s)); + } + + /** + * Wrapper class for PrintStream and PrintWriter to enable a single + * implementation of printStackTrace. + */ + private abstract static class PrintStreamOrWriter { + /** Returns the object to be locked when using this StreamOrWriter */ + abstract Object lock(); + + /** Prints the specified string as a line on this StreamOrWriter */ + abstract void println(Object o); + } + + private static class WrappedPrintStream extends PrintStreamOrWriter { + private final PrintStream printStream; + + WrappedPrintStream(PrintStream printStream) { + this.printStream = printStream; + } + + Object lock() { + return printStream; + } + + void println(Object o) { + printStream.println(o); + } + } + + private static class WrappedPrintWriter extends PrintStreamOrWriter { + private final PrintWriter printWriter; + + WrappedPrintWriter(PrintWriter printWriter) { + this.printWriter = printWriter; + } + + Object lock() { + return printWriter; + } + + void println(Object o) { + printWriter.println(o); + } + } + + /** + * Fills in the execution stack trace. This method records within this + * {@code Throwable} object information about the current state of + * the stack frames for the current thread. + * + *

If the stack trace of this {@code Throwable} {@linkplain + * Throwable#Throwable(String, Throwable, boolean, boolean) is not + * writable}, calling this method has no effect. + * + * @return a reference to this {@code Throwable} instance. + * @see java.lang.Throwable#printStackTrace() + */ + public synchronized Throwable fillInStackTrace() { + if (stackTrace != null || + backtrace != null /* Out of protocol state */ ) { + fillInStackTrace(0); + stackTrace = UNASSIGNED_STACK; + } + return this; + } + + private native Throwable fillInStackTrace(int dummy); + + /** + * Provides programmatic access to the stack trace information printed by + * {@link #printStackTrace()}. Returns an array of stack trace elements, + * each representing one stack frame. The zeroth element of the array + * (assuming the array's length is non-zero) represents the top of the + * stack, which is the last method invocation in the sequence. Typically, + * this is the point at which this throwable was created and thrown. + * The last element of the array (assuming the array's length is non-zero) + * represents the bottom of the stack, which is the first method invocation + * in the sequence. + * + *

Some virtual machines may, under some circumstances, omit one + * or more stack frames from the stack trace. In the extreme case, + * a virtual machine that has no stack trace information concerning + * this throwable is permitted to return a zero-length array from this + * method. Generally speaking, the array returned by this method will + * contain one element for every frame that would be printed by + * {@code printStackTrace}. Writes to the returned array do not + * affect future calls to this method. + * + * @return an array of stack trace elements representing the stack trace + * pertaining to this throwable. + * @since 1.4 + */ + public StackTraceElement[] getStackTrace() { + return getOurStackTrace().clone(); + } + + private synchronized StackTraceElement[] getOurStackTrace() { + // Initialize stack trace field with information from + // backtrace if this is the first call to this method + if (stackTrace == UNASSIGNED_STACK || + (stackTrace == null && backtrace != null) /* Out of protocol state */) { + int depth = getStackTraceDepth(); + stackTrace = new StackTraceElement[depth]; + for (int i=0; i < depth; i++) + stackTrace[i] = getStackTraceElement(i); + } else if (stackTrace == null) { + return UNASSIGNED_STACK; + } + return stackTrace; + } + + /** + * Sets the stack trace elements that will be returned by + * {@link #getStackTrace()} and printed by {@link #printStackTrace()} + * and related methods. + * + * This method, which is designed for use by RPC frameworks and other + * advanced systems, allows the client to override the default + * stack trace that is either generated by {@link #fillInStackTrace()} + * when a throwable is constructed or deserialized when a throwable is + * read from a serialization stream. + * + *

If the stack trace of this {@code Throwable} {@linkplain + * Throwable#Throwable(String, Throwable, boolean, boolean) is not + * writable}, calling this method has no effect other than + * validating its argument. + * + * @param stackTrace the stack trace elements to be associated with + * this {@code Throwable}. The specified array is copied by this + * call; changes in the specified array after the method invocation + * returns will have no affect on this {@code Throwable}'s stack + * trace. + * + * @throws NullPointerException if {@code stackTrace} is + * {@code null} or if any of the elements of + * {@code stackTrace} are {@code null} + * + * @since 1.4 + */ + public void setStackTrace(StackTraceElement[] stackTrace) { + // Validate argument + StackTraceElement[] defensiveCopy = stackTrace.clone(); + for (int i = 0; i < defensiveCopy.length; i++) { + if (defensiveCopy[i] == null) + throw new NullPointerException("stackTrace[" + i + "]"); + } + + synchronized (this) { + if (this.stackTrace == null && // Immutable stack + backtrace == null) // Test for out of protocol state + return; + this.stackTrace = defensiveCopy; + } + } + + /** + * Returns the number of elements in the stack trace (or 0 if the stack + * trace is unavailable). + * + * package-protection for use by SharedSecrets. + */ + native int getStackTraceDepth(); + + /** + * Returns the specified element of the stack trace. + * + * package-protection for use by SharedSecrets. + * + * @param index index of the element to return. + * @throws IndexOutOfBoundsException if {@code index < 0 || + * index >= getStackTraceDepth() } + */ + native StackTraceElement getStackTraceElement(int index); + + /** + * Reads a {@code Throwable} from a stream, enforcing + * well-formedness constraints on fields. Null entries and + * self-pointers are not allowed in the list of {@code + * suppressedExceptions}. Null entries are not allowed for stack + * trace elements. A null stack trace in the serial form results + * in a zero-length stack element array. A single-element stack + * trace whose entry is equal to {@code new StackTraceElement("", + * "", null, Integer.MIN_VALUE)} results in a {@code null} {@code + * stackTrace} field. + * + * Note that there are no constraints on the value the {@code + * cause} field can hold; both {@code null} and {@code this} are + * valid values for the field. + */ + private void readObject(ObjectInputStream s) + throws IOException, ClassNotFoundException { + s.defaultReadObject(); // read in all fields + if (suppressedExceptions != null) { + List suppressed = null; + if (suppressedExceptions.isEmpty()) { + // Use the sentinel for a zero-length list + suppressed = SUPPRESSED_SENTINEL; + } else { // Copy Throwables to new list + suppressed = new ArrayList<>(1); + for (Throwable t : suppressedExceptions) { + // Enforce constraints on suppressed exceptions in + // case of corrupt or malicious stream. + if (t == null) + throw new NullPointerException(NULL_CAUSE_MESSAGE); + if (t == this) + throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE); + suppressed.add(t); + } + } + suppressedExceptions = suppressed; + } // else a null suppressedExceptions field remains null + + /* + * For zero-length stack traces, use a clone of + * UNASSIGNED_STACK rather than UNASSIGNED_STACK itself to + * allow identity comparison against UNASSIGNED_STACK in + * getOurStackTrace. The identity of UNASSIGNED_STACK in + * stackTrace indicates to the getOurStackTrace method that + * the stackTrace needs to be constructed from the information + * in backtrace. + */ + if (stackTrace != null) { + if (stackTrace.length == 0) { + stackTrace = UNASSIGNED_STACK.clone(); + } else if (stackTrace.length == 1 && + // Check for the marker of an immutable stack trace + SentinelHolder.STACK_TRACE_ELEMENT_SENTINEL.equals(stackTrace[0])) { + stackTrace = null; + } else { // Verify stack trace elements are non-null. + for(StackTraceElement ste : stackTrace) { + if (ste == null) + throw new NullPointerException("null StackTraceElement in serial stream. "); + } + } + } else { + // A null stackTrace field in the serial form can result + // from an exception serialized without that field in + // older JDK releases; treat such exceptions as having + // empty stack traces. + stackTrace = UNASSIGNED_STACK.clone(); + } + } + + /** + * Write a {@code Throwable} object to a stream. + * + * A {@code null} stack trace field is represented in the serial + * form as a one-element array whose element is equal to {@code + * new StackTraceElement("", "", null, Integer.MIN_VALUE)}. + */ + private synchronized void writeObject(ObjectOutputStream s) + throws IOException { + // Ensure that the stackTrace field is initialized to a + // non-null value, if appropriate. As of JDK 7, a null stack + // trace field is a valid value indicating the stack trace + // should not be set. + getOurStackTrace(); + + StackTraceElement[] oldStackTrace = stackTrace; + try { + if (stackTrace == null) + stackTrace = SentinelHolder.STACK_TRACE_SENTINEL; + s.defaultWriteObject(); + } finally { + stackTrace = oldStackTrace; + } + } + + /** + * Appends the specified exception to the exceptions that were + * suppressed in order to deliver this exception. This method is + * thread-safe and typically called (automatically and implicitly) + * by the {@code try}-with-resources statement. + * + *

The suppression behavior is enabled unless disabled + * {@linkplain #Throwable(String, Throwable, boolean, boolean) via + * a constructor}. When suppression is disabled, this method does + * nothing other than to validate its argument. + * + *

Note that when one exception {@linkplain + * #initCause(Throwable) causes} another exception, the first + * exception is usually caught and then the second exception is + * thrown in response. In other words, there is a causal + * connection between the two exceptions. + * + * In contrast, there are situations where two independent + * exceptions can be thrown in sibling code blocks, in particular + * in the {@code try} block of a {@code try}-with-resources + * statement and the compiler-generated {@code finally} block + * which closes the resource. + * + * In these situations, only one of the thrown exceptions can be + * propagated. In the {@code try}-with-resources statement, when + * there are two such exceptions, the exception originating from + * the {@code try} block is propagated and the exception from the + * {@code finally} block is added to the list of exceptions + * suppressed by the exception from the {@code try} block. As an + * exception unwinds the stack, it can accumulate multiple + * suppressed exceptions. + * + *

An exception may have suppressed exceptions while also being + * caused by another exception. Whether or not an exception has a + * cause is semantically known at the time of its creation, unlike + * whether or not an exception will suppress other exceptions + * which is typically only determined after an exception is + * thrown. + * + *

Note that programmer written code is also able to take + * advantage of calling this method in situations where there are + * multiple sibling exceptions and only one can be propagated. + * + * @param exception the exception to be added to the list of + * suppressed exceptions + * @throws IllegalArgumentException if {@code exception} is this + * throwable; a throwable cannot suppress itself. + * @throws NullPointerException if {@code exception} is {@code null} + * @since 1.7 + */ + public final synchronized void addSuppressed(Throwable exception) { + if (exception == this) + throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE); + + if (exception == null) + throw new NullPointerException(NULL_CAUSE_MESSAGE); + + if (suppressedExceptions == null) // Suppressed exceptions not recorded + return; + + if (suppressedExceptions == SUPPRESSED_SENTINEL) + suppressedExceptions = new ArrayList<>(1); + + suppressedExceptions.add(exception); + } + + private static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0]; + + /** + * Returns an array containing all of the exceptions that were + * suppressed, typically by the {@code try}-with-resources + * statement, in order to deliver this exception. + * + * If no exceptions were suppressed or {@linkplain + * #Throwable(String, Throwable, boolean, boolean) suppression is + * disabled}, an empty array is returned. This method is + * thread-safe. Writes to the returned array do not affect future + * calls to this method. + * + * @return an array containing all of the exceptions that were + * suppressed to deliver this exception. + * @since 1.7 + */ + public final synchronized Throwable[] getSuppressed() { + if (suppressedExceptions == SUPPRESSED_SENTINEL || + suppressedExceptions == null) + return EMPTY_THROWABLE_ARRAY; + else + return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY); + } +} diff -r 4fca8ddf46de -r 0a115f1c6f3c pom.xml --- a/pom.xml Fri Sep 28 14:58:21 2012 +0200 +++ b/pom.xml Fri Sep 28 17:59:03 2012 +0200 @@ -9,6 +9,7 @@ vm htmlpage + emul