This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
String `+' improvement
- From: Tom Tromey <tromey at redhat dot com>
- To: Java Patch List <java-patches at gcc dot gnu dot org>
- Date: 29 Nov 2001 18:00:35 -0700
- Subject: String `+' improvement
- Reply-to: tromey at redhat dot com
Tonight I took Jeff's hint and updated my String+ patch to make sure
that the toString() step didn't re-copy the data. This was a huge
improvement.
I've appended the new patch in case anybody wants to see it.
I haven't written the ChangeLog entries yet. Before I submit this for
real, I want to know if people think this is generally a good idea.
It does involve a bit of ugliness in that we copy most of
StringBuffer's code. However I doubt this is a big deal. I don't
think the copy will need to change, and in fact we could start
removing unused bits from it (with an eye towards eventually having
gcj inline methods from it when appropriate).
I've also appended my simple, stupid test. On my box, without this
patch, a 5-run average of the `delta' number is 1249.4ms. With the
patch the average is 968.4ms.
That's about a 22% improvement, and that's without stack allocating
the StringBuffer. The real question is: is this really an important
optimization? I have no real-life numbers to support this patch. I
just thought it was an interesting thing to try.
Interestingly, gcj doesn't complain about how the new String
constructor references a package-private field of a class in a
different package. So this found a compiler bug.
Tom
public class SB
{
public static final int COUNT = 100000;
public static void foo (String s)
{
}
public static void main (String[] args)
{
long start = System.currentTimeMillis ();
for (int i = 0; i < COUNT; ++i)
{
foo ("hi there " + i);
}
long end1 = System.currentTimeMillis ();
for (int i = 0; i < COUNT; ++i)
{
foo ("hi there2");
}
long end2 = System.currentTimeMillis ();
System.out.println ("baseline = " + (end2 - end1));
System.out.println ("benchmark = " + (end1 - start));
System.out.println (" delta = " + ((end1 - start) - (end2 - end1)));
}
}
Index: gcc/java/lex.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/java/lex.c,v
retrieving revision 1.72
diff -u -r1.72 lex.c
--- gcc/java/lex.c 2001/11/08 15:38:10 1.72
+++ gcc/java/lex.c 2001/11/30 00:44:54
@@ -118,7 +118,10 @@
wfl_append = build_expr_wfl (get_identifier ("append"), NULL, 0, 0);
if (!wfl_string_buffer)
wfl_string_buffer =
- build_expr_wfl (get_identifier ("java.lang.StringBuffer"), NULL, 0, 0);
+ build_expr_wfl (get_identifier (flag_emit_class_files
+ ? "java.lang.StringBuffer"
+ : "gnu.gcj.runtime.StringBuffer"),
+ NULL, 0, 0);
if (!wfl_to_string)
wfl_to_string = build_expr_wfl (get_identifier ("toString"), NULL, 0, 0);
Index: libjava/Makefile.am
===================================================================
RCS file: /cvs/gcc/gcc/libjava/Makefile.am,v
retrieving revision 1.183
diff -u -r1.183 Makefile.am
--- libjava/Makefile.am 2001/11/13 17:43:38 1.183
+++ libjava/Makefile.am 2001/11/30 00:45:03
@@ -1265,6 +1265,7 @@
gnu/gcj/runtime/FirstThread.java \
gnu/gcj/runtime/JNIWeakRef.java \
gnu/gcj/runtime/SharedLibLoader.java \
+gnu/gcj/runtime/StringBuffer.java \
gnu/gcj/runtime/VMClassLoader.java \
gnu/java/io/ClassLoaderObjectInputStream.java \
gnu/java/io/NullOutputStream.java \
@@ -1625,6 +1626,7 @@
gnu/gcj/runtime/natFinalizerThread.cc \
gnu/gcj/runtime/natFirstThread.cc \
gnu/gcj/runtime/natSharedLibLoader.cc \
+gnu/gcj/runtime/natStringBuffer.cc \
java/io/natFile.cc \
java/io/natFileDescriptor.cc \
java/io/natObjectInputStream.cc \
Index: libjava/Makefile.in
===================================================================
RCS file: /cvs/gcc/gcc/libjava/Makefile.in,v
retrieving revision 1.194
diff -u -r1.194 Makefile.in
--- libjava/Makefile.in 2001/11/13 17:43:38 1.194
+++ libjava/Makefile.in 2001/11/30 00:45:06
@@ -998,6 +998,7 @@
gnu/gcj/runtime/FirstThread.java \
gnu/gcj/runtime/JNIWeakRef.java \
gnu/gcj/runtime/SharedLibLoader.java \
+gnu/gcj/runtime/StringBuffer.java \
gnu/gcj/runtime/VMClassLoader.java \
gnu/java/io/ClassLoaderObjectInputStream.java \
gnu/java/io/NullOutputStream.java \
@@ -1357,6 +1358,7 @@
gnu/gcj/runtime/natFinalizerThread.cc \
gnu/gcj/runtime/natFirstThread.cc \
gnu/gcj/runtime/natSharedLibLoader.cc \
+gnu/gcj/runtime/natStringBuffer.cc \
java/io/natFile.cc \
java/io/natFileDescriptor.cc \
java/io/natObjectInputStream.cc \
@@ -1520,7 +1522,8 @@
gnu/gcj/convert/natOutput_SJIS.lo gnu/gcj/io/natSimpleSHSStream.lo \
gnu/gcj/io/shs.lo gnu/gcj/protocol/core/natCoreInputStream.lo \
gnu/gcj/runtime/natFinalizerThread.lo gnu/gcj/runtime/natFirstThread.lo \
-gnu/gcj/runtime/natSharedLibLoader.lo java/io/natFile.lo \
+gnu/gcj/runtime/natSharedLibLoader.lo \
+gnu/gcj/runtime/natStringBuffer.lo java/io/natFile.lo \
java/io/natFileDescriptor.lo java/io/natObjectInputStream.lo \
java/io/natObjectOutputStream.lo java/lang/natCharacter.lo \
java/lang/natClass.lo java/lang/natClassLoader.lo \
@@ -1639,10 +1642,12 @@
.deps/gnu/gcj/runtime/FinalizerThread.P \
.deps/gnu/gcj/runtime/FirstThread.P .deps/gnu/gcj/runtime/JNIWeakRef.P \
.deps/gnu/gcj/runtime/SharedLibLoader.P \
+.deps/gnu/gcj/runtime/StringBuffer.P \
.deps/gnu/gcj/runtime/VMClassLoader.P \
.deps/gnu/gcj/runtime/natFinalizerThread.P \
.deps/gnu/gcj/runtime/natFirstThread.P \
-.deps/gnu/gcj/runtime/natSharedLibLoader.P .deps/gnu/gcj/xlib/Clip.P \
+.deps/gnu/gcj/runtime/natSharedLibLoader.P \
+.deps/gnu/gcj/runtime/natStringBuffer.P .deps/gnu/gcj/xlib/Clip.P \
.deps/gnu/gcj/xlib/Colormap.P .deps/gnu/gcj/xlib/Display.P \
.deps/gnu/gcj/xlib/Drawable.P .deps/gnu/gcj/xlib/Font.P \
.deps/gnu/gcj/xlib/GC.P .deps/gnu/gcj/xlib/Pixmap.P \
Index: libjava/defineclass.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/defineclass.cc,v
retrieving revision 1.23
diff -u -r1.23 defineclass.cc
--- libjava/defineclass.cc 2001/11/26 06:40:04 1.23
+++ libjava/defineclass.cc 2001/11/30 00:45:07
@@ -1284,8 +1284,8 @@
def->interpreted_methods[method_index] = method;
// FIXME: Shouldn't this be done after loading completes?
-// if (verify)
-// _Jv_VerifyMethod (method);
+ if (verify)
+ _Jv_VerifyMethod (method);
}
void _Jv_ClassReader::handleExceptionTableEntry
Index: libjava/gnu/gcj/runtime/StringBuffer.java
===================================================================
RCS file: StringBuffer.java
diff -N StringBuffer.java
--- /dev/null Tue May 5 13:32:27 1998
+++ libjava/gnu/gcj/runtime/StringBuffer.java Thu Nov 29 16:45:09 2001
@@ -0,0 +1,715 @@
+// This is a copy of java.lang.StringBuffer with `synchronized' removed.
+
+/* StringBuffer.java -- Growable strings
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+package gnu.gcj.runtime;
+import java.io.Serializable;
+
+/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
+ * Updated using online JDK 1.2 docs.
+ * Believed complete and correct to JDK 1.2.
+ * Merged with Classpath.
+ */
+
+/**
+ * <code>StringBuffer</code> represents a changeable <code>String</code>.
+ * It provides the operations required to modify the
+ * <code>StringBuffer</code> including insert, replace, delete, append,
+ * and reverse.
+ * <P>
+ *
+ * <code>StringBuffer</code>s are variable-length in nature, so even if
+ * you initialize them to a certain size, they can still grow larger than
+ * that. <EM>Capacity</EM> indicates the number of characters the
+ * <code>StringBuffer</code> can have in it before it has to grow (growing
+ * the char array is an expensive operation involving <code>new</code>).
+ * <P>
+ *
+ * Incidentally, the String operator "+" actually is turned into a
+ * <code>StringBuffer</code> operation:
+ * <BR>
+ * <code>a + b</code>
+ * <BR>
+ * is the same as
+ * <BR>
+ * <code>new StringBuffer(a).append(b).toString()</code>.
+ *
+ * @implnote Classpath's StringBuffer is capable of sharing memory with
+ * Strings for efficiency. This will help in two instances:
+ * first, when a StringBuffer is created from a String but is
+ * never changed, and second, when a StringBuffer is converted
+ * to a String and the StringBuffer is not changed after that.
+ *
+ * @since JDK1.0
+ * @author Paul Fisher
+ * @author John Keiser
+ * @author Tom Tromey
+ * @see java.lang.String
+ */
+public final class StringBuffer implements Serializable, CharSequence
+{
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param bool the <code>boolean</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(boolean)
+ */
+ public StringBuffer append (boolean bool)
+ {
+ return append (String.valueOf(bool));
+ }
+
+ /** Append the <code>char</code> to this <code>StringBuffer</code>.
+ * @param c the <code>char</code> to append.
+ * @return this <code>StringBuffer</code>.
+ */
+ public StringBuffer append (char ch)
+ {
+ ensureCapacity_unsynchronized (count + 1);
+ value[count++] = ch;
+ return this;
+ }
+
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param inum the <code>int</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(int)
+ */
+ public native StringBuffer append (int inum);
+
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param lnum the <code>long</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(long)
+ */
+ public StringBuffer append (long lnum)
+ {
+ return append (String.valueOf(lnum));
+ }
+
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param fnum the <code>float</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(float)
+ */
+ public StringBuffer append (float fnum)
+ {
+ return append (String.valueOf(fnum));
+ }
+
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param dnum the <code>double</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(double)
+ */
+ public StringBuffer append (double dnum)
+ {
+ return append (String.valueOf(dnum));
+ }
+
+ /** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param obj the <code>Object</code> to convert and append.
+ * @return this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(java.lang.Object)
+ */
+ public StringBuffer append (Object obj)
+ {
+ return append (String.valueOf(obj));
+ }
+
+ /** Append the <code>String</code> to this <code>StringBuffer</code>.
+ * @param str the <code>String</code> to append.
+ * @return this <code>StringBuffer</code>.
+ */
+ public StringBuffer append (String str)
+ {
+ if (str == null)
+ str = "null";
+ int len = str.length();
+ ensureCapacity_unsynchronized (count + len);
+ str.getChars(0, len, value, count);
+ count += len;
+ return this;
+ }
+
+ /** Append the <code>char</code> array to this <code>StringBuffer</code>.
+ * @param data the <code>char[]</code> to append.
+ * @return this <code>StringBuffer</code>.
+ * @exception NullPointerException if <code>str</code> is <code>null</code>.
+ */
+ public StringBuffer append (char[] data)
+ {
+ return append (data, 0, data.length);
+ }
+
+ /** Append the <code>char</code> array to this <code>StringBuffer</code>.
+ * @param data the <code>char[]</code> to append.
+ * @param offset the place to start grabbing characters from
+ * <code>str</code>.
+ * @param count the number of characters to get from <code>str</code>.
+ * @return this <code>StringBuffer</code>.
+ * @exception NullPointerException if <code>str</code> is <code>null</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> or
+ * <code>offset+len</code> is out of range.
+ */
+ public StringBuffer append (char[] data, int offset, int count)
+ {
+ ensureCapacity_unsynchronized (this.count + count);
+ System.arraycopy(data, offset, value, this.count, count);
+ this.count += count;
+ return this;
+ }
+
+ /** Get the total number of characters this <code>StringBuffer</code>
+ * can support before it must be grown. Not to be confused with
+ * <em>length</em>.
+ * @return the capacity of this <code>StringBuffer</code>
+ * @see #length()
+ * @see #ensureCapacity(int)
+ */
+ public int capacity ()
+ {
+ return value.length;
+ }
+
+ /** Get the character at the specified index.
+ * @param index the index of the character to get, starting at 0.
+ * @return the character at the specified index.
+ * @exception IndexOutOfBoundsException if the desired character index
+ * is negative or greater then length() - 1.
+ */
+ public char charAt (int index)
+ {
+ if (index >= count)
+ throw new StringIndexOutOfBoundsException (index);
+ return value[index];
+ }
+
+ /** Delete characters from this <code>StringBuffer</code>.
+ * <code>delete(10, 12)</code> will delete 10 and 11, but not 12.
+ * @param start the first character to delete.
+ * @param end the index after the last character to delete.
+ * @return this <code>StringBuffer</code>.
+ * @exception StringIndexOutOfBoundsException if <code>start</code>
+ * or <code>end-1</code> are out of bounds, or if
+ * <code>start > end</code>.
+ */
+ public StringBuffer delete (int start, int end)
+ {
+ if (start < 0 || start > count || start > end)
+ throw new StringIndexOutOfBoundsException (start);
+ if (end > count)
+ end = count;
+ // This will unshare if required.
+ ensureCapacity_unsynchronized (count);
+ if (count - end != 0)
+ System.arraycopy (value, end, value, start, count - end);
+ count -= (end - start);
+ return this;
+ }
+
+ /** Delete a character from this <code>StringBuffer</code>.
+ * @param index the index of the character to delete.
+ * @return this <code>StringBuffer</code>.
+ * @exception StringIndexOutOfBoundsException if <code>index</code>
+ * is out of bounds.
+ */
+ public StringBuffer deleteCharAt(int index)
+ {
+ return delete (index, index + 1);
+ }
+
+ /** Increase the capacity of this <code>StringBuffer</code>.
+ * This will ensure that an expensive growing operation will not occur
+ * until <code>minimumCapacity</code> is reached.
+ * If the capacity is actually already greater than <code>minimumCapacity</code>
+ * @param minimumCapacity the new capacity.
+ * @see #capacity()
+ */
+ public void ensureCapacity (int minimumCapacity)
+ {
+ if (shared || minimumCapacity > value.length)
+ {
+ // We don't want to make a larger vector when `shared' is
+ // set. If we do, then setLength becomes very inefficient
+ // when repeatedly reusing a StringBuffer in a loop.
+ int max = (minimumCapacity > value.length
+ ? value.length*2+2
+ : value.length);
+ minimumCapacity = (minimumCapacity < max ? max : minimumCapacity);
+ char[] nb = new char[minimumCapacity];
+ System.arraycopy(value, 0, nb, 0, count);
+ value = nb;
+ shared = false;
+ }
+ }
+
+ // ensureCapacity is used by several synchronized methods in StringBuffer.
+ // There's no need to synchronize again.
+ private void ensureCapacity_unsynchronized (int minimumCapacity)
+ {
+ if (shared || minimumCapacity > value.length)
+ {
+ // We don't want to make a larger vector when `shared' is
+ // set. If we do, then setLength becomes very inefficient
+ // when repeatedly reusing a StringBuffer in a loop.
+ int max = (minimumCapacity > value.length
+ ? value.length*2+2
+ : value.length);
+ minimumCapacity = (minimumCapacity < max ? max : minimumCapacity);
+ char[] nb = new char[minimumCapacity];
+ System.arraycopy(value, 0, nb, 0, count);
+ value = nb;
+ shared = false;
+ }
+ }
+
+ /** Get the specified array of characters.
+ * The characters will be copied into the array you pass in.
+ * @param srcOffset the index to start copying from in the
+ * <code>StringBuffer</code>.
+ * @param srcEnd the number of characters to copy.
+ * @param dst the array to copy into.
+ * @param dstOffset the index to start copying into <code>dst</code>.
+ * @exception NullPointerException if dst is null.
+ * @exception IndexOutOfBoundsException if any source or target
+ * indices are out of range.
+ * @see java.lang.System#arraycopy(java.lang.Object,int,java.lang.Object,int,int)
+ */
+ public void getChars (int srcOffset, int srcEnd,
+ char[] dst, int dstOffset)
+ {
+ if (srcOffset < 0 || srcOffset > srcEnd)
+ throw new StringIndexOutOfBoundsException (srcOffset);
+ int todo = srcEnd - srcOffset;
+ if (srcEnd > count || dstOffset + todo > count)
+ throw new StringIndexOutOfBoundsException (srcEnd);
+ System.arraycopy(value, srcOffset, dst, dstOffset, todo);
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param bool the <code>boolean</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(boolean)
+ */
+ public StringBuffer insert (int offset, boolean bool)
+ {
+ return insert (offset, bool ? "true" : "false");
+ }
+
+ /** Insert the <code>char</code> argument into this <code>StringBuffer</code>.
+ * @param offset the place to insert.
+ * @param ch the <code>char</code> to insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ */
+ public StringBuffer insert (int offset, char ch)
+ {
+ if (offset < 0 || offset > count)
+ throw new StringIndexOutOfBoundsException (offset);
+ ensureCapacity_unsynchronized (count+1);
+ System.arraycopy(value, offset, value, offset+1, count-offset);
+ value[offset] = ch;
+ count++;
+ return this;
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param inum the <code>int</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(int)
+ */
+ public StringBuffer insert (int offset, int inum)
+ {
+ return insert (offset, String.valueOf(inum));
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param lnum the <code>long</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(long)
+ */
+ public StringBuffer insert (int offset, long lnum)
+ {
+ return insert (offset, String.valueOf(lnum));
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param fnum the <code>float</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(float)
+ */
+ public StringBuffer insert (int offset, float fnum)
+ {
+ return insert (offset, String.valueOf(fnum));
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param dnum the <code>double</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(double)
+ */
+ public StringBuffer insert (int offset, double dnum)
+ {
+ return insert (offset, String.valueOf(dnum));
+ }
+
+ /** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
+ * Uses <code>String.valueOf()</code> to convert to
+ * <code>String</code>.
+ * @param offset the place to insert.
+ * @param obj the <code>Object</code> to convert and insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ * @see java.lang.String#valueOf(java.lang.Object)
+ */
+ public StringBuffer insert (int offset, Object obj)
+ {
+ return insert (offset, String.valueOf(obj));
+ }
+
+ /** Insert the <code>String</code> argument into this <code>StringBuffer</code>.
+ * @param offset the place to insert.
+ * @param str the <code>String</code> to insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ */
+ public StringBuffer insert (int offset, String str)
+ {
+ if (offset < 0 || offset > count)
+ throw new StringIndexOutOfBoundsException (offset);
+ // Note that using `null' is from JDK 1.2.
+ if (str == null)
+ str = "null";
+ int len = str.length();
+ ensureCapacity_unsynchronized (count+len);
+ System.arraycopy(value, offset, value, offset+len, count-offset);
+ str.getChars(0, len, value, offset);
+ count += len;
+ return this;
+ }
+
+ /** Insert the <code>char[]</code> argument into this
+ * <code>StringBuffer</code>.
+ * @param offset the place to insert.
+ * @param data the <code>char[]</code> to insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception NullPointerException if <code>data</code> is
+ * <code>null</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range for this <code>StringBuffer</code>.
+ */
+ public StringBuffer insert (int offset, char[] data)
+ {
+ // One could check if offset is invalid here instead of making sure that
+ // data isn't null before dereferencing, but this works just as well.
+ return insert (offset, data, 0, data == null ? 0 : data.length);
+ }
+
+ /** Insert the <code>char[]</code> argument into this
+ * <code>StringBuffer</code>.
+ * @param offset the place to insert.
+ * @param str the <code>char[]</code> to insert.
+ * @param str_offset the index in <code>str</code> to start inserting
+ * from.
+ * @param len the number of characters to insert.
+ * @return this <code>StringBuffer</code>.
+ * @exception NullPointerException if <code>str</code> is <code>null</code>.
+ * @exception IndexOutOfBoundsException if <code>offset</code> is out
+ * of range, for this <code>StringBuffer</code>, or if
+ * <code>str_offset</code> or <code>str_offset+len</code>
+ * are out of range for <code>str</code>.
+ */
+ public StringBuffer insert(int offset, char[] str,
+ int str_offset, int len)
+ {
+ if (offset < 0 || offset > count)
+ throw new StringIndexOutOfBoundsException (offset);
+ if (len < 0)
+ throw new StringIndexOutOfBoundsException (len);
+ if (str_offset < 0 || str_offset + len > str.length)
+ throw new StringIndexOutOfBoundsException (str_offset);
+ ensureCapacity_unsynchronized (count + len);
+ System.arraycopy(value, offset, value, offset + len, count - offset);
+ System.arraycopy(str, str_offset, value, offset, len);
+ count += len;
+ return this;
+ }
+
+ /** Get the length of the <code>String</code> this
+ * <code>StringBuffer</code> would create. Not to be confused with the
+ * <em>capacity</em> of the <code>StringBuffer</code>.
+ * @return the length of this <code>StringBuffer</code>.
+ * @see #capacity()
+ * @see #setLength(int)
+ */
+ public int length ()
+ {
+ return count;
+ }
+
+ /** Replace characters between index <code>start</code> (inclusive) and
+ * <code>end</code> (exclusive) with <code>str</code>. If <code>end</code>
+ * is larger than the size of this StringBuffer, all characters after
+ * <code>start</code> are replaced.
+ * @param start the beginning index of characters to delete (inclusive).
+ * @param end the ending index of characters to delete (exclusive).
+ * @param str the new <code>String</code> to insert.
+ * @return this <code>StringBuffer</code>.
+ */
+ public StringBuffer replace (int start, int end, String str)
+ {
+ if (start < 0 || start > count || start > end)
+ throw new StringIndexOutOfBoundsException (start);
+
+ int len = str.length();
+ // Calculate the difference in 'count' after the replace.
+ int delta = len - ((end > count ? count : end) - start);
+ ensureCapacity_unsynchronized (count + delta);
+
+ if (delta != 0 && end < count)
+ System.arraycopy(value, end, value, end + delta, count - end);
+
+ str.getChars (0, len, value, start);
+ count += delta;
+ return this;
+ }
+
+ /** Reverse the characters in this StringBuffer.
+ * @return this <code>StringBuffer</code>.
+ */
+ public StringBuffer reverse ()
+ {
+ // Call ensureCapacity to enforce copy-on-write.
+ ensureCapacity_unsynchronized (count);
+ for (int i = 0; i < count / 2; ++i)
+ {
+ char c = value[i];
+ value[i] = value[count - i - 1];
+ value[count - i - 1] = c;
+ }
+ return this;
+ }
+
+ /** Set the character at the specified index.
+ * @param index the index of the character to set starting at 0.
+ * @param ch the value to set that character to.
+ * @exception IndexOutOfBoundsException if the specified character
+ * index is not between 0 and length() - 1 (inclusive).
+ */
+ public void setCharAt (int index, char ch)
+ {
+ if (index < 0 || index >= count)
+ throw new StringIndexOutOfBoundsException (index);
+ // Call ensureCapacity to enforce copy-on-write.
+ ensureCapacity_unsynchronized (count);
+ value[index] = ch;
+ }
+
+ /** Set the length of this StringBuffer.
+ * <P>
+ * If the new length is greater than the current length, all the new
+ * characters are set to '\0'.
+ * <P>
+ * If the new length is less than the current length, the first
+ * <code>newLength</code> characters of the old array will be
+ * @param newLength the new length
+ * @exception IndexOutOfBoundsException if the new length is
+ * negative.
+ * @see #length()
+ */
+ public void setLength (int newLength)
+ {
+ if (newLength < 0)
+ throw new StringIndexOutOfBoundsException (newLength);
+
+ ensureCapacity_unsynchronized (newLength);
+ for (int i = count; i < newLength; ++i)
+ value[i] = '\0';
+ count = newLength;
+ }
+
+ /** Create a new StringBuffer with default capacity 16.
+ * @see JLS 20.13.1
+ */
+ public StringBuffer ()
+ {
+ this (DEFAULT_CAPACITY);
+ }
+
+ /** Create an empty <code>StringBuffer</code> with the specified initial capacity.
+ * @param capacity the initial capacity.
+ */
+ public StringBuffer (int capacity)
+ {
+ count = 0;
+ value = new char[capacity];
+ shared = false;
+ }
+
+ /** Create a new <code>StringBuffer</code> with the characters in the specified <code>String</code>.
+ * Initial capacity will be the size of the String plus 16.
+ * @param str the <code>String</code> to make a <code>StringBuffer</code> out of.
+ * @XXX optimize for sharing.
+ */
+ public StringBuffer (String str)
+ {
+ // The documentation is not clear, but experimentation with
+ // other implementations indicates that StringBuffer(null)
+ // should throw a NullPointerException.
+ count = str.length();
+ // JLS: The initial capacity of the string buffer is 16 plus the
+ // length of the argument string.
+ value = new char[count + DEFAULT_CAPACITY];
+ str.getChars(0, count, value, 0);
+ shared = false;
+ }
+
+ /**
+ * Creates a substring of this StringBuffer, starting at a specified index
+ * and ending at the end of this StringBuffer.
+ *
+ * @param beginIndex index to start substring (base 0)
+ *
+ * @return new String which is a substring of this StringBuffer
+ *
+ * @exception StringIndexOutOfBoundsException
+ * if (beginIndex < 0 || beginIndex > this.length())
+ */
+ public String substring (int beginIndex)
+ {
+ return substring (beginIndex, count);
+ }
+
+ /**
+ * Creates a substring of this StringBuffer, starting at a specified index
+ * and ending at one character before a specified index.
+ *
+ * @param beginIndex index to start substring (base 0)
+ * @param endIndex index after the last character to be
+ * copied into the substring
+ *
+ * @return new String which is a substring of this StringBuffer
+ *
+ * @exception StringIndexOutOfBoundsException
+ * if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex)
+ */
+ public String substring (int beginIndex, int endIndex)
+ {
+ if (beginIndex < 0 || endIndex > count || beginIndex > endIndex)
+ throw new StringIndexOutOfBoundsException ();
+ // FIXME: for libgcj it would be possible, and more efficient, to
+ // enable sharing here.
+ return new String (value, beginIndex, endIndex - beginIndex);
+ }
+
+ /**
+ * Creates a substring of this StringBuffer, starting at a specified index
+ * and ending at one character before a specified index.
+ * <p>
+ * To implement <code>CharSequence</code>.
+ * Calls <code>substring(beginIndex, endIndex)</code>.
+ *
+ * @param beginIndex index to start substring (base 0)
+ * @param endIndex index after the last character to be
+ * copied into the substring
+ *
+ * @return new String which is a substring of this StringBuffer
+ *
+ * @exception StringIndexOutOfBoundsException
+ * if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex)
+ */
+ public CharSequence subSequence (int beginIndex, int endIndex)
+ {
+ return substring(beginIndex, endIndex);
+ }
+
+
+ /** Convert this <code>StringBuffer</code> to a <code>String</code>.
+ * @return the characters in this StringBuffer
+ */
+ // This is native because efficient implementation requires avoiding
+ // the Java protection mechanism.
+ public native String toString ();
+
+ // Index of next available character. Note that this has
+ // permissions set this way so that String can get the value.
+ int count;
+
+ // The buffer. Note that this has permissions set this way so that
+ // String can get the value.
+ char[] value;
+
+ // True if we need to copy the buffer before writing to it again.
+ // FIXME: JDK 1.2 doesn't specify this. The new buffer-growing
+ // semantics make this less useful in that case, too. Note that
+ // this has permissions set this way so that String can get the
+ // value.
+ boolean shared;
+
+ static final long serialVersionUID = 3388685877147921107L;
+ private final static int DEFAULT_CAPACITY = 16; // JLS 20.13.1
+}
Index: libjava/gnu/gcj/runtime/natStringBuffer.cc
===================================================================
RCS file: natStringBuffer.cc
diff -N natStringBuffer.cc
--- /dev/null Tue May 5 13:32:27 1998
+++ libjava/gnu/gcj/runtime/natStringBuffer.cc Thu Nov 29 16:45:09 2001
@@ -0,0 +1,36 @@
+// natStringBuffer.cc - Implementation of java.lang.StringBuffer native methods.
+
+/* Copyright (C) 2001 Free Software Foundation
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+#include <config.h>
+#include <gcj/cni.h>
+#include <gnu/gcj/runtime/StringBuffer.h>
+#include <java/lang/String.h>
+
+gnu::gcj::runtime::StringBuffer *
+gnu::gcj::runtime::StringBuffer::append (jint num)
+{
+ // Use an array large enough for "-2147483648"; i.e. 11 chars.
+ jchar buffer[11];
+ int i = _Jv_FormatInt (buffer+11, num);
+ jint needed = count + i;
+ ensureCapacity_unsynchronized (needed);
+ jchar* dst = elements (value) + count;
+ jchar* src = buffer+11-i;
+ while (--i >= 0)
+ *dst++ = *src++;
+ count = needed;
+ return this;
+}
+
+java::lang::String *
+gnu::gcj::runtime::StringBuffer::toString ()
+{
+ return new java::lang::String (this);
+}
Index: libjava/java/lang/String.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/String.java,v
retrieving revision 1.16
diff -u -r1.16 String.java
--- libjava/java/lang/String.java 2001/10/02 20:59:31 1.16
+++ libjava/java/lang/String.java 2001/11/30 00:45:10
@@ -92,6 +92,16 @@
}
}
+ // This is used by gnu.gcj.runtime.StringBuffer, so it must have
+ // package-private protection. It is accessed via CNI and so avoids
+ // ordinary protection mechanisms.
+ String (gnu.gcj.runtime.StringBuffer buffer)
+ {
+ // No need to synchronize or mark the buffer, since we know it is
+ // only used once.
+ init (buffer.value, 0, buffer.count, true);
+ }
+
public String (char[] data)
{
init(data, 0, data.length, false);