Skip to content

R
riscv-gcc-1
Commit ce1bb3bb by Eric Blake Committed by Tom Tromey
Options

natStringBuffer.cc (regionMatches): New function. 

2003-03-23  Eric Blake  <ebb9@email.byu.edu>

	* java/lang/natStringBuffer.cc (regionMatches): New function.
	* java/lang/String.java (count): Now package-private.
	* java/lang/StringBuffer.java: Merged with Classpath.

From-SVN: r64770
parent fc3703e3
Showing with 696 additions and 505 deletions
libjava/ChangeLog
2003-03-23 Eric Blake <ebb9@email.byu.edu>
* java/lang/natStringBuffer.cc (regionMatches): New function.
* java/lang/String.java (count): Now package-private.
* java/lang/StringBuffer.java: Merged with Classpath.
2003-03-23 Michael Koch <konqueror@gmx.de> 2003-03-23 Michael Koch <konqueror@gmx.de>
* java/io/BufferedOutputStream.java: * java/io/BufferedOutputStream.java:
......
libjava/java/lang/String.java
/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj. This file is part of libgcj.
...@@ -26,7 +26,7 @@ public final class String implements Serializable, Comparable, CharSequence ...@@ -26,7 +26,7 @@ public final class String implements Serializable, Comparable, CharSequence
{ {
private Object data; private Object data;
private int boffset; // Note this is a byte offset - don't use in Java code! private int boffset; // Note this is a byte offset - don't use in Java code!
private int count; int count;
// This is probably not necessary because this class is special cased already // This is probably not necessary because this class is special cased already
// but it will avoid showing up as a discrepancy when comparing SUIDs. // but it will avoid showing up as a discrepancy when comparing SUIDs.
......
libjava/java/lang/StringBuffer.java
/* StringBuffer.java -- Growable strings /* StringBuffer.java -- Growable strings
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -36,276 +36,194 @@ obligated to do so. If you do not wish to do so, delete this ...@@ -36,276 +36,194 @@ obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */ exception statement from your version. */
package java.lang; package java.lang;
import java.io.Serializable;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 import java.io.Serializable;
* 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>. * <code>StringBuffer</code> represents a changeable <code>String</code>.
* It provides the operations required to modify the * It provides the operations required to modify the
* <code>StringBuffer</code> including insert, replace, delete, append, * <code>StringBuffer</code>, including insert, replace, delete, append,
* and reverse. * and reverse. It is thread-safe; meaning that all modifications to a buffer
* <P> * are in synchronized methods.
* *
* <code>StringBuffer</code>s are variable-length in nature, so even if * <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 * you initialize them to a certain size, they can still grow larger than
* that. <EM>Capacity</EM> indicates the number of characters the * that. <em>Capacity</em> indicates the number of characters the
* <code>StringBuffer</code> can have in it before it has to grow (growing * <code>StringBuffer</code> can have in it before it has to grow (growing
* the char array is an expensive operation involving <code>new</code>). * the char array is an expensive operation involving <code>new</code>).
* <P>
* *
* Incidentally, the String operator "+" actually is turned into a * <p>Incidentally, compilers often implement the String operator "+"
* <code>StringBuffer</code> operation: * by using a <code>StringBuffer</code> operation:<br>
* <BR> * <code>a + b</code><br>
* <code>a + b</code> * is the same as<br>
* <BR> * <code>new StringBuffer().append(a).append(b).toString()</code>.
* is the same as
* <BR>
* <code>new StringBuffer(a).append(b).toString()</code>.
* *
* @implnote Classpath's StringBuffer is capable of sharing memory with * <p>Classpath's StringBuffer is capable of sharing memory with Strings for
* Strings for efficiency. This will help in two instances: * efficiency. This will help when a StringBuffer is converted to a String
* first, when a StringBuffer is created from a String but is * and the StringBuffer is not changed after that (quite common when performing
* never changed, and second, when a StringBuffer is converted * string concatenation).
* to a String and the StringBuffer is not changed after that.
* *
* @since JDK1.0
* @author Paul Fisher * @author Paul Fisher
* @author John Keiser * @author John Keiser
* @author Tom Tromey * @author Tom Tromey
* @see java.lang.String * @author Eric Blake <ebb9@email.byu.edu>
* @see String
* @since 1.0
* @status updated to 1.4
*/ */
public final class StringBuffer implements Serializable, CharSequence 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 * Compatible with JDK 1.0+.
* <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) private static final long serialVersionUID = 3388685877147921107L;
{
return append (String.valueOf(bool));
}
/** Append the <code>char</code> to this <code>StringBuffer</code>. /**
* @param c the <code>char</code> to append. * Index of next available character (and thus the size of the current
* @return this <code>StringBuffer</code>. * 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
*/ */
public synchronized StringBuffer append (char ch) int count;
{
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 * The buffer. Note that this has permissions set this way so that String
* <code>String</code>. * can get the value.
* @param inum the <code>int</code> to convert and append. *
* @return this <code>StringBuffer</code>. * @serial the buffer
* @see java.lang.String#valueOf(int)
*/ */
public native StringBuffer append (int inum); char[] value;
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>. /**
* Uses <code>String.valueOf()</code> to convert to * True if the buffer is shared with another object (StringBuffer or
* <code>String</code>. * String); this means the buffer must be copied before writing to it again.
* @param lnum the <code>long</code> to convert and append. * Note that this has permissions set this way so that String can get the
* @return this <code>StringBuffer</code>. * value.
* @see java.lang.String#valueOf(long) *
* @serial whether the buffer is shared
*/ */
public StringBuffer append (long lnum) boolean shared;
{
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 * The default capacity of a buffer.
* <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) private final static int DEFAULT_CAPACITY = 16;
{
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 * Create a new StringBuffer with default capacity 16.
* <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) public StringBuffer()
{ {
return append (String.valueOf(dnum)); this(DEFAULT_CAPACITY);
} }
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>. /**
* Uses <code>String.valueOf()</code> to convert to * Create an empty <code>StringBuffer</code> with the specified initial
* <code>String</code>. * capacity.
* @param obj the <code>Object</code> to convert and append. *
* @return this <code>StringBuffer</code>. * @param capacity the initial capacity
* @see java.lang.String#valueOf(java.lang.Object) * @throws NegativeArraySizeException if capacity is negative
*/ */
public StringBuffer append (Object obj) public StringBuffer(int capacity)
{ {
return append (String.valueOf(obj)); value = new char[capacity];
} }
/** Append the <code>String</code> to this <code>StringBuffer</code>. /**
* @param str the <code>String</code> to append. * Create a new <code>StringBuffer</code> with the characters in the
* @return this <code>StringBuffer</code>. * 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 synchronized StringBuffer append (String str) public StringBuffer(String str)
{ {
if (str == null) // Unfortunately, because the size is 16 larger, we cannot share.
str = "null"; count = str.count;
int len = str.length(); value = new char[count + DEFAULT_CAPACITY];
ensureCapacity_unsynchronized (count + len); str.getChars(0, count, value, 0);
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. * Get the length of the <code>String</code> this <code>StringBuffer</code>
* @return this <code>StringBuffer</code>. * would create. Not to be confused with the <em>capacity</em> of the
* @exception NullPointerException if <code>str</code> is <code>null</code>. * <code>StringBuffer</code>.
*
* @return the length of this <code>StringBuffer</code>
* @see #capacity()
* @see #setLength(int)
*/ */
public StringBuffer append (char[] data) public synchronized int length()
{ {
return append (data, 0, data.length); return count;
} }
/** Append the <code>char</code> array to this <code>StringBuffer</code>. /**
* @param data the <code>char[]</code> to append. * Get the total number of characters this <code>StringBuffer</code> can
* @param offset the place to start grabbing characters from * support before it must be grown. Not to be confused with <em>length</em>.
* <code>str</code>. *
* @param count the number of characters to get from <code>str</code>. * @return the capacity of this <code>StringBuffer</code>
* @return this <code>StringBuffer</code>. * @see #length()
* @exception NullPointerException if <code>str</code> is <code>null</code>. * @see #ensureCapacity(int)
* @exception IndexOutOfBoundsException if <code>offset</code> or
* <code>offset+len</code> is out of range.
*/
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;
}
/** 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 () public synchronized int capacity()
{ {
return value.length; return value.length;
} }
/** Get the character at the specified index. /**
* @param index the index of the character to get, starting at 0. * Increase the capacity of this <code>StringBuffer</code>. This will
* @return the character at the specified index. * ensure that an expensive growing operation will not occur until
* @exception IndexOutOfBoundsException if the desired character index * <code>minimumCapacity</code> is reached. The buffer is grown to the
* is negative or greater then length() - 1. * 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 char charAt (int index) public synchronized void ensureCapacity(int minimumCapacity)
{ {
if (index >= count) ensureCapacity_unsynchronized(minimumCapacity);
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. * Set the length of this StringBuffer. If the new length is greater than
* @param start the first character to delete. * the current length, all the new characters are set to '\0'. If the new
* @param end the index after the last character to delete. * length is less than the current length, the first <code>newLength</code>
* @return this <code>StringBuffer</code>. * characters of the old array will be preserved, and the remaining
* @exception StringIndexOutOfBoundsException if <code>start</code> * characters are truncated.
* or <code>end-1</code> are out of bounds, or if *
* <code>start > end</code>. * @param newLength the new length
* @throws IndexOutOfBoundsException if the new length is negative
* (while unspecified, this is a StringIndexOutOfBoundsException)
* @see #length()
*/ */
public synchronized StringBuffer delete (int start, int end) public synchronized void setLength(int newLength)
{ {
if (start < 0 || start > count || start > end) if (newLength < 0)
throw new StringIndexOutOfBoundsException (start); throw new StringIndexOutOfBoundsException(newLength);
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>. ensureCapacity_unsynchronized(newLength);
* @param index the index of the character to delete. while (count < newLength)
* @return this <code>StringBuffer</code>. value[count++] = '\0';
* @exception StringIndexOutOfBoundsException if <code>index</code> count = newLength;
* 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 * Get the character at the specified index.
* until <code>minimumCapacity</code> is reached. *
* If the capacity is actually already greater than <code>minimumCapacity</code> * @param index the index of the character to get, starting at 0
* @param minimumCapacity the new capacity. * @return the character at the specified index
* @see #capacity() * @throws IndexOutOfBoundsException if index is negative or &gt;= length()
* (while unspecified, this is a StringIndexOutOfBoundsException)
*/ */
public synchronized void ensureCapacity (int minimumCapacity) public synchronized char charAt(int index)
{ {
if (shared || minimumCapacity > value.length) if (index < 0 || index >= count)
{ throw new StringIndexOutOfBoundsException(index);
// We don't want to make a larger vector when `shared' is return value[index];
// 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;
}
} }
/** /**
...@@ -332,397 +250,652 @@ public final class StringBuffer implements Serializable, CharSequence ...@@ -332,397 +250,652 @@ public final class StringBuffer implements Serializable, CharSequence
System.arraycopy(value, srcOffset, dst, dstOffset, todo); 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 * Set the character at the specified index.
* <code>String</code>. *
* @param offset the place to insert. * @param index the index of the character to set starting at 0
* @param bool the <code>boolean</code> to convert and insert. * @param ch the value to set that character to
* @return this <code>StringBuffer</code>. * @throws IndexOutOfBoundsException if index is negative or &gt;= length()
* @exception IndexOutOfBoundsException if <code>offset</code> is out * (while unspecified, this is a StringIndexOutOfBoundsException)
* of range for this <code>StringBuffer</code>.
* @see java.lang.String#valueOf(boolean)
*/ */
public StringBuffer insert (int offset, boolean bool) public synchronized void setCharAt(int index, char ch)
{ {
return insert (offset, bool ? "true" : "false"); if (index < 0 || index >= count)
throw new StringIndexOutOfBoundsException(index);
// Call ensureCapacity to enforce copy-on-write.
ensureCapacity_unsynchronized(count);
value[index] = ch;
} }
/** Insert the <code>char</code> argument into this <code>StringBuffer</code>. /**
* @param offset the place to insert. * Append the <code>String</code> value of the argument to this
* @param ch the <code>char</code> to insert. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* @return this <code>StringBuffer</code>. * to <code>String</code>.
* @exception IndexOutOfBoundsException if <code>offset</code> is out *
* of range for this <code>StringBuffer</code>. * @param obj the <code>Object</code> to convert and append
* @return this <code>StringBuffer</code>
* @see String#valueOf(Object)
* @see #append(String)
*/ */
public synchronized StringBuffer insert (int offset, char ch) public StringBuffer append(Object obj)
{ {
if (offset < 0 || offset > count) return append(obj == null ? "null" : obj.toString());
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 * Append the <code>String</code> to this <code>StringBuffer</code>. If
* <code>String</code>. * str is null, the String "null" is appended.
* @param offset the place to insert. *
* @param inum the <code>int</code> to convert and insert. * @param str the <code>String</code> to append
* @return this <code>StringBuffer</code>. * @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) public synchronized StringBuffer append(String str)
{ {
return insert (offset, String.valueOf(inum)); if (str == null)
str = "null";
int len = str.count;
ensureCapacity_unsynchronized(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
} }
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>. /**
* Uses <code>String.valueOf()</code> to convert to * Append the <code>StringBuffer</code> value of the argument to this
* <code>String</code>. * <code>StringBuffer</code>. This behaves the same as
* @param offset the place to insert. * <code>append((Object) stringBuffer)</code>, except it is more efficient.
* @param lnum the <code>long</code> to convert and insert. *
* @return this <code>StringBuffer</code>. * @param stringBuffer the <code>StringBuffer</code> to convert and append
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @return this <code>StringBuffer</code>
* of range for this <code>StringBuffer</code>. * @see #append(Object)
* @see java.lang.String#valueOf(long) * @since 1.4
*/ */
public StringBuffer insert (int offset, long lnum) public synchronized StringBuffer append(StringBuffer stringBuffer)
{ {
return insert (offset, String.valueOf(lnum)); 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;
} }
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>. /**
* Uses <code>String.valueOf()</code> to convert to * Append the <code>char</code> array to this <code>StringBuffer</code>.
* <code>String</code>. * This is similar (but more efficient) than
* @param offset the place to insert. * <code>append(new String(data))</code>, except in the case of null.
* @param fnum the <code>float</code> to convert and insert. *
* @return this <code>StringBuffer</code>. * @param data the <code>char[]</code> to append
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @return this <code>StringBuffer</code>
* of range for this <code>StringBuffer</code>. * @throws NullPointerException if <code>str</code> is <code>null</code>
* @see java.lang.String#valueOf(float) * @see #append(char[], int, int)
*/ */
public StringBuffer insert (int offset, float fnum) public StringBuffer append(char[] data)
{ {
return insert (offset, String.valueOf(fnum)); return append(data, 0, data.length);
} }
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>. /**
* Uses <code>String.valueOf()</code> to convert to * Append part of the <code>char</code> array to this
* <code>String</code>. * <code>StringBuffer</code>. This is similar (but more efficient) than
* @param offset the place to insert. * <code>append(new String(data, offset, count))</code>, except in the case
* @param dnum the <code>double</code> to convert and insert. * of null.
* @return this <code>StringBuffer</code>. *
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @param data the <code>char[]</code> to append
* of range for this <code>StringBuffer</code>. * @param offset the start location in <code>str</code>
* @see java.lang.String#valueOf(double) * @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 StringBuffer insert (int offset, double dnum) public synchronized StringBuffer append(char[] data, int offset, int count)
{ {
return insert (offset, String.valueOf(dnum)); ensureCapacity_unsynchronized(this.count + count);
System.arraycopy(data, offset, value, this.count, count);
this.count += 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 * Append the <code>String</code> value of the argument to this
* <code>String</code>. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* @param offset the place to insert. * to <code>String</code>.
* @param obj the <code>Object</code> to convert and insert. *
* @return this <code>StringBuffer</code>. * @param bool the <code>boolean</code> to convert and append
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @return this <code>StringBuffer</code>
* of range for this <code>StringBuffer</code>. * @see String#valueOf(boolean)
* @see java.lang.String#valueOf(java.lang.Object)
*/ */
public StringBuffer insert (int offset, Object obj) public StringBuffer append(boolean bool)
{ {
return insert (offset, String.valueOf(obj)); return append(bool ? "true" : "false");
} }
/** Insert the <code>String</code> argument into this <code>StringBuffer</code>. /**
* @param offset the place to insert. * Append the <code>char</code> to this <code>StringBuffer</code>.
* @param str the <code>String</code> to insert. *
* @return this <code>StringBuffer</code>. * @param c the <code>char</code> to append
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @return this <code>StringBuffer</code>
* of range for this <code>StringBuffer</code>.
*/ */
public synchronized StringBuffer insert (int offset, String str) public synchronized StringBuffer append(char ch)
{ {
if (offset < 0 || offset > count) ensureCapacity_unsynchronized(count + 1);
throw new StringIndexOutOfBoundsException (offset); value[count++] = ch;
// 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; return this;
} }
/** Insert the <code>char[]</code> argument into this /**
* <code>StringBuffer</code>. * Append the <code>String</code> value of the argument to this
* @param offset the place to insert. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* @param data the <code>char[]</code> to insert. * to <code>String</code>.
* @return this <code>StringBuffer</code>. *
* @exception NullPointerException if <code>data</code> is * @param inum the <code>int</code> to convert and append
* <code>null</code>. * @return this <code>StringBuffer</code>
* @exception IndexOutOfBoundsException if <code>offset</code> is out * @see String#valueOf(int)
* of range for this <code>StringBuffer</code>. */
*/ // GCJ LOCAL: this is native for efficiency.
public StringBuffer insert (int offset, char[] data) public native StringBuffer append (int inum);
{
// 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. * Append the <code>String</code> value of the argument to this
return insert (offset, data, 0, data == null ? 0 : data.length); * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
} * to <code>String</code>.
*
/** Insert the <code>char[]</code> argument into this * @param lnum the <code>long</code> to convert and append
* <code>StringBuffer</code>. * @return this <code>StringBuffer</code>
* @param offset the place to insert. * @see String#valueOf(long)
* @param str the <code>char[]</code> to insert. */
* @param str_offset the index in <code>str</code> to start inserting public StringBuffer append(long lnum)
* 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 synchronized StringBuffer insert(int offset, char[] str,
int str_offset, int len)
{ {
if (offset < 0 || offset > count) return append(Long.toString(lnum, 10));
throw new StringIndexOutOfBoundsException (offset); }
if (len < 0)
throw new StringIndexOutOfBoundsException (len); /**
if (str_offset < 0 || str_offset + len > str.length) * Append the <code>String</code> value of the argument to this
throw new StringIndexOutOfBoundsException (str_offset); * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
ensureCapacity_unsynchronized (count + len); * to <code>String</code>.
System.arraycopy(value, offset, value, offset + len, count - offset); *
System.arraycopy(str, str_offset, value, offset, len); * @param fnum the <code>float</code> to convert and append
count += len; * @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; return this;
} }
/** Get the length of the <code>String</code> this /**
* <code>StringBuffer</code> would create. Not to be confused with the * Delete a character from this <code>StringBuffer</code>.
* <em>capacity</em> of the <code>StringBuffer</code>. *
* @return the length of this <code>StringBuffer</code>. * @param index the index of the character to delete
* @see #capacity() * @return this <code>StringBuffer</code>
* @see #setLength(int) * @throws StringIndexOutOfBoundsException if index is out of bounds
* @since 1.2
*/ */
public int length () public StringBuffer deleteCharAt(int index)
{ {
return count; 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> * Replace characters between index <code>start</code> (inclusive) and
* is larger than the size of this StringBuffer, all characters after * <code>end</code> (exclusive) with <code>str</code>. If <code>end</code>
* <code>start</code> are replaced. * is larger than the size of this StringBuffer, all characters after
* @param start the beginning index of characters to delete (inclusive). * <code>start</code> are replaced.
* @param end the ending index of characters to delete (exclusive). *
* @param str the new <code>String</code> to insert. * @param start the beginning index of characters to delete (inclusive)
* @return this <code>StringBuffer</code>. * @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) public synchronized StringBuffer replace(int start, int end, String str)
{ {
if (start < 0 || start > count || start > end) if (start < 0 || start > count || start > end)
throw new StringIndexOutOfBoundsException (start); throw new StringIndexOutOfBoundsException(start);
int len = str.length(); int len = str.count;
// Calculate the difference in 'count' after the replace. // Calculate the difference in 'count' after the replace.
int delta = len - ((end > count ? count : end) - start); int delta = len - (end > count ? count : end) + start;
ensureCapacity_unsynchronized (count + delta); ensureCapacity_unsynchronized(count + delta);
if (delta != 0 && end < count) if (delta != 0 && end < count)
System.arraycopy(value, end, value, end + delta, count - end); System.arraycopy(value, end, value, end + delta, count - end);
str.getChars (0, len, value, start); str.getChars(0, len, value, start);
count += delta; count += delta;
return this; return this;
} }
/** Reverse the characters in this StringBuffer. /**
* @return this <code>StringBuffer</code>. * 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 synchronized StringBuffer reverse () public String substring(int beginIndex)
{ {
// Call ensureCapacity to enforce copy-on-write. return substring(beginIndex, count);
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. * Creates a substring of this StringBuffer, starting at a specified index
* @param ch the value to set that character to. * and ending at one character before a specified index. This is implemented
* @exception IndexOutOfBoundsException if the specified character * the same as <code>substring(beginIndex, endIndex)</code>, to satisfy
* index is not between 0 and length() - 1 (inclusive). * 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 synchronized void setCharAt (int index, char ch) public CharSequence subSequence(int beginIndex, int endIndex)
{ {
if (index < 0 || index >= count) return substring(beginIndex, endIndex);
throw new StringIndexOutOfBoundsException (index);
// Call ensureCapacity to enforce copy-on-write.
ensureCapacity_unsynchronized (count);
value[index] = ch;
} }
/** Set the length of this StringBuffer. /**
* <P> * Creates a substring of this StringBuffer, starting at a specified index
* If the new length is greater than the current length, all the new * and ending at one character before a specified index.
* characters are set to '\0'. *
* <P> * @param beginIndex index to start at (inclusive, base 0)
* If the new length is less than the current length, the first * @param endIndex index to end at (exclusive)
* <code>newLength</code> characters of the old array will be * @return new String which is a substring of this StringBuffer
* @param newLength the new length * @throws StringIndexOutOfBoundsException if beginIndex or endIndex is out
* @exception IndexOutOfBoundsException if the new length is * of bounds
* negative. * @since 1.2
* @see #length()
*/ */
public synchronized void setLength (int newLength) public synchronized String substring(int beginIndex, int endIndex)
{ {
if (newLength < 0) int len = endIndex - beginIndex;
throw new StringIndexOutOfBoundsException (newLength); 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);
}
ensureCapacity_unsynchronized (newLength); /**
for (int i = count; i < newLength; ++i) * Insert a subarray of the <code>char[]</code> argument into this
value[i] = '\0'; * <code>StringBuffer</code>.
count = newLength; *
* @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,
char[] str, int str_offset, int len)
{
if (offset < 0 || offset > count || len < 0
|| str_offset < 0 || str_offset + len > str.length)
throw new StringIndexOutOfBoundsException();
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;
} }
/** Create a new StringBuffer with default capacity 16. /**
* @see JLS 20.13.1 * 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 in this buffer
* @param obj the <code>Object</code> to convert and insert
* @return this <code>StringBuffer</code>
* @exception StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(Object)
*/ */
public StringBuffer () public StringBuffer insert(int offset, Object obj)
{ {
this (DEFAULT_CAPACITY); return insert(offset, obj == null ? "null" : obj.toString());
} }
/** Create an empty <code>StringBuffer</code> with the specified initial capacity. /**
* @param capacity the initial capacity. * Insert the <code>String</code> argument into this
* <code>StringBuffer</code>. If str is null, the String "null" is used
* instead.
*
* @param offset the place to insert in this buffer
* @param str the <code>String</code> to insert
* @return this <code>StringBuffer</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
*/ */
public StringBuffer (int capacity) public synchronized StringBuffer insert(int offset, String str)
{ {
count = 0; if (offset < 0 || offset > count)
value = new char[capacity]; throw new StringIndexOutOfBoundsException(offset);
shared = false; if (str == null)
str = "null";
int len = str.count;
ensureCapacity_unsynchronized(count + len);
System.arraycopy(value, offset, value, offset + len, count - offset);
str.getChars(0, len, value, offset);
count += len;
return this;
} }
/** 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. * Insert the <code>char[]</code> argument into this
* @param str the <code>String</code> to make a <code>StringBuffer</code> out of. * <code>StringBuffer</code>.
* @XXX optimize for sharing. *
* @param offset the place to insert in this buffer
* @param data the <code>char[]</code> to insert
* @return this <code>StringBuffer</code>
* @throws NullPointerException if <code>data</code> is <code>null</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see #insert(int, char[], int, int)
*/ */
public StringBuffer (String str) public StringBuffer insert(int offset, char[] data)
{ {
// The documentation is not clear, but experimentation with return insert(offset, data, 0, data.length);
// 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 * Insert the <code>String</code> value of the argument into this
* and ending at the end of this StringBuffer. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* to <code>String</code>.
* *
* @param beginIndex index to start substring (base 0) * @param offset the place to insert in this buffer
* * @param bool the <code>boolean</code> to convert and insert
* @return new String which is a substring of this StringBuffer * @return this <code>StringBuffer</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see 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>.
* *
* @exception StringIndexOutOfBoundsException * @param offset the place to insert in this buffer
* if (beginIndex < 0 || beginIndex > this.length()) * @param ch the <code>char</code> to insert
* @return this <code>StringBuffer</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
*/ */
public String substring (int beginIndex) public synchronized StringBuffer insert(int offset, char ch)
{ {
return substring (beginIndex, count); 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;
} }
/** /**
* Creates a substring of this StringBuffer, starting at a specified index * Insert the <code>String</code> value of the argument into this
* and ending at one character before a specified index. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* to <code>String</code>.
* *
* @param beginIndex index to start substring (base 0) * @param offset the place to insert in this buffer
* @param endIndex index after the last character to be * @param inum the <code>int</code> to convert and insert
* copied into the substring * @return this <code>StringBuffer</code>
* * @throws StringIndexOutOfBoundsException if offset is out of bounds
* @return new String which is a substring of this StringBuffer * @see 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>.
* *
* @exception StringIndexOutOfBoundsException * @param offset the place to insert in this buffer
* if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex) * @param lnum the <code>long</code> to convert and insert
* @return this <code>StringBuffer</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(long)
*/ */
public synchronized String substring (int beginIndex, int endIndex) public StringBuffer insert(int offset, long lnum)
{ {
if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) return insert(offset, Long.toString(lnum, 10));
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 * Insert the <code>String</code> value of the argument into this
* and ending at one character before a specified index. * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert
* <p> * to <code>String</code>.
* To implement <code>CharSequence</code>.
* Calls <code>substring(beginIndex, endIndex)</code>.
* *
* @param beginIndex index to start substring (base 0) * @param offset the place to insert in this buffer
* @param endIndex index after the last character to be * @param fnum the <code>float</code> to convert and insert
* copied into the substring * @return this <code>StringBuffer</code>
* * @throws StringIndexOutOfBoundsException if offset is out of bounds
* @return new String which is a substring of this StringBuffer * @see String#valueOf(float)
*/
public StringBuffer insert(int offset, float fnum)
{
return insert(offset, Float.toString(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>.
* *
* @exception StringIndexOutOfBoundsException * @param offset the place to insert in this buffer
* if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex) * @param dnum the <code>double</code> to convert and insert
* @return this <code>StringBuffer</code>
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(double)
*/ */
public CharSequence subSequence (int beginIndex, int endIndex) public StringBuffer insert(int offset, double dnum)
{ {
return substring(beginIndex, endIndex); return insert(offset, Double.toString(dnum));
} }
/**
* Finds the first instance of a substring in this StringBuffer.
*
* @param str String to find
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @see #indexOf(String, int)
* @since 1.4
*/
public int indexOf(String str)
{
return indexOf(str, 0);
}
/** Convert this <code>StringBuffer</code> to a <code>String</code>. /**
* @return the characters in this StringBuffer * Finds the first instance of a String in this StringBuffer, starting at
* a given index. If starting index is less than 0, the search starts at
* the beginning of this String. If the starting index is greater than the
* length of this String, or the substring is not found, -1 is returned.
*
* @param str String to find
* @param fromIndex index to start the search
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @since 1.4
*/ */
public String toString () public synchronized int indexOf(String str, int fromIndex)
{ {
// Note: in libgcj this causes the StringBuffer to be shared. In if (fromIndex < 0)
// Classpath it does not. fromIndex = 0;
return new String (this); int limit = count - str.count;
for ( ; fromIndex <= limit; fromIndex++)
if (regionMatches(fromIndex, str))
return fromIndex;
return -1;
} }
// Index of next available character. Note that this has /**
// permissions set this way so that String can get the value. * Finds the last instance of a substring in this StringBuffer.
int count; *
* @param str String to find
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @see #lastIndexOf(String, int)
* @since 1.4
*/
public int lastIndexOf(String str)
{
return lastIndexOf(str, count - str.count);
}
// The buffer. Note that this has permissions set this way so that /**
// String can get the value. * Finds the last instance of a String in this StringBuffer, starting at a
char[] value; * given index. If starting index is greater than the maximum valid index,
* then the search begins at the end of this String. If the starting index
* is less than zero, or the substring is not found, -1 is returned.
*
* @param str String to find
* @param fromIndex index to start the search
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @since 1.4
*/
public synchronized int lastIndexOf(String str, int fromIndex)
{
fromIndex = Math.min(fromIndex, count - str.count);
for ( ; fromIndex >= 0; fromIndex--)
if (regionMatches(fromIndex, str))
return fromIndex;
return -1;
}
// 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 * Reverse the characters in this StringBuffer. The same sequence of
// semantics make this less useful in that case, too. Note that * characters exists, but in the reverse index ordering.
// this has permissions set this way so that String can get the *
// value. * @return this <code>StringBuffer</code>
boolean shared; */
public synchronized StringBuffer reverse()
{
// Call ensureCapacity to enforce copy-on-write.
ensureCapacity_unsynchronized(count);
for (int i = count >> 1, j = count - i; --i >= 0; ++j)
{
char c = value[i];
value[i] = value[j];
value[j] = c;
}
return this;
}
/**
* Convert this <code>StringBuffer</code> to a <code>String</code>. The
* String is composed of the characters currently in this StringBuffer. Note
* that the result is a copy, and that future modifications to this buffer
* do not affect the String.
*
* @return the characters in this StringBuffer
*/
public String toString()
{
// The string will set this.shared = true.
return new String(this);
}
/**
* An unsynchronized version of ensureCapacity, used internally to avoid
* the cost of a second lock on the same object. This also has the side
* effect of duplicating the array, if it was shared (to form copy-on-write
* semantics).
*
* @param minimumCapacity the minimum capacity
* @see #ensureCapacity(int)
*/
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;
}
}
static final long serialVersionUID = 3388685877147921107L; /**
private final static int DEFAULT_CAPACITY = 16; // JLS 20.13.1 * Predicate which determines if a substring of this matches another String
* starting at a specified offset for each String and continuing for a
* specified length. This is more efficient than creating a String to call
* indexOf on.
*
* @param toffset index to start comparison at for this String
* @param other non-null String to compare to region of this
* @return true if regions match, false otherwise
* @see #indexOf(String, int)
* @see #lastIndexOf(String, int)
* @see String#regionMatches(boolean, int, String, int, int)
*/
// GCJ LOCAL: native for gcj.
private native boolean regionMatches(int toffset, String other);
} }
libjava/java/lang/natStringBuffer.cc
// natStringBuffer.cc - Implementation of java.lang.StringBuffer native methods. // natStringBuffer.cc - Implementation of java.lang.StringBuffer native methods.
/* Copyright (C) 2001 Free Software Foundation /* Copyright (C) 2001, 2003 Free Software Foundation
This file is part of libgcj. This file is part of libgcj.
...@@ -28,3 +28,15 @@ java::lang::StringBuffer::append (jint num) ...@@ -28,3 +28,15 @@ java::lang::StringBuffer::append (jint num)
count = needed; count = needed;
return this; return this;
} }
jboolean
java::lang::StringBuffer::regionMatches(jint toffset, jstring other)
{
jint len = other->count;
jchar *tptr = elements(value) + toffset;
jchar *optr = JvGetStringChars(other);
while (--len >= 0)
if (*tptr++ != *optr++)
return false;
return true;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment