StreamDecoder(InputStream in,
    Object lock,
    Charset cs) 
{
        this(in, lock,
         cs.newDecoder()
         .onMalformedInput(CodingErrorAction.REPLACE)
         .onUnmappableCharacter(CodingErrorAction.REPLACE));
}

 StreamDecoder(InputStream in,
    Object lock,
    CharsetDecoder dec) 
{
        super(lock);
        this.cs = dec.charset();
        this.decoder = dec;
        // This path disabled until direct buffers are faster
        if (false && in instanceof FileInputStream) {
        ch = getChannel((FileInputStream)in);
        if (ch != null)
            bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE);
        }
        if (ch == null) {
        this.in = in;
        this.ch = null;
        bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);
        }
        bb.flip();                      // So that bb is initially empty
}

 StreamDecoder(ReadableByteChannel ch,
    CharsetDecoder dec,
    int mbc) 
{
        this.in = null;
        this.ch = ch;
        this.decoder = dec;
        this.cs = dec.charset();
        this.bb = ByteBuffer.allocate(mbc <  0
                                  ? DEFAULT_BYTE_BUFFER_SIZE
                                  : (mbc <  MIN_BYTE_BUFFER_SIZE
                                     ? MIN_BYTE_BUFFER_SIZE
                                     : mbc));
        bb.flip();
}

 public  void close() throws IOException 
{
        synchronized (lock) {
            if (!isOpen)
                return;
            implClose();
            isOpen = false;
        }
}

 String encodingName() 
{
        return ((cs instanceof HistoricallyNamedCharset)
            ? ((HistoricallyNamedCharset)cs).historicalName()
            : cs.name());
}

 public static StreamDecoder forDecoder(ReadableByteChannel ch,
    CharsetDecoder dec,
    int minBufferCap) 
{
        return new StreamDecoder(ch, dec, minBufferCap);
}

 public static StreamDecoder forInputStreamReader(InputStream in,
    Object lock,
    String charsetName) throws UnsupportedEncodingException 
{
        String csn = charsetName;
        if (csn == null)
            csn = Charset.defaultCharset().name();
        try {
            if (Charset.isSupported(csn))
                return new StreamDecoder(in, lock, Charset.forName(csn));
        } catch (IllegalCharsetNameException x) { }
        throw new UnsupportedEncodingException (csn);
}

 public static StreamDecoder forInputStreamReader(InputStream in,
    Object lock,
    Charset cs) 
{
        return new StreamDecoder(in, lock, cs);
}

 public static StreamDecoder forInputStreamReader(InputStream in,
    Object lock,
    CharsetDecoder dec) 
{
        return new StreamDecoder(in, lock, dec);
}

 public String getEncoding() 
{
        if (isOpen())
            return encodingName();
        return null;
}

  void implClose() throws IOException 
{
        if (ch != null)
        ch.close();
        else
        in.close();
}

 int implRead(char[] cbuf,
    int off,
    int end) throws IOException 
{
        // In order to handle surrogate pairs, this method requires that
        // the invoker attempt to read at least two characters.  Saving the
        // extra character, if any, at a higher level is easier than trying
        // to deal with it here.
        assert (end - off  > 1);
        CharBuffer cb = CharBuffer.wrap(cbuf, off, end - off);
        if (cb.position() != 0)
        // Ensure that cb[0] == cbuf[off]
        cb = cb.slice();
        boolean eof = false;
        for (;;) {
        CoderResult cr = decoder.decode(bb, cb, eof);
        if (cr.isUnderflow()) {
            if (eof)
                break;
            if (!cb.hasRemaining())
                break;
            if ((cb.position()  > 0) && !inReady())
                break;          // Block at most once
            int n = readBytes();
            if (n <  0) {
                eof = true;
                if ((cb.position() == 0) && (!bb.hasRemaining()))
                    break;
                decoder.reset();
            }
            continue;
        }
        if (cr.isOverflow()) {
            assert cb.position()  > 0;
            break;
        }
        cr.throwException();
        }
        if (eof) {
        // ## Need to flush decoder
        decoder.reset();
        }
        if (cb.position() == 0) {
            if (eof)
                return -1;
            assert false;
        }
        return cb.position();
}

 boolean implReady() 
{
            return bb.hasRemaining() || inReady();
}

 public int read() throws IOException 
{
        return read0();
}

 public int read(char[] cbuf,
    int offset,
    int length) throws IOException 
{
        int off = offset;
        int len = length;
        synchronized (lock) {
            ensureOpen();
            if ((off <  0) || (off  > cbuf.length) || (len <  0) ||
                ((off + len)  > cbuf.length) || ((off + len) <  0)) {
                throw new IndexOutOfBoundsException();
            }
            if (len == 0)
                return 0;
            int n = 0;
            if (haveLeftoverChar) {
                // Copy the leftover char into the buffer
                cbuf[off] = leftoverChar;
                off++; len--;
                haveLeftoverChar = false;
                n = 1;
                if ((len == 0) || !implReady())
                    // Return now if this is all we can produce w/o blocking
                    return n;
            }
            if (len == 1) {
                // Treat single-character array reads just like read()
                int c = read0();
                if (c == -1)
                    return (n == 0) ? -1 : n;
                cbuf[off] = (char)c;
                return n + 1;
            }
            return n + implRead(cbuf, off, off + len);
        }
}

 public boolean ready() throws IOException 
{
        synchronized (lock) {
            ensureOpen();
            return haveLeftoverChar || implReady();
        }
}