From 50cc5dd29b71f5fcbe10cb424177ecc4d72e95d7 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Tue, 11 Dec 2001 18:01:40 +0000 Subject: String.java (String): New constructor. * java/lang/String.java (String): New constructor. * gnu/gcj/runtime/natStringBuffer.cc: New file. * gnu/gcj/runtime/StringBuffer.java: New file. * Makefile.in: Rebuilt. * Makefile.am (ordinary_java_source_files): Added gnu/gcj/runtime/StringBuffer.java. (nat_source_files): Added gnu/gcj/runtime/natStringBuffer.cc. From-SVN: r47883 --- libjava/gnu/gcj/runtime/StringBuffer.java | 188 ++++++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 libjava/gnu/gcj/runtime/StringBuffer.java (limited to 'libjava/gnu/gcj/runtime/StringBuffer.java') diff --git a/libjava/gnu/gcj/runtime/StringBuffer.java b/libjava/gnu/gcj/runtime/StringBuffer.java new file mode 100644 index 00000000000..403f952c951 --- /dev/null +++ b/libjava/gnu/gcj/runtime/StringBuffer.java @@ -0,0 +1,188 @@ +// This is a simplified 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; + +public final class StringBuffer +{ + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param bool the boolean to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(boolean) + */ + public StringBuffer append (boolean bool) + { + return append (bool ? "true" : "false"); + } + + /** Append the char to this StringBuffer. + * @param c the char to append. + * @return this StringBuffer. + */ + public StringBuffer append (char ch) + { + ensureCapacity_unsynchronized (count + 1); + value[count++] = ch; + return this; + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param inum the int to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(int) + */ + public native StringBuffer append (int inum); + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param lnum the long to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(long) + */ + public StringBuffer append (long lnum) + { + return append (Long.toString (lnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param fnum the float to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(float) + */ + public StringBuffer append (float fnum) + { + return append (Float.toString (fnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param dnum the double to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(double) + */ + public StringBuffer append (double dnum) + { + return append (Double.toString (dnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param obj the Object to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(java.lang.Object) + */ + public StringBuffer append (Object obj) + { + return append (String.valueOf(obj)); + } + + /** Append the String to this StringBuffer. + * @param str the String to append. + * @return this StringBuffer. + */ + 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; + } + + private void ensureCapacity_unsynchronized (int minimumCapacity) + { + if (minimumCapacity > value.length) + { + minimumCapacity = value.length * 2 + 2; + char[] nb = new char[minimumCapacity]; + System.arraycopy(value, 0, nb, 0, count); + value = nb; + } + } + + /** Create a new StringBuffer with default capacity 16. + * @see JLS 20.13.1 + */ + public StringBuffer () + { + this (DEFAULT_CAPACITY); + } + + /** Create an empty StringBuffer with the specified initial capacity. + * @param capacity the initial capacity. + */ + public StringBuffer (int capacity) + { + count = 0; + value = new char[capacity]; + } + + /** Create a new StringBuffer with the characters in the specified String. + * Initial capacity will be the size of the String plus 16. + * @param str the String to make a StringBuffer out of. + */ + public StringBuffer (String str) + { + if (str == null) + str = "null"; + 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); + } + + /** Convert this StringBuffer to a String. + * @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; + + private final static int DEFAULT_CAPACITY = 16; // JLS 20.13.1 +} -- cgit v1.2.3