From a79cb46cf43218d467e93cc62430bcad41cafc12 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Mon, 9 Jan 2006 06:42:19 +0000 Subject: [PATCH] StringBuilder.java (appendCodePoint): New method. * java/lang/StringBuilder.java (appendCodePoint): New method. (insert): New overloads. * java/lang/StringBuffer.java (StringBuffer): New constructor. (charAt): Remerged javadoc. (codePointAt, codePointBefore): New methods. (appendCodePoint): New method. (append): New overloads. (insert): Likewise. (trimToSize, codePointCount, offsetByCodePoints): New methods. * java/lang/Float.java (SIZE): New field. (valueOf): New method. * java/lang/natDouble.cc (initIDs): Removed. * java/lang/Double.java (static initializer): Removed. (SIZE): New field. (valueOf): New method. (initIDs): Removed. From-SVN: r109497 --- libjava/ChangeLog | 19 ++ libjava/java/lang/Double.java | 43 +++-- libjava/java/lang/Float.java | 24 ++- libjava/java/lang/StringBuffer.java | 261 ++++++++++++++++++++++++++- libjava/java/lang/StringBuilder.java | 67 ++++++- libjava/java/lang/natDouble.cc | 8 +- 6 files changed, 391 insertions(+), 31 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 16c256836d0..3770c671607 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,22 @@ +2006-01-08 Tom Tromey + + * java/lang/StringBuilder.java (appendCodePoint): New method. + (insert): New overloads. + * java/lang/StringBuffer.java (StringBuffer): New constructor. + (charAt): Remerged javadoc. + (codePointAt, codePointBefore): New methods. + (appendCodePoint): New method. + (append): New overloads. + (insert): Likewise. + (trimToSize, codePointCount, offsetByCodePoints): New methods. + * java/lang/Float.java (SIZE): New field. + (valueOf): New method. + * java/lang/natDouble.cc (initIDs): Removed. + * java/lang/Double.java (static initializer): Removed. + (SIZE): New field. + (valueOf): New method. + (initIDs): Removed. + 2006-01-07 Jakub Jelinek PR libgcj/24940 diff --git a/libjava/java/lang/Double.java b/libjava/java/lang/Double.java index f6235d5b65c..92f8a230822 100644 --- a/libjava/java/lang/Double.java +++ b/libjava/java/lang/Double.java @@ -1,5 +1,5 @@ /* Double.java -- object wrapper for double - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,7 +38,6 @@ exception statement from your version. */ package java.lang; -import gnu.classpath.Configuration; /** * Instances of class Double represent primitive @@ -88,6 +87,12 @@ public final class Double extends Number implements Comparable */ public static final double NaN = 0.0 / 0.0; + /** + * The number of bits needed to represent a double. + * @since 1.5 + */ + public static final int SIZE = 64; + /** * The primitive type double is represented by this * Class object. @@ -102,18 +107,6 @@ public final class Double extends Number implements Comparable */ private final double value; - /** - * Load native routines necessary for this class. - */ - static - { - if (Configuration.INIT_LOAD_LIBRARY) - { - System.loadLibrary("javalang"); - initIDs(); - } - } - /** * Create a Double from the primitive double * specified. @@ -179,6 +172,22 @@ public final class Double extends Number implements Comparable return toString(d, false); } + /** + * Returns a Double object wrapping the value. + * In contrast to the Double constructor, this method + * may cache some values. It is used by boxing conversion. + * + * @param val the value to wrap + * @return the Double + * + * @since 1.5 + */ + public static Double valueOf(double val) + { + // We don't actually cache, but we could. + return new Double(val); + } + /** * Create a new Double object using the String. * @@ -534,10 +543,4 @@ public final class Double extends Number implements Comparable */ // Package visible for use by Float. static native String toString(double d, boolean isFloat); - - /** - * Initialize JNI cache. This method is called only by the - * static initializer when using JNI. - */ - private static native void initIDs(); } diff --git a/libjava/java/lang/Float.java b/libjava/java/lang/Float.java index b2c84c75655..7677ca4132e 100644 --- a/libjava/java/lang/Float.java +++ b/libjava/java/lang/Float.java @@ -1,5 +1,5 @@ /* Float.java -- object wrapper for float - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -93,6 +93,12 @@ public final class Float extends Number implements Comparable */ public static final Class TYPE = VMClassLoader.getPrimitiveClass('F'); + /** + * The number of bits needed to represent a float. + * @since 1.5 + */ + public static final int SIZE = 32; + /** * The immutable value of this Float. * @@ -191,6 +197,22 @@ public final class Float extends Number implements Comparable return new Float(parseFloat(s)); } + /** + * Returns a Float object wrapping the value. + * In contrast to the Float constructor, this method + * may cache some values. It is used by boxing conversion. + * + * @param val the value to wrap + * @return the Float + * + * @since 1.5 + */ + public static Float valueOf(float val) + { + // We don't actually cache, but we could. + return new Float(val); + } + /** * Parse the specified String as a float. The * extended BNF grammar is as follows:
diff --git a/libjava/java/lang/StringBuffer.java b/libjava/java/lang/StringBuffer.java index d93fed5fd40..c3f112967c4 100644 --- a/libjava/java/lang/StringBuffer.java +++ b/libjava/java/lang/StringBuffer.java @@ -1,5 +1,5 @@ /* StringBuffer.java -- Growable strings - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -147,6 +147,24 @@ public final class StringBuffer implements Serializable, CharSequence str.getChars(0, count, value, 0); } + /** + * Create a new StringBuffer with the characters from the + * specified CharSequence. Initial capacity will be the + * size of the CharSequence plus 16. + * + * @param sequence the String to convert + * @throws NullPointerException if str is null + * + * @since 1.5 + */ + public StringBuffer(CharSequence sequence) + { + count = Math.max(0, sequence.length()); + value = new char[count + DEFAULT_CAPACITY]; + for (int i = 0; i < count; ++i) + value[i] = sequence.charAt(i); + } + /** * Get the length of the String this StringBuffer * would create. Not to be confused with the capacity of the @@ -234,7 +252,6 @@ public final class StringBuffer implements Serializable, CharSequence * @param index the index of the character to get, starting at 0 * @return the character at the specified index * @throws IndexOutOfBoundsException if index is negative or >= length() - * (while unspecified, this is a StringIndexOutOfBoundsException) */ public synchronized char charAt(int index) { @@ -243,6 +260,39 @@ public final class StringBuffer implements Serializable, CharSequence return value[index]; } + /** + * Get the code point at the specified index. This is like #charAt(int), + * but if the character is the start of a surrogate pair, and the + * following character completes the pair, then the corresponding + * supplementary code point is returned. + * @param index the index of the codepoint to get, starting at 0 + * @return the codepoint at the specified index + * @throws IndexOutOfBoundsException if index is negative or >= length() + * @since 1.5 + */ + public synchronized int codePointAt(int index) + { + return Character.codePointAt(value, index, count); + } + + /** + * Get the code point before the specified index. This is like + * #codePointAt(int), but checks the characters at index-1 and + * index-2 to see if they form a supplementary code point. + * @param index the index just past the codepoint to get, starting at 0 + * @return the codepoint at the specified index + * @throws IndexOutOfBoundsException if index is negative or >= length() + * @since 1.5 + */ + public synchronized int codePointBefore(int index) + { + // Character.codePointBefore() doesn't perform this check. We + // could use the CharSequence overload, but this is just as easy. + if (index >= count) + throw new IndexOutOfBoundsException(); + return Character.codePointBefore(value, index, 1); + } + /** * Get the specified array of characters. srcOffset - srcEnd * characters will be copied into the array you pass in. @@ -340,6 +390,46 @@ public final class StringBuffer implements Serializable, CharSequence return this; } + /** + * Append the CharSequence value of the argument to this + * StringBuffer. + * + * @param sequence the CharSequence to append + * @return this StringBuffer + * @see #append(Object) + * @since 1.5 + */ + public synchronized StringBuffer append(CharSequence sequence) + { + if (sequence == null) + sequence = "null"; + return append(sequence, 0, sequence.length()); + } + + /** + * Append the specified subsequence of the CharSequence + * argument to this StringBuffer. + * + * @param sequence the CharSequence to append + * @param start the starting index + * @param end one past the ending index + * @return this StringBuffer + * @see #append(Object) + * @since 1.5 + */ + public synchronized StringBuffer append(CharSequence sequence, + int start, int end) + { + if (sequence == null) + sequence = "null"; + if (start < 0 || end < 0 || start > end || end > sequence.length()) + throw new IndexOutOfBoundsException(); + ensureCapacity_unsynchronized(this.count + end - start); + for (int i = start; i < end; ++i) + value[count++] = sequence.charAt(i); + return this; + } + /** * Append the char array to this StringBuffer. * This is similar (but more efficient) than @@ -406,6 +496,25 @@ public final class StringBuffer implements Serializable, CharSequence return this; } + /** + * Append the code point to this StringBuffer. + * This is like #append(char), but will append two characters + * if a supplementary code point is given. + * + * @param code the code point to append + * @return this StringBuffer + * @see Character#toChars(int, char[], int) + * @since 1.5 + */ + public synchronized StringBuffer appendCodePoint(int code) + { + int len = Character.charCount(code); + ensureCapacity_unsynchronized(count + len); + Character.toChars(code, value, count); + count += len; + return this; + } + /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert @@ -656,6 +765,54 @@ public final class StringBuffer implements Serializable, CharSequence return this; } + /** + * Insert the CharSequence argument into this + * StringBuffer. If the sequence is null, the String + * "null" is used instead. + * + * @param offset the place to insert in this buffer + * @param sequence the CharSequence to insert + * @return this StringBuffer + * @throws IndexOutOfBoundsException if offset is out of bounds + * @since 1.5 + */ + public synchronized StringBuffer insert(int offset, CharSequence sequence) + { + if (sequence == null) + sequence = "null"; + return insert(offset, sequence, 0, sequence.length()); + } + + /** + * Insert a subsequence of the CharSequence argument into this + * StringBuffer. If the sequence is null, the String + * "null" is used instead. + * + * @param offset the place to insert in this buffer + * @param sequence the CharSequence to insert + * @param start the starting index of the subsequence + * @param end one past the ending index of the subsequence + * @return this StringBuffer + * @throws IndexOutOfBoundsException if offset, start, + * or end are out of bounds + * @since 1.5 + */ + public synchronized StringBuffer insert(int offset, CharSequence sequence, + int start, int end) + { + if (sequence == null) + sequence = "null"; + if (start < 0 || end < 0 || start > end || end > sequence.length()) + throw new IndexOutOfBoundsException(); + int len = end - start; + ensureCapacity_unsynchronized(count + len); + System.arraycopy(value, offset, value, offset + len, count - offset); + for (int i = start; i < end; ++i) + value[offset++] = sequence.charAt(i); + count += len; + return this; + } + /** * Insert the char[] argument into this * StringBuffer. @@ -876,6 +1033,106 @@ public final class StringBuffer implements Serializable, CharSequence return new String(this); } + /** + * This may reduce the amount of memory used by the StringBuffer, + * by resizing the internal array to remove unused space. However, + * this method is not required to resize, so this behavior cannot + * be relied upon. + * @since 1.5 + */ + public synchronized void trimToSize() + { + int wouldSave = value.length - count; + // Some random heuristics: if we save less than 20 characters, who + // cares. + if (wouldSave < 20) + return; + // If we save more than 200 characters, shrink. + // If we save more than 1/4 of the buffer, shrink. + if (wouldSave > 200 || wouldSave * 4 > value.length) + { + char[] newValue = new char[count]; + System.arraycopy(value, 0, newValue, 0, count); + value = newValue; + } + } + + /** + * Return the number of code points between two indices in the + * StringBuffer. An unpaired surrogate counts as a + * code point for this purpose. Characters outside the indicated + * range are not examined, even if the range ends in the middle of a + * surrogate pair. + * + * @param start the starting index + * @param end one past the ending index + * @return the number of code points + * @since 1.5 + */ + public synchronized int codePointCount(int start, int end) + { + if (start < 0 || end >= count || start > end) + throw new StringIndexOutOfBoundsException(); + + int count = 0; + while (start < end) + { + char base = value[start]; + if (base < Character.MIN_HIGH_SURROGATE + || base > Character.MAX_HIGH_SURROGATE + || start == end + || start == count + || value[start + 1] < Character.MIN_LOW_SURROGATE + || value[start + 1] > Character.MAX_LOW_SURROGATE) + { + // Nothing. + } + else + { + // Surrogate pair. + ++start; + } + ++start; + ++count; + } + return count; + } + + /** + * Starting at the given index, this counts forward by the indicated + * number of code points, and then returns the resulting index. An + * unpaired surrogate counts as a single code point for this + * purpose. + * + * @param start the starting index + * @param codePoints the number of code points + * @return the resulting index + * @since 1.5 + */ + public synchronized int offsetByCodePoints(int start, int codePoints) + { + while (codePoints > 0) + { + char base = value[start]; + if (base < Character.MIN_HIGH_SURROGATE + || base > Character.MAX_HIGH_SURROGATE + || start == count + || value[start + 1] < Character.MIN_LOW_SURROGATE + || value[start + 1] > Character.MAX_LOW_SURROGATE) + { + // Nothing. + } + else + { + // Surrogate pair. + ++start; + } + ++start; + --codePoints; + } + return start; + } + /** * An unsynchronized version of ensureCapacity, used internally to avoid * the cost of a second lock on the same object. This also has the side diff --git a/libjava/java/lang/StringBuilder.java b/libjava/java/lang/StringBuilder.java index 51df8826416..5990a6d8dd5 100644 --- a/libjava/java/lang/StringBuilder.java +++ b/libjava/java/lang/StringBuilder.java @@ -1,5 +1,5 @@ /* StringBuilder.java -- Unsynchronized growable strings - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -463,6 +463,25 @@ public final class StringBuilder return this; } + /** + * Append the code point to this StringBuilder. + * This is like #append(char), but will append two characters + * if a supplementary code point is given. + * + * @param code the code point to append + * @return this StringBuilder + * @see Character#toChars(int, char[], int) + * @since 1.5 + */ + public synchronized StringBuilder appendCodePoint(int code) + { + int len = Character.charCount(code); + ensureCapacity(count + len); + Character.toChars(code, value, count); + count += len; + return this; + } + /** * Append the String value of the argument to this * StringBuilder. Uses String.valueOf() to convert @@ -704,6 +723,52 @@ public final class StringBuilder return this; } + /** + * Insert the CharSequence argument into this + * StringBuilder. If the sequence is null, the String + * "null" is used instead. + * + * @param offset the place to insert in this buffer + * @param sequence the CharSequence to insert + * @return this StringBuilder + * @throws IndexOutOfBoundsException if offset is out of bounds + */ + public synchronized StringBuilder insert(int offset, CharSequence sequence) + { + if (sequence == null) + sequence = "null"; + return insert(offset, sequence, 0, sequence.length()); + } + + /** + * Insert a subsequence of the CharSequence argument into this + * StringBuilder. If the sequence is null, the String + * "null" is used instead. + * + * @param offset the place to insert in this buffer + * @param sequence the CharSequence to insert + * @param start the starting index of the subsequence + * @param end one past the ending index of the subsequence + * @return this StringBuilder + * @throws IndexOutOfBoundsException if offset, start, + * or end are out of bounds + */ + public synchronized StringBuilder insert(int offset, CharSequence sequence, + int start, int end) + { + if (sequence == null) + sequence = "null"; + if (start < 0 || end < 0 || start > end || end > sequence.length()) + throw new IndexOutOfBoundsException(); + int len = end - start; + ensureCapacity(count + len); + System.arraycopy(value, offset, value, offset + len, count - offset); + for (int i = start; i < end; ++i) + value[offset++] = sequence.charAt(i); + count += len; + return this; + } + /** * Insert the char[] argument into this * StringBuilder. diff --git a/libjava/java/lang/natDouble.cc b/libjava/java/lang/natDouble.cc index 72fe5fbe1c6..24dad8a6318 100644 --- a/libjava/java/lang/natDouble.cc +++ b/libjava/java/lang/natDouble.cc @@ -1,6 +1,6 @@ // natDouble.cc - Implementation of java.lang.Double native methods. -/* Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation +/* Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005, 2006 Free Software Foundation This file is part of libgcj. @@ -211,9 +211,3 @@ java::lang::Double::parseDouble(jstring str) } throw new NumberFormatException(str); } - -void -java::lang::Double::initIDs() -{ - // Not used in libgcj -}