private void readValue()
{//throws IOException {
byte next;
bool lastCr = false;
int mark = pos;
int last = pos;
decoder.reset();
cBuf.clear();
while (pos < buf.Length)
{
next = buf[pos++];
switch (next)
{
case 0:
throw new java.io.IOException("NUL character in a manifest"); //$NON-NLS-1$
case (byte)'\n':
if (lastCr)
{
lastCr = false;
}
else
{
linebreak++;
}
continue;
case (byte)'\r':
lastCr = true;
linebreak++;
continue;
case (byte)' ':
if (linebreak == 1)
{
decode(mark, last, false);
mark = pos;
linebreak = 0;
continue;
}
break;
}
if (linebreak >= 1)
{
pos--;
break;
}
last = pos;
}
decode(mark, last, true);
while (java.nio.charset.CoderResult.OVERFLOW == decoder.flush(cBuf))
{
enlargeBuffer();
}
value = new String((char[])cBuf.array(), cBuf.arrayOffset(), cBuf.position());
}
/*
* Reads at most {@code length} characters from this reader and stores them
* at position {@code offset} in the character array {@code buf}. Returns
* the number of characters actually read or -1 if the end of the reader has
* been reached. The bytes are either obtained from converting bytes in this
* reader's buffer or by first filling the buffer from the source
* InputStream and then reading from the buffer.
*
* @param buf
* the array to store the characters read.
* @param offset
* the initial position in {@code buf} to store the characters
* read from this reader.
* @param length
* the maximum number of characters to read.
* @return the number of characters read or -1 if the end of the reader has
* been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code length < 0}, or if
* {@code offset + length} is greater than the length of
* {@code buf}.
* @throws IOException
* if this reader is closed or some other I/O error occurs.
*/
public override int read(char[] buf, int offset, int length)
{// throws IOException {
lock (lockJ)
{
if (!isOpen())
{
// luni.BA=InputStreamReader is closed.
throw new IOException("InputStreamReader is closed."); //$NON-NLS-1$
}
if (offset < 0 || offset > buf.Length - length || length < 0)
{
throw new java.lang.IndexOutOfBoundsException();
}
if (length == 0)
{
return(0);
}
java.nio.CharBuffer outJ = java.nio.CharBuffer.wrap(buf, offset, length);
java.nio.charset.CoderResult result = java.nio.charset.CoderResult.UNDERFLOW;
// bytes.remaining() indicates number of bytes in buffer
// when 1-st time entered, it'll be equal to zero
bool needInput = !bytes.hasRemaining();
while (outJ.hasRemaining())
{
// fill the buffer if needed
if (needInput)
{
try
{
if ((inJ.available() == 0) &&
(outJ.position() > offset))
{
// we could return the result without blocking read
break;
}
}
catch (IOException e)
{
// available didn't work so just try the read
}
int to_read = bytes.capacity() - bytes.limit();
int off = bytes.arrayOffset() + bytes.limit();
int was_red = inJ.read((byte[])bytes.array(), off, to_read);
if (was_red == -1)
{
endOfInput = true;
break;
}
else if (was_red == 0)
{
break;
}
bytes.limit(bytes.limit() + was_red);
needInput = false;
}
// decode bytes
result = decoder.decode(bytes, outJ, false);
if (result.isUnderflow())
{
// compact the buffer if no space left
if (bytes.limit() == bytes.capacity())
{
bytes.compact();
bytes.limit(bytes.position());
bytes.position(0);
}
needInput = true;
}
else
{
break;
}
}
if (result == java.nio.charset.CoderResult.UNDERFLOW && endOfInput)
{
result = decoder.decode(bytes, outJ, true);
decoder.flush(outJ);
decoder.reset();
}
if (result.isMalformed())
{
throw new java.nio.charset.MalformedInputException(result.length());
}
else if (result.isUnmappable())
{
throw new java.nio.charset.UnmappableCharacterException(result.length());
}
return(outJ.position() - offset == 0 ? -1 : outJ.position() - offset);
}
}