[kaffe] CVS kaffe (dalibor): Fixes for eXist 0.9.2
Kaffe CVS
cvs-commits at kaffe.org
Sat Sep 13 05:33:02 PDT 2003
PatchSet 4030
Date: 2003/09/13 12:30:46
Author: dalibor
Branch: HEAD
Tag: (none)
Log:
Fixes for eXist 0.9.2
Merged in StringBuffer from GNU Classpath as eXist needs some methods from
Java 1.4. Added a few missing methods in Runtime and URL. eXist now loads,
and runs nicely, with ocassional hiccups due to StackOverflows. Helmer
might have a fix for that.
Members:
ChangeLog:1.1626->1.1627
libraries/clib/native/Runtime.c:1.20->1.21
libraries/javalib/java/lang/Runtime.java:1.26->1.27
libraries/javalib/java/lang/String.java:1.39->1.40
libraries/javalib/java/lang/StringBuffer.java:1.21->1.22
libraries/javalib/java/net/URL.java:1.31->1.32
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.1626 kaffe/ChangeLog:1.1627
--- kaffe/ChangeLog:1.1626 Sat Sep 13 00:23:33 2003
+++ kaffe/ChangeLog Sat Sep 13 12:30:46 2003
@@ -1,3 +1,23 @@
+2003-09-13 Dalibor Topic <robilad at kaffe.org>
+
+ * libraries/clib/native/Runtime.c:
+ (java_lang_Runtime_maxMemory) New function.
+ (java_lang_Runtime_totalMemory) Return gc_heap_total instead of
+ gc_heap_limit.
+
+ * libraries/javalib/java/lang/Runtime.java:
+ (maxMemory) New native method.
+
+ * libraries/javalib/java/lang/StringBuffer.java:
+ Replaced by implementation from GNU Classpath.
+
+ * libraries/javalib/java/lang/String.java:
+ (String) Adapted constructor to work with field names from new
+ StringBuffer implementation.
+
+ * libraries/javalib/java/net/URL.java:
+ (getUserInfo) New method.
+
2003-09-12 Ito Kazumitsu <kaz at maczuka.gcd.org>
* libraries/javalib/java/io/File.java:
added missing 1.4 features (toURI() and File(URI)) once implemented
Index: kaffe/libraries/clib/native/Runtime.c
diff -u kaffe/libraries/clib/native/Runtime.c:1.20 kaffe/libraries/clib/native/Runtime.c:1.21
--- kaffe/libraries/clib/native/Runtime.c:1.20 Tue Jul 8 23:48:24 2003
+++ kaffe/libraries/clib/native/Runtime.c Sat Sep 13 12:30:47 2003
@@ -64,12 +64,21 @@
}
/*
+ * Maximally available memory.
+ */
+jlong
+java_lang_Runtime_maxMemory(struct Hjava_lang_Runtime* this)
+{
+ return (gc_heap_limit);
+}
+
+/*
* Total memory.
*/
jlong
java_lang_Runtime_totalMemory(struct Hjava_lang_Runtime* this)
{
- return (gc_heap_limit);
+ return (gc_heap_total);
}
/*
Index: kaffe/libraries/javalib/java/lang/Runtime.java
diff -u kaffe/libraries/javalib/java/lang/Runtime.java:1.26 kaffe/libraries/javalib/java/lang/Runtime.java:1.27
--- kaffe/libraries/javalib/java/lang/Runtime.java:1.26 Sun Aug 31 17:16:50 2003
+++ kaffe/libraries/javalib/java/lang/Runtime.java Sat Sep 13 12:30:48 2003
@@ -186,6 +186,8 @@
}
}
+native public long maxMemory();
+
int getMemoryAdvice() {
return (advice.getColor());
}
Index: kaffe/libraries/javalib/java/lang/String.java
diff -u kaffe/libraries/javalib/java/lang/String.java:1.39 kaffe/libraries/javalib/java/lang/String.java:1.40
--- kaffe/libraries/javalib/java/lang/String.java:1.39 Tue Aug 12 17:18:22 2003
+++ kaffe/libraries/javalib/java/lang/String.java Sat Sep 13 12:30:48 2003
@@ -65,17 +65,17 @@
public String(StringBuffer sb) {
synchronized (sb) {
- if (sb.buffer.length > sb.used + STRINGBUFFER_SLOP) {
- value = new char[sb.used];
+ if (sb.value.length > sb.count + STRINGBUFFER_SLOP) {
+ value = new char[sb.count];
offset = 0;
- count = sb.used;
- System.arraycopy(sb.buffer, 0, value, 0, count);
+ count = sb.count;
+ sb.getChars(0, count, value, 0);
}
else {
- value = sb.buffer;
+ value = sb.value;
offset = 0;
- count = sb.used;
- sb.isStringized = true;
+ count = sb.count;
+ sb.shared = true;
}
}
}
Index: kaffe/libraries/javalib/java/lang/StringBuffer.java
diff -u kaffe/libraries/javalib/java/lang/StringBuffer.java:1.21 kaffe/libraries/javalib/java/lang/StringBuffer.java:1.22
--- kaffe/libraries/javalib/java/lang/StringBuffer.java:1.21 Fri May 23 11:27:33 2003
+++ kaffe/libraries/javalib/java/lang/StringBuffer.java Sat Sep 13 12:30:48 2003
@@ -1,293 +1,911 @@
-/*
- * Java core library component.
- *
- * Copyright (c) 1997, 1998
- * Transvirtual Technologies, Inc. All rights reserved.
- *
- * See the file "license.terms" for information on usage and redistribution
- * of this file.
- */
+/* StringBuffer.java -- Growable strings
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 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.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
package java.lang;
-public final class StringBuffer implements java.io.Serializable, CharSequence {
- private static final int SPARECAPACITY = 16;
+import java.io.Serializable;
- char[] buffer; // character buffer
- int used; // # chars used in buffer
- boolean isStringized; // buffer also part of String
- // and therefore unmodifiable
-
- // This is what Sun's JDK1.1 "serialver java.lang.StringBuffer" says
- private static final long serialVersionUID = 3388685877147921107L;
-
-public StringBuffer() {
- buffer = new char[SPARECAPACITY];
-}
-
-public StringBuffer(String str) {
- used = str.count;
- buffer = new char[used + SPARECAPACITY];
- System.arraycopy(str.value, str.offset, buffer, 0, used);
-}
-
-public StringBuffer(int length) {
- buffer = new char[length];
-}
-
-public StringBuffer append(Object obj) {
- return append(String.valueOf(obj));
-}
-
-public StringBuffer append ( String str ) {
- if (str == null) {
- str = "null";
- }
- return append(str.value, str.offset, str.count);
-}
-
-public StringBuffer append(boolean b) {
- return append(String.valueOf(b));
-}
-
-public synchronized StringBuffer append(char c) {
- if (used + 1 > buffer.length || isStringized) // optimization
- ensureCapacity(used + 1, isStringized);
- buffer[used++] = c;
- return this;
-}
-
-public StringBuffer append(char str[]) {
- return append(str, 0, str.length);
-}
-
-public synchronized StringBuffer append(char str[], int offset, int len) {
- if (offset < 0 || len < 0 || offset + len > str.length)
- throw new StringIndexOutOfBoundsException();
- if (used + len > buffer.length || isStringized) // optimization
- ensureCapacity(used + len, isStringized);
- System.arraycopy(str, offset, buffer, used, len);
- used += len;
- return this;
-}
-
-public StringBuffer append(double d) {
- return append(String.valueOf(d));
-}
-
-public StringBuffer append(float f) {
- return append(String.valueOf(f));
-}
-
-public StringBuffer append(int i) {
- return append(String.valueOf(i));
-}
-
-public StringBuffer append(long l) {
- return append(String.valueOf(l));
-}
-
-public StringBuffer append (StringBuffer sb) {
- return append (sb.buffer, 0, sb.used);
-}
-
-public int capacity() {
- return buffer.length;
-}
-
-public synchronized char charAt(int index) {
- if (index >= used)
- throw new StringIndexOutOfBoundsException();
- return buffer[index];
-}
-
-private void checkIndex(int index) {
- if (index < 0 || index > length()) {
- throw new StringIndexOutOfBoundsException();
- }
-}
-
-private void checkExistingIndex(int index) {
- if (index < 0 || index >= length()) {
- throw new StringIndexOutOfBoundsException();
- }
-}
-
-public synchronized StringBuffer deleteCharAt(int index) {
- checkExistingIndex(index);
- System.arraycopy(buffer, index + 1, buffer, index, --used - index);
- return this;
-}
-
-public synchronized StringBuffer delete(int start, int end) {
- if (end > used)
- end = used;
- if (start < 0 || start > end)
- throw new StringIndexOutOfBoundsException();
- System.arraycopy(buffer, end, buffer, start, used - end);
- used -= end - start;
- return this;
-}
-
-public synchronized StringBuffer replace(int start, int end, String str) {
- return delete(start, end).insert(start, str);
-}
-
-public synchronized String substring(int start) {
- return substring(start, used);
-}
-
-public synchronized String substring(int start, int end) {
- int length = end - start;
-
- if (start < 0 || end > used || length < 0)
- throw new StringIndexOutOfBoundsException();
- if (buffer.length - length > String.STRINGBUFFER_SLOP)
- return new String(buffer, start, length);
- else {
- isStringized = true;
- return new String(start, end, buffer);
- }
-}
-
-public CharSequence subSequence(int start, int end) {
- return substring(start, end);
-}
-
-public void ensureCapacity(int minCapacity) {
- if (minCapacity <= 0)
- return;
- synchronized (this) {
- ensureCapacity(minCapacity, isStringized);
- }
-}
-
-// This method assumes synchronization
-private boolean ensureCapacity(int minCapacity, boolean forceNew) {
-
- // Do we really need to create a new buffer?
- if (!forceNew && minCapacity <= buffer.length) {
- return false;
- }
-
- // Increase buffer size in powers of two to avoid O(n^2) behavior
- if (minCapacity < used) {
- minCapacity = used;
- } else if (minCapacity < buffer.length * 2 + 2) {
- minCapacity = buffer.length * 2 + 2;
- }
-
- // Allocate a new buffer and copy data over
- char[] newBuffer = new char[minCapacity];
- System.arraycopy(buffer, 0, newBuffer, 0, used);
- buffer = newBuffer;
- isStringized = false;
- return true;
-}
-
-public synchronized void getChars(int srcBegin, int srcEnd,
- char dst[], int dstBegin) {
- if (srcEnd > used)
- throw new StringIndexOutOfBoundsException();
- System.arraycopy(buffer, srcBegin, dst, dstBegin, srcEnd - srcBegin);
-}
-
-public synchronized StringBuffer insert(int offset, Object obj) {
- return insert(offset, String.valueOf(obj));
-}
-
-public synchronized StringBuffer insert(int offset, String str) {
- if (str == null) {
- str = "null";
- }
- return insert(offset, str.value, str.offset, str.count);
-}
-
-public StringBuffer insert(int offset, boolean b) {
- return insert(offset, String.valueOf(b));
-}
-
-public synchronized StringBuffer insert(int offset, char c) {
- return insert(offset, new char[] { c }, 0, 1);
-}
-
-public StringBuffer insert(int offset, char[] str) {
- checkIndex(offset);
- return insert(offset, str, 0, str.length);
-}
-
-public synchronized StringBuffer insert(int index, char[] str,
- int offset, int len) {
- checkIndex(index);
- if (offset < 0 || len < 0 || offset + len > str.length) {
- throw new StringIndexOutOfBoundsException();
- }
- if (used + len > buffer.length || isStringized) // optimization
- ensureCapacity(used + len, isStringized);
-
- // Shift buffer rightward to make space
- System.arraycopy(buffer, index, buffer, index + len, used - index);
-
- // Copy inserted chars into place
- System.arraycopy(str, offset, buffer, index, len);
-
- // Update used count
- used += len;
- return this;
-}
-
-public StringBuffer insert(int offset, double d) {
- return insert(offset, String.valueOf(d));
-}
-
-public StringBuffer insert(int offset, float f) {
- return insert(offset, String.valueOf(f));
-}
-
-public StringBuffer insert(int offset, int i) {
- return insert(offset, String.valueOf(i));
-}
-
-public StringBuffer insert(int offset, long l) {
- return insert(offset, String.valueOf(l));
-}
-
-public int length () {
- return used;
-}
-
-public synchronized StringBuffer reverse() {
- if (isStringized) // optimization
- ensureCapacity(used, true);
- for (int pos = used/2 - 1; pos >= 0; pos--) {
- char ch = buffer[pos];
- buffer[pos] = buffer[used - pos - 1];
- buffer[used - pos - 1] = ch;
- }
- return this;
-}
-
-public synchronized void setCharAt(int index, char ch) {
- checkIndex(index);
- if (isStringized) // optimization
- ensureCapacity(used, true);
- buffer[index] = ch;
-}
-
-public synchronized void setLength(int newLength) {
- if (newLength < 0) {
- throw new StringIndexOutOfBoundsException();
- }
- boolean newBuf = ensureCapacity(newLength, isStringized);
- if (!newBuf && newLength > used) {
- for (int index = used; index < newLength; index++)
- buffer[index] = '\0';
- }
- used = newLength;
-}
-
-public String toString() {
- // String constructor will be responsible for setting isStringized
- return new String(this);
-}
+/**
+ * <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. It is thread-safe; meaning that all modifications to a buffer
+ * are in synchronized methods.
+ *
+ * <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, compilers often implement the String operator "+"
+ * by using a <code>StringBuffer</code> operation:<br>
+ * <code>a + b</code><br>
+ * is the same as<br>
+ * <code>new StringBuffer().append(a).append(b).toString()</code>.
+ *
+ * <p>Classpath's StringBuffer is capable of sharing memory with Strings for
+ * efficiency. This will help when a StringBuffer is converted to a String
+ * and the StringBuffer is not changed after that (quite common when performing
+ * string concatenation).
+ *
+ * @author Paul Fisher
+ * @author John Keiser
+ * @author Tom Tromey
+ * @author Eric Blake <ebb9 at email.byu.edu>
+ * @see String
+ * @since 1.0
+ * @status updated to 1.4
+ */
+public final class StringBuffer implements Serializable, CharSequence
+{
+ /**
+ * Compatible with JDK 1.0+.
+ */
+ private static final long serialVersionUID = 3388685877147921107L;
+
+ /**
+ * Index of next available character (and thus the size of the current
+ * string contents). Note that this has permissions set this way so that
+ * String can get the value.
+ *
+ * @serial the number of characters in the buffer
+ */
+ int count;
+
+ /**
+ * The buffer. Note that this has permissions set this way so that String
+ * can get the value.
+ *
+ * @serial the buffer
+ */
+ char[] value;
+
+ /**
+ * True if the buffer is shared with another object (StringBuffer or
+ * String); this means the buffer must be copied before writing to it again.
+ * Note that this has permissions set this way so that String can get the
+ * value.
+ *
+ * @serial whether the buffer is shared
+ */
+ boolean shared;
+
+ /**
+ * The default capacity of a buffer.
+ */
+ private final static int DEFAULT_CAPACITY = 16;
+
+ /**
+ * Create a new StringBuffer with default capacity 16.
+ */
+ public StringBuffer()
+ {
+ this(DEFAULT_CAPACITY);
+ }
+
+ /**
+ * Create an empty <code>StringBuffer</code> with the specified initial
+ * capacity.
+ *
+ * @param capacity the initial capacity
+ * @throws NegativeArraySizeException if capacity is negative
+ */
+ public StringBuffer(int capacity)
+ {
+ value = new char[capacity];
+ }
+
+ /**
+ * 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 convert
+ * @throws NullPointerException if str is null
+ */
+ public StringBuffer(String str)
+ {
+ // Unfortunately, because the size is 16 larger, we cannot share.
+ count = str.count;
+ value = new char[count + DEFAULT_CAPACITY];
+ str.getChars(0, count, value, 0);
+ }
+
+ /**
+ * 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 synchronized int length()
+ {
+ return count;
+ }
+
+ /**
+ * 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 synchronized int capacity()
+ {
+ return value.length;
+ }
+
+ /**
+ * 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. The buffer is grown to the
+ * larger of <code>minimumCapacity</code> and
+ * <code>capacity() * 2 + 2</code>, if it is not already large enough.
+ *
+ * @param minimumCapacity the new capacity
+ * @see #capacity()
+ */
+ public synchronized void ensureCapacity(int minimumCapacity)
+ {
+ ensureCapacity_unsynchronized(minimumCapacity);
+ }
+
+ /**
+ * Set the length of this StringBuffer. If the new length is greater than
+ * the current length, all the new characters are set to '\0'. If the new
+ * length is less than the current length, the first <code>newLength</code>
+ * characters of the old array will be preserved, and the remaining
+ * characters are truncated.
+ *
+ * @param newLength the new length
+ * @throws IndexOutOfBoundsException if the new length is negative
+ * (while unspecified, this is a StringIndexOutOfBoundsException)
+ * @see #length()
+ */
+ public synchronized void setLength(int newLength)
+ {
+ if (newLength < 0)
+ throw new StringIndexOutOfBoundsException(newLength);
+
+ ensureCapacity_unsynchronized(newLength);
+ while (count < newLength)
+ value[count++] = '\0';
+ count = newLength;
+ }
+
+ /**
+ * 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
+ * @throws IndexOutOfBoundsException if index is negative or >= length()
+ * (while unspecified, this is a StringIndexOutOfBoundsException)
+ */
+ public synchronized char charAt(int index)
+ {
+ if (index < 0 || index >= count)
+ throw new StringIndexOutOfBoundsException(index);
+ return value[index];
+ }
+
+ /**
+ * Get the specified array of characters. <code>srcOffset - srcEnd</code>
+ * characters will be copied into the array you pass in.
+ *
+ * @param srcOffset the index to start copying from (inclusive)
+ * @param srcEnd the index to stop copying from (exclusive)
+ * @param dst the array to copy into
+ * @param dstOffset the index to start copying into
+ * @throws NullPointerException if dst is null
+ * @throws IndexOutOfBoundsException if any source or target indices are
+ * out of range (while unspecified, source problems cause a
+ * StringIndexOutOfBoundsException, and dest problems cause an
+ * ArrayIndexOutOfBoundsException)
+ * @see System#arraycopy(Object, int, Object, int, int)
+ */
+ public synchronized void getChars(int srcOffset, int srcEnd,
+ char[] dst, int dstOffset)
+ {
+ int todo = srcEnd - srcOffset;
+ if (srcOffset < 0 || srcEnd > count || todo < 0)
+ throw new StringIndexOutOfBoundsException();
+ System.arraycopy(value, srcOffset, dst, dstOffset, todo);
+ }
+
+ /**
+ * 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
+ * @throws IndexOutOfBoundsException if index is negative or >= length()
+ * (while unspecified, this is a StringIndexOutOfBoundsException)
+ */
+ public synchronized 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;
+ }
+
+ /**
+ * 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 String#valueOf(Object)
+ * @see #append(String)
+ */
+ public StringBuffer append(Object obj)
+ {
+ return append(obj == null ? "null" : obj.toString());
+ }
+
+ /**
+ * Append the <code>String</code> to this <code>StringBuffer</code>. If
+ * str is null, the String "null" is appended.
+ *
+ * @param str the <code>String</code> to append
+ * @return this <code>StringBuffer</code>
+ */
+ public synchronized StringBuffer append(String str)
+ {
+ if (str == null)
+ str = "null";
+ int len = str.count;
+ ensureCapacity_unsynchronized(count + len);
+ str.getChars(0, len, value, count);
+ count += len;
+ return this;
+ }
+
+ /**
+ * Append the <code>StringBuffer</code> value of the argument to this
+ * <code>StringBuffer</code>. This behaves the same as
+ * <code>append((Object) stringBuffer)</code>, except it is more efficient.
+ *
+ * @param stringBuffer the <code>StringBuffer</code> to convert and append
+ * @return this <code>StringBuffer</code>
+ * @see #append(Object)
+ * @since 1.4
+ */
+ public synchronized StringBuffer append(StringBuffer stringBuffer)
+ {
+ if (stringBuffer == null)
+ return append("null");
+ synchronized (stringBuffer)
+ {
+ int len = stringBuffer.count;
+ ensureCapacity_unsynchronized(count + len);
+ System.arraycopy(stringBuffer.value, 0, value, count, len);
+ count += len;
+ }
+ return this;
+ }
+
+ /**
+ * Append the <code>char</code> array to this <code>StringBuffer</code>.
+ * This is similar (but more efficient) than
+ * <code>append(new String(data))</code>, except in the case of null.
+ *
+ * @param data the <code>char[]</code> to append
+ * @return this <code>StringBuffer</code>
+ * @throws NullPointerException if <code>str</code> is <code>null</code>
+ * @see #append(char[], int, int)
+ */
+ public StringBuffer append(char[] data)
+ {
+ return append(data, 0, data.length);
+ }
+
+ /**
+ * Append part of the <code>char</code> array to this
+ * <code>StringBuffer</code>. This is similar (but more efficient) than
+ * <code>append(new String(data, offset, count))</code>, except in the case
+ * of null.
+ *
+ * @param data the <code>char[]</code> to append
+ * @param offset the start location in <code>str</code>
+ * @param count the number of characters to get from <code>str</code>
+ * @return this <code>StringBuffer</code>
+ * @throws NullPointerException if <code>str</code> is <code>null</code>
+ * @throws IndexOutOfBoundsException if offset or count is out of range
+ * (while unspecified, this is a StringIndexOutOfBoundsException)
+ */
+ public synchronized 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;
+ }
+
+ /**
+ * 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 String#valueOf(boolean)
+ */
+ public StringBuffer append(boolean bool)
+ {
+ return append(bool ? "true" : "false");
+ }
+
+ /**
+ * Append the <code>char</code> to this <code>StringBuffer</code>.
+ *
+ * @param c the <code>char</code> to append
+ * @return this <code>StringBuffer</code>
+ */
+ public synchronized 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 String#valueOf(int)
+ */
+ // This is native in libgcj, for efficiency.
+ public StringBuffer append(int inum)
+ {
+ return append(String.valueOf(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 String#valueOf(long)
+ */
+ public StringBuffer append(long lnum)
+ {
+ return append(Long.toString(lnum, 10));
+ }
+
+ /**
+ * 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 String#valueOf(float)
+ */
+ public StringBuffer append(float fnum)
+ {
+ return append(Float.toString(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 String#valueOf(double)
+ */
+ public StringBuffer append(double dnum)
+ {
+ return append(Double.toString(dnum));
+ }
+
+ /**
+ * Delete characters from this <code>StringBuffer</code>.
+ * <code>delete(10, 12)</code> will delete 10 and 11, but not 12. It is
+ * harmless for end to be larger than length().
+ *
+ * @param start the first character to delete
+ * @param end the index after the last character to delete
+ * @return this <code>StringBuffer</code>
+ * @throws StringIndexOutOfBoundsException if start or end are out of bounds
+ * @since 1.2
+ */
+ public synchronized 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>
+ * @throws StringIndexOutOfBoundsException if index is out of bounds
+ * @since 1.2
+ */
+ public StringBuffer deleteCharAt(int index)
+ {
+ return delete(index, index + 1);
+ }
+
+ /**
+ * 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>
+ * @throws StringIndexOutOfBoundsException if start or end are out of bounds
+ * @throws NullPointerException if str is null
+ * @since 1.2
+ */
+ public synchronized StringBuffer replace(int start, int end, String str)
+ {
+ if (start < 0 || start > count || start > end)
+ throw new StringIndexOutOfBoundsException(start);
+
+ int len = str.count;
+ // 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;
+ }
+
+ /**
+ * 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
+ * @throws StringIndexOutOfBoundsException if beginIndex is out of bounds
+ * @see #substring(int, int)
+ * @since 1.2
+ */
+ 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. This is implemented
+ * the same as <code>substring(beginIndex, endIndex)</code>, to satisfy
+ * the CharSequence interface.
+ *
+ * @param beginIndex index to start at (inclusive, base 0)
+ * @param endIndex index to end at (exclusive)
+ * @return new String which is a substring of this StringBuffer
+ * @throws IndexOutOfBoundsException if beginIndex or endIndex is out of
+ * bounds
+ * @see #substring(int, int)
+ * @since 1.4
+ */
+ public CharSequence subSequence(int beginIndex, int endIndex)
+ {
+ return substring(beginIndex, endIndex);
+ }
+
+ /**
+ * 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 at (inclusive, base 0)
+ * @param endIndex index to end at (exclusive)
+ * @return new String which is a substring of this StringBuffer
+ * @throws StringIndexOutOfBoundsException if beginIndex or endIndex is out
+ * of bounds
+ * @since 1.2
+ */
+ public synchronized String substring(int beginIndex, int endIndex)
+ {
+ int len = endIndex - beginIndex;
+ if (beginIndex < 0 || endIndex > count || len < 0)
+ throw new StringIndexOutOfBoundsException();
+ if (len == 0)
+ return "";
+ // Share the char[] unless 3/4 empty.
+ shared = (len << 2) >= value.length;
+ // Package constructor avoids an array copy.
+ return new String(value, beginIndex, len, shared);
+ }
+
+ /**
+ * Insert a subarray of the <code>char[]</code> argument into this
+ * <code>StringBuffer</code>.
+ *
+ * @param offset the place to insert in this buffer
+ * @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>
+ * @throws NullPointerException if <code>str</code> is <code>null</code>
+ * @throws StringIndexOutOfBoundsException if any index is out of bounds
+ * @since 1.2
+ */
+ public synchronized StringBuffer insert(int offset,
*** Patch too long, truncated ***
More information about the kaffe
mailing list