deep-c-rsc/JCGO/goclsp/vm_str/java/lang/String.java

/*
 * @(#) $(JCGO)/goclsp/vm_str/java/lang/String.java --
 * Space-optimized implementation of the standard String class.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2008 Ivan Maidanski <ivmai@ivmaisoft.com>
 * All rights reserved.
 **
 * Class specification origin: GNU Classpath v0.93
 */

/*
 * This 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.
 **
 * This software 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 (GPL) for more details.
 **
 * 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;

import gnu.classpath.SystemProperties;

import gnu.java.lang.CharData;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;

import java.util.Comparator;
import java.util.Locale;

import java.util.regex.Pattern;

public final class String /* hard-coded class name */ /* const data */
 implements Serializable, Comparable, CharSequence
{

 private static final class CaseInsensitiveComparator
  implements Comparator, Serializable
 {

  private static final long serialVersionUID = 8575799808933029326L;

  CaseInsensitiveComparator() {}

  public int compare(Object o1, Object o2)
  {
   return ((String) o1).compareToIgnoreCase((String) o2);
  }
 }

 private static final long serialVersionUID = -6849794470754667710L;

 private static final char[] EMPTY_CHARS = {};

 private static final char[] upperExpand =
  zeroBasedStringValue(CharData.UPPER_EXPAND);

 private static final char[] upperSpecial =
  zeroBasedStringValue(CharData.UPPER_SPECIAL);

 public static final Comparator CASE_INSENSITIVE_ORDER =
  new CaseInsensitiveComparator();

 final Object value; /* hard-coded type and name */ /* const data */

 final int offset; /* hard-coded type and name */

 final int count; /* hard-coded type and name */

 private int cachedHashCode; /* hard-coded type and name */

 public String()
 {
  value = "".value;
  offset = 0;
  count = 0;
 }

 public String(String str)
 {
  value = str.value;
  offset = str.offset;
  count = str.count;
  cachedHashCode = str.cachedHashCode;
 }

 public String(char[] data)
 {
  int count = data.length;
  offset = 0;
  if (hasHighByte(data, 0, count))
   VMSystem.arraycopy(data, 0, value = new char[count], 0, count);
   else
   {
    byte[] newBytes = new byte[count];
    copyCharsToBytes(data, 0, newBytes, 0, count);
    value = newBytes;
   }
  this.count = count;
 }

 public String(char[] data, int offset, int count)
 {
  if ((offset | count) < 0 || data.length - offset < count)
   throw new StringIndexOutOfBoundsException();
  this.offset = 0;
  if (hasHighByte(data, offset, count))
   VMSystem.arraycopy(data, offset, value = new char[count], 0, count);
   else
   {
    byte[] newBytes = new byte[count];
    copyCharsToBytes(data, offset, newBytes, 0, count);
    value = newBytes;
   }
  this.count = count;
 }

/**
 * @deprecated
 */
 public String(byte[] data, int hibyte, int offset, int count)
 {
  if ((offset | count) < 0 || data.length - offset < count)
   throw new StringIndexOutOfBoundsException();
  this.offset = 0;
  this.count = count;
  if (hibyte != 0)
   value = createCharsFromBytes(data, offset, count, hibyte << 8);
   else
   {
    byte[] newBytes = new byte[count];
    VMSystem.arraycopy(data, offset, newBytes, 0, count);
    value = newBytes;
   }
 }

/**
 * @deprecated
 */
 public String(byte[] data, int hibyte)
 {
  int count = data.length;
  offset = 0;
  this.count = count;
  if (hibyte != 0)
   value = createCharsFromBytes(data, 0, count, hibyte << 8);
   else
   {
    byte[] newBytes = new byte[count];
    VMSystem.arraycopy(data, 0, newBytes, 0, count);
    value = newBytes;
   }
 }

 public String(byte[] data, int offset, int count, String encoding)
  throws UnsupportedEncodingException
 {
  CharBuffer cbuf = null;
  try
  {
   cbuf = decodeBytes(data, offset, count, encoding);
  }
  catch (CharacterCodingException e) {}
  catch (IllegalCharsetNameException e) {}
  catch (UnsupportedCharsetException e) {}
  if (cbuf == null)
   throw new UnsupportedEncodingException("Encoding not found: " + encoding);
  if (cbuf.hasArray())
  {
   value = cbuf.array();
   this.offset = cbuf.position();
   this.count = cbuf.remaining();
  }
   else
   {
    char[] newChars = new char[cbuf.remaining()];
    cbuf.get(newChars);
    value = newChars;
    this.offset = 0;
    this.count = newChars.length;
   }
 }

 public String(byte[] data, String encoding)
  throws UnsupportedEncodingException
 {
  this(data, 0, data.length, encoding);
 }

 public String(byte[] data, int offset, int count)
 {
  CharBuffer cbuf = null;
  try
  {
   cbuf = decodeBytes(data, offset, count,
           SystemProperties.getProperty("file.encoding"));
  }
  catch (CharacterCodingException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  catch (IllegalCharsetNameException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  catch (UnsupportedCharsetException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  if (cbuf.hasArray())
  {
   value = cbuf.array();
   this.offset = cbuf.position();
   this.count = cbuf.remaining();
  }
   else
   {
    char[] newChars = new char[cbuf.remaining()];
    cbuf.get(newChars);
    value = newChars;
    this.offset = 0;
    this.count = newChars.length;
   }
 }

 public String(byte[] data)
 {
  this(data, 0, data.length);
 }

 public String(StringBuffer buffer)
 {
  offset = 0;
  synchronized (buffer)
  {
   buffer.setShared();
   value = buffer.value();
   count = buffer.length();
  }
 }

 public String(StringBuilder buffer) /* hard-coded method signature */
 {
  offset = 0;
  buffer.setShared();
  value = buffer.value();
  count = buffer.length();
 }

 public String(int[] codePoints, int offset, int count)
 {
  if ((offset | count) < 0 || codePoints.length - offset < count)
   throw new IndexOutOfBoundsException();
  StringBuilder buffer = new StringBuilder(count);
  while (count-- > 0)
   buffer.appendCodePoint(codePoints[offset++]);
  this.offset = 0;
  buffer.setShared();
  value = buffer.value();
  this.count = buffer.length();
 }

 String(char[] data, int offset, int count, boolean dontCopy)
 {
  if (offset <= 0)
   offset = 0;
  if (count <= 0)
   count = 0;
  if (data.length - offset < count) /* hack */
  {
   offset = 0;
   count = data.length;
  }
  if (dontCopy)
  {
   value = data;
   this.offset = offset;
  }
   else
   {
    this.offset = 0;
    if (hasHighByte(data, offset, count))
     VMSystem.arraycopy(data, offset, value = new char[count], 0, count);
     else
     {
      byte[] newBytes = new byte[count];
      copyCharsToBytes(data, offset, newBytes, 0, count);
      value = newBytes;
     }
   }
  this.count = count;
 }

 public int length()
 {
  return count;
 }

 public char charAt(int index)
 {
  if (index < 0 || index >= count)
   throw new StringIndexOutOfBoundsException(index); /* hack */
  Object value = this.value;
  return value instanceof byte[] ?
          (char) (((byte[]) value)[offset + index] & 0xff) :
          ((char[]) value)[offset + index];
 }

 public void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)
 {
  if (((count - srcEnd) | srcBegin) < 0 || srcEnd < srcBegin)
   throw new StringIndexOutOfBoundsException();
  copyToChars(value, offset + srcBegin, dest, destBegin, srcEnd - srcBegin);
 }

/**
 * @deprecated
 */
 public void getBytes(int srcBegin, int srcEnd, byte[] dest, int destBegin)
 {
  if (((count - srcEnd) | srcBegin) < 0 || srcEnd < srcBegin)
   throw new StringIndexOutOfBoundsException();
  Object value = this.value;
  if (value instanceof byte[])
   VMSystem.arraycopy(value, offset + srcBegin, dest, destBegin,
    srcEnd - srcBegin);
   else copyCharsToBytes((char[]) value, offset + srcBegin, dest, destBegin,
         srcEnd - srcBegin);
 }

 public byte[] getBytes(String encoding)
  throws UnsupportedEncodingException
 {
  try
  {
   return encodeValue(value, offset, count, encoding);
  }
  catch (IllegalCharsetNameException e) {}
  catch (UnsupportedCharsetException e) {}
  catch (CharacterCodingException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  throw new UnsupportedEncodingException("Encoding not found: " + encoding);
 }

 public byte[] getBytes()
 {
  try
  {
   return encodeValue(value, offset, count,
           SystemProperties.getProperty("file.encoding"));
  }
  catch (CharacterCodingException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  catch (IllegalCharsetNameException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
  catch (UnsupportedCharsetException e)
  {
   throw (Error) (new InternalError()).initCause(e);
  }
 }

 public boolean equals(Object obj)
 {
  if (obj == this)
   return true;
  if (!(obj instanceof String))
   return false;
  String anotherString = (String) obj;
  int count = this.count;
  return anotherString.count == count && compareValues(value, offset,
          anotherString.value, anotherString.offset, count) == 0;
 }

 public boolean contentEquals(StringBuffer buffer)
 {
  int count = this.count;
  synchronized (buffer)
  {
   return buffer.length() == count &&
           compareValues(value, offset, buffer.value(), 0, count) == 0;
  }
 }

 public boolean contentEquals(CharSequence seq)
 {
  if (seq != this)
  {
   int count = this.count;
   if (seq.length() != count)
    return false;
   int offset = this.offset;
   Object value = this.value;
   if (value instanceof byte[])
   {
    byte[] bytes = (byte[]) value;
    for (int i = 0; i < count; i++)
     if ((bytes[offset + i] & 0xff) != seq.charAt(i))
      return false;
   }
    else
    {
     char[] chars = (char[]) value;
     for (int i = 0; i < count; i++)
      if (chars[offset + i] != seq.charAt(i))
       return false;
    }
  }
  return true;
 }

 public boolean equalsIgnoreCase(String anotherString)
 {
  int count = this.count;
  return anotherString != null && anotherString.count == count &&
          compareValuesIgnoreCase(value, offset, anotherString.value,
          anotherString.offset, count) == 0;
 }

 public int compareTo(String anotherString)
 {
  int count2 = anotherString.count;
  int count = this.count;
  int cmp = compareValues(value, offset, anotherString.value,
             anotherString.offset, count < count2 ? count : count2);
  if (cmp == 0)
   cmp = count - count2;
  return cmp;
 }

 public int compareTo(Object obj)
 {
  return compareTo((String) obj);
 }

 public int compareToIgnoreCase(String anotherString)
 {
  int count2 = anotherString.count;
  int count = this.count;
  int cmp = compareValuesIgnoreCase(value, offset, anotherString.value,
             anotherString.offset, count < count2 ? count : count2);
  if (cmp == 0)
   cmp = count - count2;
  return cmp;
 }

 public boolean regionMatches(int toffset, String other, int ooffset, int len)
 {
  return other.count - ooffset >= len && count - toffset >= len &&
          (toffset | ooffset) >= 0 && compareValues(value, offset + toffset,
          other.value, other.offset + ooffset, len) == 0;
 }

 public boolean regionMatches(boolean ignoreCase, int toffset, String other,
   int ooffset, int len)
 {
  return other.count - ooffset >= len && count - toffset >= len &&
          (toffset | ooffset) >= 0 && (ignoreCase ?
          compareValuesIgnoreCase(value, offset + toffset,
          other.value, other.offset + ooffset, len) :
          compareValues(value, offset + toffset,
          other.value, other.offset + ooffset, len)) == 0;
 }

 public boolean startsWith(String prefix, int toffset)
 {
  int count2 = prefix.count;
  return count - toffset >= count2 && toffset >= 0 && compareValues(value,
          offset + toffset, prefix.value, prefix.offset, count2) == 0;
 }

 public boolean startsWith(String prefix)
 {
  int count2 = prefix.count;
  return count >= count2 && compareValues(value, offset, prefix.value,
          prefix.offset, count2) == 0;
 }

 public boolean endsWith(String suffix)
 {
  int count2 = suffix.count;
  int toffset = count - count2;
  return toffset >= 0 && compareValues(value, offset + toffset, suffix.value,
          suffix.offset, count2) == 0;
 }

 public int hashCode()
 {
  int hashCode = cachedHashCode;
  if (hashCode == 0 &&
      (hashCode = hashCodeOfValue(value, offset, count)) != 0) /* hack */
   cachedHashCode = hashCode;
  return hashCode;
 }

 public int indexOf(int ch)
 {
  return indexOf(ch, 0);
 }

 public int indexOf(int ch, int fromIndex)
 {
  if (((char) ch) == ch)
  {
   if (fromIndex <= 0)
    fromIndex = 0;
   int offset = this.offset;
   int count = this.count;
   fromIndex = indexValueOf(ch, value, offset + fromIndex,
                count - fromIndex) - offset;
   if (fromIndex < count)
    return fromIndex;
  }
  return -1;
 }

 public int lastIndexOf(int ch)
 {
  return lastIndexOf(ch, count - 1);
 }

 public int lastIndexOf(int ch, int fromIndex)
 {
  if (((char) ch) != ch || fromIndex < 0)
   return -1;
  if (fromIndex >= count)
   fromIndex = count - 1;
  int offset = this.offset;
  return lastIndexValueOf(ch, value, offset + fromIndex, fromIndex + 1) -
          offset;
 }

 public int indexOf(String str)
 {
  return indexOf(str, 0);
 }

 public int indexOf(String str, int fromIndex)
 {
  int lastInd2 = str.count - 1;
  if (fromIndex <= 0)
   fromIndex = 0;
  int limit = count - lastInd2;
  if (fromIndex >= limit)
   return -1;
  if (lastInd2 >= 0)
  {
   Object value2 = str.value;
   int offset2 = str.offset;
   int ch = getValueAt(value2, offset2);
   Object value = this.value;
   int offset = this.offset;
   offset2++;
   do
   {
    fromIndex = indexValueOf(ch, value, offset + fromIndex,
                 limit - fromIndex) - offset;
    if (fromIndex >= limit)
     return -1;
    if (compareValues(value, offset + fromIndex + 1, value2, offset2,
        lastInd2) == 0)
     break;
    fromIndex++;
   } while (true);
  }
  return fromIndex;
 }

 public int lastIndexOf(String str)
 {
  return lastIndexOf(str, count - str.count);
 }

 public int lastIndexOf(String str, int fromIndex)
 {
  int lastInd2 = str.count - 1;
  if (count - lastInd2 <= fromIndex)
   fromIndex = count - lastInd2 - 1;
  if (fromIndex < 0)
   return -1;
  if (lastInd2 >= 0)
  {
   Object value2 = str.value;
   int offset2 = str.offset;
   int ch = getValueAt(value2, offset2);
   Object value = this.value;
   int offset = this.offset;
   offset2++;
   do
   {
    fromIndex = lastIndexValueOf(ch, value, offset + fromIndex,
                 fromIndex + 1) - offset;
    if (fromIndex < 0 || compareValues(value, offset + fromIndex + 1, value2,
        offset2, lastInd2) == 0)
     break;
    fromIndex--;
   } while (true);
  }
  return fromIndex;
 }

 public String substring(int beginIndex)
 {
  return substring(beginIndex, count);
 }

 public String substring(int beginIndex, int endIndex)
 {
  int margins = (count - endIndex) | beginIndex;
  if (margins == 0)
   return this;
  if (margins < 0 || endIndex < beginIndex)
   throw new StringIndexOutOfBoundsException();
  int len = endIndex - beginIndex;
  return len > 0 ? new String(offset + beginIndex, len, value) : "";
 }

 public CharSequence subSequence(int beginIndex, int endIndex)
 {
  return substring(beginIndex, endIndex);
 }

 public String concat(String str)
 {
  int count2 = str.count;
  int count = this.count;
  if (count2 == 0)
   return this;
  if (count == 0)
   return str;
  Object value = this.value;
  Object value2 = str.value;
  int offset = this.offset;
  int offset2 = str.offset;
  if (getValueLength(value) - offset - count >= count2 &&
      compareValues(value, offset + count, value2, offset2, count2) == 0)
   return new String(offset, count + count2, value);
  if (offset2 >= count &&
      compareValues(value, offset, value2, offset2 - count, count) == 0)
   return new String(offset2 - count, count + count2, value2);
  if (value instanceof byte[] && value2 instanceof byte[])
  {
   byte[] newBytes = new byte[count + count2];
   VMSystem.arraycopy(value, offset, newBytes, 0, count);
   VMSystem.arraycopy(value2, offset2, newBytes, count, count2);
   return new String(0, newBytes.length, newBytes);
  }
  char[] newChars = new char[count + count2];
  copyToChars(value, offset, newChars, 0, count);
  copyToChars(value2, offset2, newChars, count, count2);
  return new String(0, newChars.length, newChars);
 }

 public String replace(char oldChar, char newChar)
 {
  int pos;
  if (oldChar == newChar || (pos = indexOf(oldChar, 0)) < 0)
   return this;
  int count = this.count;
  Object value = this.value;
  if (newChar <= 0xff && value instanceof byte[])
  {
   byte[] newBytes = new byte[count];
   VMSystem.arraycopy(value, offset, newBytes, 0, count);
   newBytes[pos] = (byte) newChar;
   while (++pos < count)
    if ((newBytes[pos] & 0xff) == oldChar)
     newBytes[pos] = (byte) newChar;
   return new String(0, count, newBytes);
  }
  char[] newChars = new char[count];
  copyToChars(value, offset, newChars, 0, count);
  newChars[pos] = newChar;
  while (++pos < count)
   if (newChars[pos] == oldChar)
    newChars[pos] = newChar;
  return new String(0, count, newChars);
 }

 public boolean matches(String regex)
 {
  return Pattern.matches(regex, this);
 }

 public String replaceFirst(String regex, String replacement)
 {
  return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
 }

 public String replaceAll(String regex, String replacement)
 {
  return Pattern.compile(regex).matcher(this).replaceAll(replacement);
 }

 public String[] split(String regex, int limit)
 {
  return Pattern.compile(regex).split(this, limit);
 }

 public String[] split(String regex)
 {
  return split(regex, 0);
 }

 public String toLowerCase(Locale loc)
 {
  return toLowerCase("tr".equals(loc.getLanguage()));
 }

 public String toLowerCase()
 {
  return toLowerCase(false);
 }

 public String toUpperCase(Locale loc)
 {
  return toUpperCase("tr".equals(loc.getLanguage()));
 }

 public String toUpperCase()
 {
  return toUpperCase(false);
 }

 public String trim()
 {
  int limit = count;
  int pos = offset;
  if (limit == 0)
   return this;
  Object value = this.value;
  limit = pos + limit - 1;
  if (value instanceof byte[])
  {
   byte[] bytes = (byte[]) value;
   while ((bytes[pos] & 0xff) <= ' ')
    if (++pos > limit)
     return "";
   while ((bytes[limit] & 0xff) <= ' ')
    limit--;
  }
   else
   {
    char[] chars = (char[]) value;
    while (chars[pos] <= ' ')
     if (++pos > limit)
      return "";
    while (chars[limit] <= ' ')
     limit--;
   }
  limit = limit - pos + 1;
  return ((pos - offset) | (count - limit)) > 0 ?
          new String(pos, limit, value) : this;
 }

 public String toString()
 {
  return this;
 }

 public char[] toCharArray()
 {
  char[] newChars = new char[count];
  copyToChars(value, offset, newChars, 0, newChars.length);
  return newChars;
 }

 public static String valueOf(Object obj) /* hard-coded method signature */
 {
  return obj != null ? obj.toString() : "null";
 }

 public static String valueOf(char[] data)
 {
  return valueOf(data, 0, data.length);
 }

 public static String valueOf(char[] data, int offset, int count)
 {
  if ((offset | count) < 0 || data.length - offset < count)
   throw new StringIndexOutOfBoundsException();
  return new String(data, offset, count, false);
 }

 public static String copyValueOf(char[] data, int offset, int count)
 {
  if ((offset | count) < 0 || data.length - offset < count)
   throw new StringIndexOutOfBoundsException();
  return new String(data, offset, count, false);
 }

 public static String copyValueOf(char[] data)
 {
  return copyValueOf(data, 0, data.length);
 }

 public static String valueOf(boolean b) /* hard-coded method signature */
 {
  return b ? "true" : "false";
 }

 public static String valueOf(char c) /* hard-coded method signature */
 {
  return new String(0, 1, c > 0xff ? (Object) new char[] { c } :
          new byte[] { (byte) c });
 }

 public static String valueOf(int v) /* hard-coded method signature */
 {
  boolean isNeg = true;
  if (v >= 0)
  {
   isNeg = false;
   v = -v;
  }
  int offset = 11;
  if (v > -10000)
  {
   if (v > -100)
   {
    offset = 1;
    if (v <= -10)
     offset = 2;
   }
    else
    {
     offset = 3;
     if (v <= -1000)
      offset++;
    }
   if (isNeg)
    offset++;
  }
  byte[] newBytes = new byte[offset];
  do
  {
   newBytes[--offset] = (byte) ('0' - (v % 10));
   v /= 10;
  } while (v < 0);
  if (isNeg)
   newBytes[--offset] = '-';
  return new String(offset, newBytes.length - offset, newBytes);
 }

 public static String valueOf(long l) /* hard-coded method signature */
 {
  return Long.toString(l);
 }

 public static String valueOf(float f) /* hard-coded method signature */
 {
  return Float.toString(f);
 }

 public static String valueOf(double d) /* hard-coded method signature */
 {
  return Double.toString(d);
 }

 public String intern()
 {
  return VMString.intern(this);
 }

 public int codePointAt(int index)
 {
  return Character.codePointAt(this, index);
 }

 public int codePointBefore(int index)
 {
  return Character.codePointBefore(this, index);
 }

 public boolean contains(CharSequence seq)
 {
  return indexOf(seq.toString(), 0) >= 0;
 }

 public int codePointCount(int beginIndex, int endIndex)
 {
  if (((count - endIndex) | beginIndex) < 0 || endIndex < beginIndex)
   throw new StringIndexOutOfBoundsException();
  Object value = this.value;
  return value instanceof byte[] ? endIndex - beginIndex :
          Character.codePointCount((char[]) value, offset + beginIndex,
          endIndex - beginIndex);
 }

 public int offsetByCodePoints(int index, int codePointOffset)
 {
  int count = this.count;
  if (((count - index) | index) < 0)
   throw new StringIndexOutOfBoundsException(index);
  Object value = this.value;
  if (value instanceof byte[])
  {
   index = index + codePointOffset;
   if (((count - index) | index) < 0)
    throw new IndexOutOfBoundsException();
   return index;
  }
  int offset = this.offset;
  return Character.offsetByCodePoints((char[]) value, offset, count,
          offset + index, codePointOffset) - offset;
 }

 public String replace(CharSequence oldSeq, CharSequence newSeq)
 {
  int oldLen = oldSeq.length();
  int newLen = newSeq.length();
  if (oldLen == 1 && newLen == 1)
   return replace(oldSeq.charAt(0), newSeq.charAt(0));
  String oldStr = oldSeq.toString();
  int pos = indexOf(oldStr, 0);
  if (pos < 0 || oldSeq.equals(newSeq))
   return this;
  String newStr = newSeq.toString();
  StringBuilder buffer = new StringBuilder(this);
  do
  {
   buffer.replace(pos, pos + oldLen, newStr);
   pos = buffer.indexOf(oldStr, pos + newLen);
  } while (pos >= 0);
  return buffer.toString();
 }

 public boolean isEmpty()
 {
  return count == 0;
 }

 private static int upperCaseExpansion(char ch)
 {
  return Character.direction[0][Character.readCodePoint((int) ch) >> 7] & 0x3;
 }

 private static int upperCaseIndex(char ch)
 {
  int low = 0;
  char[] upperSpecialArr = upperSpecial;
  int hi = upperSpecialArr.length - 2;
  int mid;
  char c;
  while ((c = upperSpecialArr[mid = ((low + hi) >> 2) << 1]) != ch)
   if (ch < c)
    hi = mid - 2;
    else low = mid + 2;
  return upperSpecialArr[mid + 1];
 }

 static char[] zeroBasedStringValue(String str)
 {
  Object value = str.value;
  int offset = str.offset;
  int count = str.count;
  if (value instanceof byte[] ||
      ((((char[]) value).length - count) | offset) > 0)
  {
   if (count == 0)
    return EMPTY_CHARS;
   char[] newChars = new char[count];
   copyToChars(value, offset, newChars, 0, count);
   return newChars;
  }
  return (char[]) value;
 }

 String(int offset, byte[] bytes, int count)
 {
  value = bytes;
  this.offset = offset;
  this.count = count;
 }

 private String(int offset, int count, Object value)
 {
  this.value = value;
  this.offset = offset;
  this.count = count;
 }

 private static CharBuffer decodeBytes(byte[] bytes, int offset, int count,
   String encoding)
  throws CharacterCodingException, IllegalCharsetNameException,
   UnsupportedCharsetException
 {
  if ((offset | count) < 0 || bytes.length - offset < count)
   throw new StringIndexOutOfBoundsException();
  CharsetDecoder csd = Charset.forName(encoding).newDecoder();
  csd.onMalformedInput(CodingErrorAction.REPLACE);
  csd.onUnmappableCharacter(CodingErrorAction.REPLACE);
  return csd.decode(ByteBuffer.wrap(bytes, offset, count));
 }

 private static byte[] encodeValue(Object value, int offset, int count,
   String encoding)
  throws CharacterCodingException, IllegalCharsetNameException,
   UnsupportedCharsetException
 {
  CharsetEncoder cse = Charset.forName(encoding).newEncoder();
  cse.onMalformedInput(CodingErrorAction.REPLACE);
  cse.onUnmappableCharacter(CodingErrorAction.REPLACE);
  char[] chars;
  if (value instanceof byte[])
  {
   chars = new char[count];
   copyToChars(value, offset, chars, 0, count);
   offset = 0;
  }
   else chars = (char[]) value;
  ByteBuffer bbuf = cse.encode(CharBuffer.wrap(chars, offset, count));
  int bytesLen = bbuf.remaining();
  if (bbuf.hasArray() && bbuf.capacity() == bytesLen)
   return bbuf.array();
  byte[] newBytes = new byte[bytesLen];
  bbuf.get(newBytes);
  return newBytes;
 }

 private static boolean hasHighByte(char[] chars, int offset, int count)
 {
  count += offset;
  while (offset < count)
   if (chars[offset++] > 0xff)
    return true;
  return false;
 }

 private String toLowerCase(boolean isTurkish)
 {
  int offset = this.offset;
  int count = this.count;
  Object value = this.value;
  char[] chars;
  char[] newChars;
  int index;
  if (value instanceof byte[])
  {
   byte[] bytes = (byte[]) value;
   index = searchForNonLower(bytes, offset, count) - offset;
   if (index >= count)
    return this;
   if (!isTurkish &&
       Character.toLowerCase((char) (bytes[offset + index] & 0xff)) <= 0xff)
   {
    byte[] newBytes = new byte[count];
    if (index > 0)
     VMSystem.arraycopy(bytes, offset, newBytes, 0, index);
    index = convertToLower(bytes, offset + index, newBytes, index,
             count - index);
    if (index <= 0)
     return new String(0, count, newBytes);
    index = count - index;
    newChars = new char[count];
    copyToChars(newBytes, 0, newChars, 0, index);
    copyToChars(bytes, offset + index, newChars, index, count - index);
   }
    else
    {
     newChars = new char[count];
     copyToChars(bytes, offset, newChars, 0, count);
    }
   chars = newChars;
   offset = 0;
  }
   else
   {
    chars = (char[]) value;
    index = searchForNonLower(chars, offset, count) - offset;
    if (index >= count)
     return this;
    newChars = new char[count];
    if (index > 0)
     VMSystem.arraycopy(chars, offset, newChars, 0, index);
   }
  convertToLower(chars, offset + index, newChars, index, count - index,
   isTurkish);
  return new String(0, count, newChars);
 }

 private static int searchForNonLower(byte[] bytes, int offset, int count)
 {
  while (count-- > 0)
  {
   char ch = (char) (bytes[offset] & 0xff);
   if (Character.toLowerCase(ch) != ch)
    break;
   offset++;
  }
  return offset;
 }

 private static int searchForNonLower(char[] chars, int offset, int count)
 {
  while (count-- > 0)
  {
   char ch = chars[offset];
   if (Character.toLowerCase(ch) != ch)
    break;
   offset++;
  }
  return offset;
 }

 private static int convertToLower(byte[] bytes, int offset, byte[] bytes2,
   int offset2, int count)
 {
  if (count > 0)
  {
   do
   {
    char ch = Character.toLowerCase((char) (bytes[offset++] & 0xff));
    if (ch > 0xff)
     break;
    bytes2[offset2++] = (byte) ch;
   } while (--count > 0);
  }
  return count;
 }

 private static void convertToLower(char[] chars, int offset, char[] chars2,
   int offset2, int count, boolean isTurkish)
 {
  if (isTurkish)
  {
   while (count-- > 0)
   {
    char ch = chars[offset++];
    if (ch == 'I')
     ch = '\u0131';
     else if (ch == '\u0130')
      ch = 'i';
      else ch = Character.toLowerCase(ch);
    chars2[offset2++] = ch;
   }
  }
   else
   {
    while (count-- > 0)
     chars2[offset2++] = Character.toLowerCase(chars[offset++]);
   }
 }

 private String toUpperCase(boolean isTurkish)
 {
  int offset = this.offset;
  int count = this.count;
  Object value = this.value;
  char[] chars;
  char[] newChars = null;
  int index;
  if (value instanceof byte[])
  {
   byte[] bytes = (byte[]) value;
   index = searchForNonUpper(bytes, offset, count) - offset;
   if (index >= count)
    return this;
   if (!isTurkish &&
       Character.toUpperCase((char) (bytes[offset + index] & 0xff)) <= 0xff)
   {
    byte[] newBytes = new byte[count];
    if (index > 0)
     VMSystem.arraycopy(bytes, offset, newBytes, 0, index);
    index = convertToUpper(bytes, offset + index, newBytes, index,
             count - index);
    if (index <= 0)
     return new String(0, count, newBytes);
    index = count - index;
    newChars = new char[count];
    copyToChars(newBytes, 0, newChars, 0, index);
    copyToChars(bytes, offset + index, newChars, index, count - index);
   }
    else
    {
     newChars = new char[count];
     copyToChars(bytes, offset, newChars, 0, count);
    }
   chars = newChars;
   offset = 0;
  }
   else
   {
    chars = (char[]) value;
    index = searchForNonUpper(chars, offset, count) - offset;
    if (index >= count)
     return this;
   }
  int expand = getUpperExpansion(chars, offset + index, count - index);
  if (expand > 0 || chars != newChars)
  {
   newChars = new char[count + expand];
   if (index > 0)
    VMSystem.arraycopy(chars, offset, newChars, 0, index);
  }
  if (isTurkish || expand > 0)
   convertToUpper(chars, offset + index, newChars, index, count - index,
    isTurkish);
   else convertToUpper(chars, offset + index, newChars, index, count - index);
  return new String(0, count, newChars);
 }

 private static int searchForNonUpper(byte[] bytes, int offset, int count)
 {
  while (count-- > 0)
  {
   char ch = (char) (bytes[offset] & 0xff);
   if (Character.toUpperCase(ch) != ch || upperCaseExpansion(ch) > 0)
    break;
   offset++;
  }
  return offset;
 }

 private static int searchForNonUpper(char[] chars, int offset, int count)
 {
  while (count-- > 0)
  {
   char ch = chars[offset];
   if (Character.toUpperCase(ch) != ch || upperCaseExpansion(ch) > 0)
    break;
   offset++;
  }
  return offset;
 }

 private static int getUpperExpansion(char[] chars, int offset, int count)
 {
  int expand = 0;
  while (count-- > 0)
   expand += upperCaseExpansion(chars[offset++]);
  return expand;
 }

 private static int convertToUpper(byte[] bytes, int offset, byte[] bytes2,
   int offset2, int count)
 {
  if (count > 0)
  {
   do
   {
    char ch = (char) (bytes[offset++] & 0xff);
    if (upperCaseExpansion(ch) > 0)
     break;
    ch = Character.toUpperCase(ch);
    if (ch > 0xff)
     break;
    bytes2[offset2++] = (byte) ch;
   } while (--count > 0);
  }
  return count;
 }

 private static void convertToUpper(char[] chars, int offset, char[] chars2,
   int offset2, int count)
 {
  while (count-- > 0)
   chars2[offset2++] = Character.toUpperCase(chars[offset++]);
 }

 private static void convertToUpper(char[] chars, int offset, char[] chars2,
   int offset2, int count, boolean isTurkish)
 {
  while (count-- > 0)
  {
   char ch = chars[offset++];
   if (ch == '\u0131' && isTurkish)
    ch = 'I';
    else if (ch == 'i' && isTurkish)
     ch = '\u0130';
     else
     {
      int expand = upperCaseExpansion(ch);
      if (expand > 0)
      {
       char[] upperExpandArr = upperExpand;
       int index = upperCaseIndex(ch);
       do
       {
        chars2[offset2++] = upperExpandArr[index++];
       } while (--expand > 0);
       ch = upperExpandArr[index];
      }
       else ch = Character.toUpperCase(ch);
     }
   chars2[offset2++] = ch;
  }
 }

 private static char[] createCharsFromBytes(byte[] bytes, int offset,
   int count, int orval)
 {
  char[] newChars = new char[count];
  for (int i = 0; i < count; i++)
   newChars[i] = (char) ((bytes[offset++] & 0xff) | orval);
  return newChars;
 }

 private static void copyCharsToBytes(char[] chars, int offset, byte[] bytes2,
   int offset2, int count)
 {
  while (count-- > 0)
   bytes2[offset2++] = (byte) chars[offset++];
 }

 private static void copyToChars(Object value, int offset, char[] chars2,
   int offset2, int count)
 {
  if (count > 0)
  {
   if (value instanceof byte[])
   {
    byte[] bytes = (byte[]) value;
    do
    {
     chars2[offset2++] = (char) (bytes[offset++] & 0xff);
    } while (--count > 0);
   }
    else VMSystem.arraycopy(value, offset, chars2, offset2, count);
  }
 }

 private static int hashCodeOfValue(Object value, int offset, int count)
 {
  int hashCode = 0;
  if (value instanceof byte[])
  {
   byte[] bytes = (byte[]) value;
   while (count-- > 0)
   {
    hashCode = (bytes[offset] & 0xff) + (hashCode << 5) - hashCode;
    offset++;
   }
  }
   else
   {
    char[] chars = (char[]) value;
    while (count-- > 0)
     hashCode = chars[offset++] + (hashCode << 5) - hashCode;
   }
  return hashCode;
 }

 private static int indexValueOf(int ch, Object value, int pos, int count)
 {
  if (value instanceof byte[])
  {
   if (ch > 0xff)
    return pos + count;
   byte[] bytes = (byte[]) value;
   while (count-- > 0 && (bytes[pos] & 0xff) != ch)
    pos++;
  }
   else
   {
    char[] chars = (char[]) value;
    while (count-- > 0 && chars[pos] != ch)
     pos++;
   }
  return pos;
 }

 private static int lastIndexValueOf(int ch, Object value, int pos, int count)
 {
  if (value instanceof byte[])
  {
   if (ch > 0xff)
    return pos - count;
   byte[] bytes = (byte[]) value;
   while (count-- > 0 && (bytes[pos] & 0xff) != ch)
    pos--;
  }
   else
   {
    char[] chars = (char[]) value;
    while (count-- > 0 && chars[pos] != ch)
     pos--;
   }
  return pos;
 }

 private static int compareValues(Object value, int offset, Object value2,
   int offset2, int count)
 {
  int cmp = 0;
  if (offset != offset2 || value != value2)
  {
   if (value instanceof byte[])
   {
    byte[] bytes = (byte[]) value;
    if (value2 instanceof byte[])
    {
     byte[] bytes2 = (byte[]) value2;
     while (count-- > 0)
     {
      cmp = (bytes[offset] & 0xff) - (bytes2[offset2] & 0xff);
      if (cmp != 0)
       break;
      offset++;
      offset2++;
     }
    }
     else
     {
      char[] chars2 = (char[]) value2;
      while (count-- > 0)
       if ((cmp = (bytes[offset++] & 0xff) - chars2[offset2++]) != 0)
        break;
     }
   }
    else
    {
     char[] chars = (char[]) value;
     if (value2 instanceof byte[])
     {
      byte[] bytes2 = (byte[]) value2;
      while (count-- > 0)
       if ((cmp = chars[offset++] - (bytes2[offset2++] & 0xff)) != 0)
        break;
     }
      else
      {
       char[] chars2 = (char[]) value2;
       while (count-- > 0)
        if ((cmp = chars[offset++] - chars2[offset2++]) != 0)
         break;
      }
    }
  }
  return cmp;
 }

 private static int compareValuesIgnoreCase(Object value, int offset,
   Object value2, int offset2, int count)
 {
  int cmp = 0;
  if (offset != offset2 || value != value2)
  {
   if (value instanceof byte[])
   {
    byte[] bytes = (byte[]) value;
    if (value2 instanceof byte[])
    {
     byte[] bytes2 = (byte[]) value2;
     while (count-- > 0)
      if ((cmp = compareCharsIgnoreCase(bytes[offset++] & 0xff,
          bytes2[offset2++] & 0xff)) != 0)
       break;
    }
     else
     {
      char[] chars2 = (char[]) value2;
      while (count-- > 0)
       if ((cmp = compareCharsIgnoreCase(bytes[offset++] & 0xff,
           chars2[offset2++])) != 0)
        break;
     }
   }
    else
    {
     char[] chars = (char[]) value;
     if (value2 instanceof byte[])
     {
      byte[] bytes2 = (byte[]) value2;
      while (count-- > 0)
       if ((cmp = compareCharsIgnoreCase(chars[offset++],
           bytes2[offset2++] & 0xff)) != 0)
        break;
     }
      else
      {
       char[] chars2 = (char[]) value2;
       while (count-- > 0)
        if ((cmp = compareCharsIgnoreCase(chars[offset++],
            chars2[offset2++])) != 0)
         break;
      }
    }
  }
  return cmp;
 }

 private static int compareCharsIgnoreCase(int ch, int ch2)
 {
  int cmp = 0;
  if (ch != ch2)
  {
   char c = Character.toUpperCase((char) ch);
   char c2 = Character.toUpperCase((char) ch2);
   if (c != c2)
    cmp = Character.toLowerCase(c) - Character.toLowerCase(c2);
  }
  return cmp;
 }

 private static int getValueLength(Object value)
 {
  return value instanceof byte[] ? ((byte[]) value).length :
          ((char[]) value).length;
 }

 private static char getValueAt(Object value, int index)
 {
  return value instanceof byte[] ? (char) (((byte[]) value)[index] & 0xff) :
          ((char[]) value)[index];
 }
}