wasCSharpSQLite – Rev 1
?pathlinks?
#undef DEBUG
/*
* TclInputStream.java
*
* Copyright (c) 2003 Mo DeJong
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*
* Included in SQLite3 port to C# for use in testharness only; 2008 Noah B Hart
*
* RCS @(#) $Id: TclInputStream.java,v 1.1 2003/03/08 03:42:44 mdejong Exp $
*/
// A TclInputStream is a cross between a Java InputStream and
// a Reader. The class supports reading raw bytes as well as
// encoded characters. It manages buffering and supports
// line oriented reading of data. It also supports a user
// configurable EOF marker and line ending translations.
using System;
using System.Text;
using System.IO;
namespace tcl.lang
{
public class TclInputStream
{
internal System.Text.Encoding Encoding
{
set
{
encoding = value;
}
}
internal char EofChar
{
set
{
eofChar = value;
}
}
internal int Translation
{
set
{
translation = value;
}
}
internal int Buffering
{
set
{
buffering = value;
}
}
internal int BufferSize
{
set
{
bufSize = value;
}
}
internal bool Blocking
{
set
{
blocking = value;
}
}
internal bool Blocked
{
get
{
return blocked;
}
}
/// <summary> GetInput -> getInput
///
/// Reads input data from a device into a channel buffer.
///
/// The return value is the Posix error code if an error occurred while
/// reading from the file, or 0 otherwise.
/// </summary>
private int Input
{
get
{
int toRead;
int result;
int nread;
// if (checkForDeadChannel()) return EINVAL;
// Skipped pushback processing code for stacked Channels
// See if we can fill an existing buffer. If we can, read only
// as much as will fit in it. Otherwise allocate a new buffer,
// add it to the input queue and attempt to fill it to the max.
ChannelBuffer buf = inQueueTail;
if ( ( buf != null ) && ( buf.nextAdded < buf.bufLength ) )
{
System.Diagnostics.Debug.WriteLine( "smaller than buffer" );
toRead = buf.bufLength - buf.nextAdded;
}
else
{
System.Diagnostics.Debug.WriteLine( "fits in existing buffer" );
buf = saveInBuf;
saveInBuf = null;
// Check the actual buffersize against the requested
// buffersize. Buffers which are smaller than requested are
// squashed. This is done to honor dynamic changes of the
// buffersize made by the user.
if ( ( buf != null ) && ( ( buf.bufLength - tcl.lang.ChannelBuffer.BUFFER_PADDING ) < bufSize ) )
{
buf = null;
}
if ( buf == null )
{
System.Diagnostics.Debug.WriteLine( "allocated ChannelBuffer of size " + bufSize );
buf = new ChannelBuffer( bufSize );
}
buf.next = null;
// Use the actual size of the buffer to determine
// the number of bytes to read from the channel and not the
// size for new buffers. They can be different if the
// buffersize was changed between reads.
toRead = buf.bufLength - buf.nextAdded;
System.Diagnostics.Debug.WriteLine( "toRead set to " + toRead );
if ( inQueueTail == null )
inQueueHead = buf;
else
inQueueTail.next = buf;
inQueueTail = buf;
}
// If EOF is set, we should avoid calling the driver because on some
// platforms it is impossible to read from a device after EOF.
if ( eofCond )
{
System.Diagnostics.Debug.WriteLine( "eofCond was true, no error return" );
return 0;
}
// FIXME: We do not handle non-blocking or this CHANNEL_TIMER_FEV flag yet
if ( !blocking )
{
return TclPosixException.EWOULDBLOCK;
}
else
{
result = 0;
// Can we even use this for a brain-dead nonblocking IO check?
int numAvailable = 0;
if ( !blocking && ( numAvailable < toRead ) )
{
result = TclPosixException.EWOULDBLOCK;
nread = -1;
}
else
{
try
{
System.Diagnostics.Debug.WriteLine( "now to read " + toRead + " bytes" );
if ( input == null )
input = System.Console.OpenStandardInput();
nread = SupportClass.ReadInput( input, ref buf.buf, buf.nextAdded, toRead );
// read() returns -1 on EOF
if ( nread == -1 )
{
System.Diagnostics.Debug.WriteLine( "got EOF from read() call" );
nread = 0;
}
}
catch ( IOException ex )
{
// FIXME: How do we recover from IO errors here?
// I think we need to set result to a POSIX error
SupportClass.WriteStackTrace( ex, System.Console.Error );
nread = -1;
}
}
}
if ( nread > 0 )
{
System.Diagnostics.Debug.WriteLine( "nread is " + nread );
buf.nextAdded += nread;
// should avoid calling the driver because on some platforms we
// will block in the low level reading code even though the
// channel is set into nonblocking mode.
if ( nread < toRead )
{
blocked = true;
}
}
else if ( nread == 0 )
{
System.Diagnostics.Debug.WriteLine( "nread is zero" );
eofCond = true;
encodingEnd = true;
}
else if ( nread < 0 )
{
System.Diagnostics.Debug.WriteLine( "nread is " + nread );
if ( ( result == TclPosixException.EWOULDBLOCK ) || ( result == TclPosixException.EAGAIN ) )
{
blocked = true;
result = TclPosixException.EAGAIN;
}
// FIXME: Called needs to raise a TclException
//Tcl_SetErrno(result);
return result;
}
System.Diagnostics.Debug.WriteLine( "no error return" );
return 0;
}
}
/// <summary> Tcl_InputBuffered -> getNumBufferedBytes
///
/// Return the number of bytes that are current buffered.
/// </summary>
internal int NumBufferedBytes
{
get
{
ChannelBuffer buf;
int IOQueued;
for ( IOQueued = 0, buf = inQueueHead; buf != null; buf = buf.next )
{
IOQueued += buf.nextAdded - buf.nextRemoved;
}
return IOQueued;
}
}
/// <summary> The Java byte stream object we pull data in from.</summary>
private Stream input;
/// <summary> If nonzero, use this character as EOF marker.</summary>
private char eofChar;
/// <summary> Flag that is set on each read. If the read encountered EOF
/// or a custom eofChar is found, the it is set to true.
/// </summary>
private bool eofCond = false;
private bool stickyEofCond = false;
/// <summary> Translation mode for end-of-line character</summary>
protected internal int translation;
/// <summary> Name of Java encoding for this Channel.
/// A null value means use no encoding (binary).
/// </summary>
protected internal System.Text.Encoding encoding;
/// <summary> Current converter object. A null value means
/// that no conversions have been done yet.
/// </summary>
protected internal Decoder btc = null;
/// <summary> Buffering</summary>
protected internal int buffering;
/// <summary> Blocking</summary>
protected internal bool blocking;
/// <summary> Blocked</summary>
protected internal bool blocked = false;
/// <summary> Buffer size in bytes</summary>
protected internal int bufSize;
/// <summary> Used to track EOL state</summary>
protected internal bool needNL = false;
protected internal bool sawCR_Renamed_Field = false;
protected internal bool needMoreData = false;
/// <summary> Flags used to track encoding states.
/// The encodingState member of called inputEncodingState
/// in the C ChannelState type. The encodingStart and encodingEnd
/// members combined are called inputEncodingFlags
/// and have the bit values TCL_ENCODING_END and TCL_ENCODING_START.
/// </summary>
internal Object encodingState = null;
internal bool encodingStart = true;
internal bool encodingEnd = false;
/// <summary> First and last buffers in the input queue.</summary>
internal ChannelBuffer inQueueHead = null;
internal ChannelBuffer inQueueTail = null;
internal ChannelBuffer saveInBuf = null;
/// <summary> Constructor for Tcl input stream class. We require
/// a byte stream source at init time, the stram can't
/// be changed after the TclInputStream is created.
/// </summary>
internal TclInputStream( Stream inInput )
{
input = inInput;
}
// Helper used by getsObj and filterBytes
internal class GetsState
{
public GetsState( TclInputStream enclosingInstance )
{
InitBlock( enclosingInstance );
}
private void InitBlock( TclInputStream enclosingInstance )
{
this.enclosingInstance = enclosingInstance;
rawRead = new IntPtr();
charsWrote = new IntPtr();
}
private TclInputStream enclosingInstance;
public TclInputStream Enclosing_Instance
{
get
{
return enclosingInstance;
}
}
internal TclObject obj;
//int dst;
internal System.Text.Encoding encoding;
internal ChannelBuffer buf;
internal Object state;
internal IntPtr rawRead;
IntPtr bytesWrote = new IntPtr();
internal IntPtr charsWrote;
internal int totalChars;
}
/// <summary> Tcl_GetsObj -> getsObj
///
/// Accumulate input from the input channel until end-of-line or
/// end-of-file has been seen. Bytes read from the input channel
/// are converted to Unicode using the encoding specified by the
/// channel.
///
/// Returns the number of characters accumulated in the object
/// or -1 if error, blocked, or EOF. If -1, use Tcl_GetErrno()
/// to retrieve the POSIX error code for the error or condition
/// that occurred.
///
/// FIXME: Above setting of error code is not fully implemented.
///
/// Will consume input from the channel.
/// On reading EOF, leave channel at EOF char.
/// On reading EOL, leave channel after EOL, but don't
/// return EOL in dst buffer.
/// </summary>
internal int getsObj( TclObject obj )
{
GetsState gs;
ChannelBuffer buf;
bool oldEncodingStart, oldEncodingEnd;
int oldRemoved, skip, inEofChar;
int copiedTotal, oldLength;
bool in_binary_encoding = false;
int dst, dstEnd, eol, eof;
Object oldState;
buf = inQueueHead;
//encoding = this.encoding;
// Preserved so we can restore the channel's state in case we don't
// find a newline in the available input.
oldLength = 0;
oldEncodingStart = encodingStart;
oldEncodingEnd = encodingEnd;
oldState = encodingState;
oldRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
if ( buf != null )
{
oldRemoved = buf.nextRemoved;
}
// If there is no encoding, use "iso8859-1" -- readLine() doesn't
// produce ByteArray objects.
if ( (System.Object)encoding == null )
{
in_binary_encoding = true;
encoding = EncodingCmd.getJavaName( "utf-8" );
}
System.Diagnostics.Debug.WriteLine( "getsObj encoding is " + encoding );
// Object used by filterBytes to keep track of how much data has
// been consumed from the channel buffers.
gs = new GetsState( this );
gs.obj = obj;
//gs.dst = &dst;
gs.encoding = encoding;
gs.buf = buf;
gs.state = oldState;
gs.rawRead.i = 0;
//gs.bytesWrote.i = 0;
gs.charsWrote.i = 0;
gs.totalChars = 0;
// Ensure that tobj is an empty TclString object.
// Cheat a bit and grab the StringBuffer out of
// the TclString so we can query the data that
// was just added to the buffer.
TclString.empty( obj );
StringBuilder obj_sbuf = ( (TclString)obj.InternalRep ).sbuf;
dst = 0;
dstEnd = dst;
skip = 0;
eof = -1;
inEofChar = eofChar;
// Used to implement goto like functionality for restore
// and goteol loop terminaltion blocks.
bool restore = false;
bool goteol = false;
// This is just here so that eol and copiedTotal are
// definitely assigned before the try block.
eol = -1;
copiedTotal = -1;
{
while ( true )
{
if ( dst >= dstEnd )
{
if ( filterBytes( gs ) != 0 )
{
restore = true;
goto restore_or_goteol_brk; //goto restore
}
dstEnd += gs.charsWrote.i; // dstEnd = dst + gs.bytesWrote;
}
// Remember if EOF char is seen, then look for EOL anyhow, because
// the EOL might be before the EOF char.
if ( inEofChar != '\x0000' )
{
for ( eol = dst; eol < dstEnd; eol++ )
{
if ( obj_sbuf[eol] == inEofChar )
{
dstEnd = eol;
eof = eol;
break;
}
}
}
// On EOL, leave current file position pointing after the EOL, but
// don't store the EOL in the output string.
switch ( translation )
{
case TclIO.TRANS_LF:
{
for ( eol = dst; eol < dstEnd; eol++ )
{
if ( obj_sbuf[eol] == '\n' )
{
skip = 1;
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
break;
}
case TclIO.TRANS_CR:
{
for ( eol = dst; eol < dstEnd; eol++ )
{
if ( obj_sbuf[eol] == '\r' )
{
skip = 1;
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
break;
}
case TclIO.TRANS_CRLF:
{
for ( eol = dst; eol < dstEnd; eol++ )
{
if ( obj_sbuf[eol] == '\r' )
{
eol++;
// If a CR is at the end of the buffer,
// then check for a LF at the begining
// of the next buffer.
if ( eol >= dstEnd )
{
//int offset;
//offset = eol - objPtr->bytes;
dst = dstEnd;
if ( filterBytes( gs ) != 0 )
{
restore = true;
goto restore_or_goteol_brk; //goto restore
}
dstEnd += gs.charsWrote.i; // dstEnd = dst + gs.bytesWrote
//eol = objPtr->bytes + offset;
if ( eol >= dstEnd )
{
skip = 0;
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
if ( obj_sbuf[eol] == '\n' )
{
eol--;
skip = 2;
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
}
break;
}
case TclIO.TRANS_AUTO:
{
eol = dst;
skip = 1;
if ( sawCR_Renamed_Field )
{
sawCR_Renamed_Field = false;
if ( ( eol < dstEnd ) && ( obj_sbuf[eol] == '\n' ) )
{
// Skip the raw bytes that make up the '\n'.
char[] tmp = new char[1];
IntPtr rawRead = new IntPtr( this );
buf = gs.buf;
// FIXME: We don't actually pass gs.state here, should we?
//if (btc != null) btc.reset();
externalToUnicode( buf.buf, buf.nextRemoved, gs.rawRead.i, tmp, 0, 1, rawRead, null, null );
buf.nextRemoved += rawRead.i;
gs.rawRead.i -= rawRead.i;
//gs.bytesWrote.i--;
gs.charsWrote.i--;
obj_sbuf.Remove( dst, 1 );
dstEnd--;
}
}
for ( eol = dst; eol < dstEnd; eol++ )
{
if ( obj_sbuf[eol] == '\r' )
{
eol++;
if ( eol == dstEnd )
{
// If buffer ended on \r, peek ahead to see if a
// \n is available.
//int offset;
IntPtr dstEndPtr = new IntPtr();
//offset = eol /* - objPtr->bytes*/;
dst = dstEnd;
// FIXME: Why does this peek in AUTO mode
// but filter in CRLF mode?
peekAhead( gs );
//dstEnd = dstEndPtr.i;
dstEnd += gs.charsWrote.i;
//eol = /*objPtr->bytes + */ offset;
if ( eol >= dstEnd )
{
eol--;
sawCR_Renamed_Field = true;
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
if ( obj_sbuf[eol] == '\n' )
{
skip++;
}
eol--;
goteol = true; //goto goteol
goto restore_or_goteol_brk;
}
else if ( obj_sbuf[eol] == '\n' )
{
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
}
}
break;
}
if ( eof != -1 )
{
// EOF character was seen. On EOF, leave current file position
// pointing at the EOF character, but don't store the EOF
// character in the output string.
dstEnd = eof;
eofCond = true;
stickyEofCond = true;
encodingEnd = true;
}
if ( eofCond )
{
skip = 0;
eol = dstEnd;
if ( eol == oldLength )
{
// If we didn't append any bytes before encountering EOF,
// caller needs to see -1.
obj_sbuf.Length = oldLength;
commonGetsCleanup();
copiedTotal = -1;
goto restore_or_goteol_brk; //goto done
}
goteol = true;
goto restore_or_goteol_brk; //goto goteol
}
dst = dstEnd;
}
}
restore_or_goteol_brk:
;
// end restore_or_goteol: block
if ( goteol )
{
// Found EOL or EOF, but the output buffer may now contain too many
// characters. We need to know how many raw bytes correspond to
// the number of characters we want, plus how many raw bytes
// correspond to the character(s) making up EOL (if any), so we can
// remove the correct number of bytes from the channel buffer.
int linelen = eol - dst + skip;
char[] tmp = new char[linelen];
buf = gs.buf;
encodingState = gs.state;
if ( btc != null )
{
btc = this.encoding.GetDecoder();
}
externalToUnicode( buf.buf, buf.nextRemoved, gs.rawRead.i, tmp, 0, linelen, gs.rawRead, null, gs.charsWrote );
buf.nextRemoved += gs.rawRead.i;
// Recycle all the emptied buffers.
obj_sbuf.Length = eol;
commonGetsCleanup();
blocked = false;
copiedTotal = gs.totalChars + gs.charsWrote.i - skip;
}
if ( restore )
{
// Couldn't get a complete line. This only happens if we get a error
// reading from the channel or we are non-blocking and there wasn't
// an EOL or EOF in the data available.
buf = inQueueHead;
buf.nextRemoved = oldRemoved;
for ( buf = buf.next; buf != null; buf = buf.next )
{
buf.nextRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
}
commonGetsCleanup();
encodingState = oldState;
//if (btc != null) btc.reset(); // Not sure we want to reset encoder state here
encodingStart = oldEncodingStart;
encodingEnd = oldEncodingEnd;
obj_sbuf.Length = oldLength;
// We didn't get a complete line so we need to indicate to UpdateInterest
// that the gets blocked. It will wait for more data instead of firing
// a timer, avoiding a busy wait. This is where we are assuming that the
// next operation is a gets. No more file events will be delivered on
// this channel until new data arrives or some operation is performed
// on the channel (e.g. gets, read, fconfigure) that changes the blocking
// state. Note that this means a file event will not be delivered even
// though a read would be able to consume the buffered data.
needMoreData = true;
copiedTotal = -1;
}
// Update the notifier state so we don't block while there is still
// data in the buffers.
//done:
// Reset original encoding in case it was set to binary
if ( in_binary_encoding )
encoding = null;
updateInterest();
// FIXME: copiedTotal seems to be returning incorrect values
// for some tests, need to make caller code use the return
// value instead of the length of the returned object before
// these errors can be detected by the test suite.
return copiedTotal;
}
/// <summary> FilterInputBytes -> filterBytes
///
/// Helper function for getsObj. Appends Unicode characters
/// onto the TclObject associated with the GetsState after
/// converting them from raw bytes encoded in the Channel.
///
/// Consumes available bytes from channel buffers. When channel
/// buffers are exhausted, reads more bytes from channel device into
/// a new channel buffer. It is the caller's responsibility to
/// free the channel buffers that have been exhausted.
///
/// The return value is -1 if there was an error reading from the
/// channel, 0 otherwise.
///
/// FIXME: Doc modification of object's StringBuffer
///
/// Status object keeps track of how much data from channel buffers
/// has been consumed and where characters should be stored.
/// </summary>
internal int filterBytes( GetsState gs )
{
ChannelBuffer buf;
byte[] raw;
int rawStart, rawEnd;
char[] dst;
int offset, toRead, spaceLeft, result, rawLen, length;
TclObject obj;
int ENCODING_LINESIZE = 20; // Lower bound on how many bytes
// to convert at a time. Since we
// don't know a priori how many
// bytes of storage this many
// source bytes will use, we
// actually need at least
// ENCODING_LINESIZE bytes of room.
bool goto_read = false; // Set to true when jumping to the read
// label, used to simulate a goto.
obj = gs.obj;
// Subtract the number of bytes that were removed from channel buffer
// during last call.
buf = gs.buf;
if ( buf != null )
{
buf.nextRemoved += gs.rawRead.i;
if ( buf.nextRemoved >= buf.nextAdded )
{
buf = buf.next;
}
}
gs.totalChars += gs.charsWrote.i;
while ( true )
{
if ( goto_read || ( buf == null ) || ( buf.nextAdded == tcl.lang.ChannelBuffer.BUFFER_PADDING ) )
{
// All channel buffers were exhausted and the caller still hasn't
// seen EOL. Need to read more bytes from the channel device.
// Side effect is to allocate another channel buffer.
//read:
if ( blocked )
{
if ( !blocking )
{
gs.charsWrote.i = 0;
gs.rawRead.i = 0;
return -1;
}
blocked = false;
}
if ( Input != 0 )
{
gs.charsWrote.i = 0;
gs.rawRead.i = 0;
return -1;
}
buf = inQueueTail;
gs.buf = buf;
}
// Convert some of the bytes from the channel buffer to characters.
// Space in obj's string rep is used to hold the characters.
rawStart = buf.nextRemoved;
raw = buf.buf;
rawEnd = buf.nextAdded;
rawLen = rawEnd - rawStart;
//dst = *gsPtr->dstPtr;
//offset = dst - objPtr->bytes;
toRead = ENCODING_LINESIZE;
if ( toRead > rawLen )
{
toRead = rawLen;
}
//dstNeeded = toRead * TCL_UTF_MAX + 1;
//spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1;
//if (dstNeeded > spaceLeft) {
// length = offset * 2;
// if (offset < dstNeeded) {
// length = offset + dstNeeded;
// }
// length += TCL_UTF_MAX + 1;
// Tcl_SetObjLength(objPtr, length);
// spaceLeft = length - offset;
// dst = objPtr->bytes + offset;
// *gsPtr->dstPtr = dst;
//}
dst = new char[toRead];
gs.state = encodingState;
result = externalToUnicode( raw, rawStart, rawLen, dst, 0, toRead, gs.rawRead, null, gs.charsWrote );
TclString.append( gs.obj, dst, 0, gs.charsWrote.i );
// Make sure that if we go through 'gets', that we reset the
// TCL_ENCODING_START flag still.
encodingStart = false;
if ( result == TCL_CONVERT_MULTIBYTE )
{
// The last few bytes in this channel buffer were the start of a
// multibyte sequence. If this buffer was full, then move them to
// the next buffer so the bytes will be contiguous.
ChannelBuffer next;
int extra;
next = buf.next;
if ( buf.nextAdded < buf.bufLength )
{
if ( gs.rawRead.i > 0 )
{
// Some raw bytes were converted to UTF-8. Fall through,
// returning those UTF-8 characters because a EOL might be
// present in them.
}
else if ( eofCond )
{
// There was a partial character followed by EOF on the
// device. Fall through, returning that nothing was found.
buf.nextRemoved = buf.nextAdded;
}
else
{
// There are no more cached raw bytes left. See if we can
// get some more.
goto_read = true;
goto read; //goto read;
}
}
else
{
if ( next == null )
{
next = new ChannelBuffer( bufSize );
buf.next = next;
inQueueTail = next;
}
extra = rawLen - gs.rawRead.i;
Array.Copy( raw, gs.rawRead.i, next.buf, tcl.lang.ChannelBuffer.BUFFER_PADDING - extra, extra );
next.nextRemoved -= extra;
buf.nextAdded -= extra;
}
}
goto read_brk; // End loop in the normal case
read:
;
}
read_brk:
;
gs.buf = buf;
return 0;
}
/// <summary> PeekAhead -> peekAhead
///
/// Helper function used by getsObj. Called when we've seen a
/// \r at the end of the string and want to look ahead one
/// character to see if it is a \n.
///
/// Characters read from the channel are appended to gs.obj
/// via the filterBytes method.
/// </summary>
internal void peekAhead( GetsState gs )
{
ChannelBuffer buf;
//Tcl_DriverBlockModeProc *blockModeProc;
int bytesLeft;
bool goto_cleanup = false; // Set to true when jumping to the
// cleanup label, used to simulate a goto.
buf = gs.buf;
// If there's any more raw input that's still buffered, we'll peek into
// that. Otherwise, only get more data from the channel driver if it
// looks like there might actually be more data. The assumption is that
// if the channel buffer is filled right up to the end, then there
// might be more data to read.
{
//blockModeProc = NULL;
if ( buf.next == null )
{
bytesLeft = buf.nextAdded - ( buf.nextRemoved + gs.rawRead.i );
if ( bytesLeft == 0 )
{
if ( buf.nextAdded < buf.bufLength )
{
// Don't peek ahead if last read was short read.
goto_cleanup = true;
goto cleanup_brk;
}
// FIXME: This non-blocking check is currently disabled, non-blocking
// is not currently supported and it is not clean why we would
// need to depend on non-blocking IO when peeking anyway.
if ( blocking )
{
//blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
//if (false)
//{
// // Don't peek ahead if cannot set non-blocking mode.
// goto_cleanup = true;
// goto cleanup_brk;
//}
//StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
}
}
}
//if (filterBytes(gs) == 0) {
// dstEndPtr.i = gs.charsWrote.i; *gsPtr->dstPtr + gs.bytesWrote.i
//}
filterBytes( gs );
//if (blockModeProc != NULL) {
// StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
//}
}
cleanup_brk:
;
if ( goto_cleanup )
{
buf.nextRemoved += gs.rawRead.i;
gs.rawRead.i = 0;
gs.totalChars += gs.charsWrote.i;
//gs.bytesWrote.i = 0;
gs.charsWrote.i = 0;
}
}
/// <summary> CommonGetsCleanup -> commonGetsCleanup
///
/// Helper function used by getsObj to restore the channel after
/// a "gets" operation.
///
/// </summary>
internal void commonGetsCleanup()
{
ChannelBuffer buf, next;
buf = inQueueHead;
for ( ; buf != null; buf = next )
{
next = buf.next;
if ( buf.nextRemoved < buf.nextAdded )
{
break;
}
recycleBuffer( buf, false );
}
inQueueHead = buf;
if ( buf == null )
{
inQueueTail = null;
}
else
{
// If any multi-byte characters were split across channel buffer
// boundaries, the split-up bytes were moved to the next channel
// buffer by filterBytes(). Move the bytes back to their
// original buffer because the caller could change the channel's
// encoding which could change the interpretation of whether those
// bytes really made up multi-byte characters after all.
next = buf.next;
for ( ; next != null; next = buf.next )
{
int extra;
extra = buf.bufLength - buf.nextAdded;
if ( extra > 0 )
{
Array.Copy( next.buf, tcl.lang.ChannelBuffer.BUFFER_PADDING - extra, buf.buf, buf.nextAdded, extra );
buf.nextAdded += extra;
next.nextRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
}
buf = next;
}
}
if ( (System.Object)encoding != null )
{
//Tcl_FreeEncoding(encoding);
}
}
// CloseChannel -> close
internal void close()
{
discardQueued( true );
// FIXME: More close logic in CloseChannel
}
internal bool eof()
{
return eofCond;
}
internal bool sawCR()
{
return sawCR_Renamed_Field;
}
// Helper class to implement integer pass by reference
// for methods like doReadChars, readBytes and so on.
internal class IntPtr
{
private void InitBlock( TclInputStream enclosingInstance )
{
this.enclosingInstance = enclosingInstance;
}
private TclInputStream enclosingInstance;
public TclInputStream Enclosing_Instance
{
get
{
return enclosingInstance;
}
}
internal int i;
internal IntPtr()
{
}
internal IntPtr( TclInputStream enclosingInstance )
{
InitBlock( enclosingInstance );
}
internal IntPtr( TclInputStream enclosingInstance, int value )
{
InitBlock( enclosingInstance );
i = value;
}
}
/// <summary> DoReadChars -> doReadChars
///
/// Reads from the channel until the requested number of characters
/// have been seen, EOF is seen, or the channel would block. EOL
/// and EOF translation is done. If reading binary data, the raw
/// bytes are wrapped in a Tcl byte array object. Otherwise, the raw
/// bytes are converted to characters using the channel's current
/// encoding and stored in a Tcl string object.
///
/// </summary>
/// <param name="obj">Input data is stored in this object.
/// </param>
/// <param name="toRead">Maximum number of characters to store,
/// or -1 to read all available data (up to EOF
/// or when channel blocks).
/// </param>
internal int doReadChars( TclObject obj, int toRead )
{
ChannelBuffer buf;
int copied, copiedNow, result;
IntPtr offset = new IntPtr( this );
if ( (System.Object)encoding == null )
{
TclByteArray.setLength( null, obj, 0 );
}
else
{
TclString.empty( obj );
}
offset.i = 0;
// if toRead is negative, read until EOF
if ( toRead < 0 )
{
toRead = System.Int32.MaxValue;
}
{
for ( copied = 0; toRead > 0; )
{
copiedNow = -1;
if ( inQueueHead != null )
{
if ( (System.Object)encoding == null )
{
System.Diagnostics.Debug.WriteLine( "calling readBytes " + toRead );
copiedNow = readBytes( obj, toRead, offset );
}
else
{
System.Diagnostics.Debug.WriteLine( "calling readChars " + toRead );
copiedNow = readChars( obj, toRead );
}
// If the current buffer is empty recycle it.
buf = inQueueHead;
System.Diagnostics.Debug.WriteLine( "after read* buf.nextRemoved is " + buf.nextRemoved );
System.Diagnostics.Debug.WriteLine( "after read* buf.nextAdded is " + buf.nextAdded );
if ( buf.nextRemoved == buf.nextAdded )
{
System.Diagnostics.Debug.WriteLine( "recycling empty buffer" );
ChannelBuffer next;
next = buf.next;
recycleBuffer( buf, false );
inQueueHead = next;
if ( next == null )
{
System.Diagnostics.Debug.WriteLine( "inQueueTail set to null" );
inQueueTail = null;
}
else
{
System.Diagnostics.Debug.WriteLine( "inQueueTail is not null" );
}
}
}
if ( copiedNow < 0 )
{
System.Diagnostics.Debug.WriteLine( "copiedNow < 0" );
if ( eofCond )
{
System.Diagnostics.Debug.WriteLine( "eofCond" );
break;
}
if ( blocked )
{
System.Diagnostics.Debug.WriteLine( "blocked" );
if ( !blocking )
{
break;
}
blocked = false;
}
result = Input;
if ( result != 0 )
{
System.Diagnostics.Debug.WriteLine( "non-zero result" );
if ( result == TclPosixException.EAGAIN )
{
break;
}
copied = -1;
goto done_brk; //goto done
}
}
else
{
copied += copiedNow;
System.Diagnostics.Debug.WriteLine( "copied incremented to " + copied );
toRead -= copiedNow;
System.Diagnostics.Debug.WriteLine( "toRead decremented to " + toRead );
}
}
blocked = false;
if ( (System.Object)encoding == null )
{
TclByteArray.setLength( null, obj, offset.i );
System.Diagnostics.Debug.WriteLine( "set byte array length to " + offset.i );
}
}
done_brk:
;
// end done: block
//done:
updateInterest();
#if DEBUG
System.Diagnostics.Debug.WriteLine("returning copied = " + copied);
System.Diagnostics.Debug.WriteLine("returning string \"" + obj + "\"");
obj.invalidateStringRep();
System.Diagnostics.Debug.WriteLine("returning string \"" + obj + "\"");
#endif
return copied;
}
/// <summary> ReadBytes -> readBytes
///
/// Reads from the channel until the requested number of
/// bytes have been seen, EOF is seen, or the channel would
/// block. Bytes from the channel are stored in obj as a
/// ByteArray object. EOL and EOF translation are done.
///
/// 'bytesToRead' can safely be a very large number because
/// space is only allocated to hold data read from the channel
/// as needed.
///
/// The return value is the number of bytes appended to
/// the object.
///
/// </summary>
/// <param name="obj,">the TclByteArrayObject we are operating on
/// </param>
/// <param name="bytesToRead,">Maximum number of bytes to store.
/// Bytes are obtained from the first
/// buffer in the queue -- even if this number
/// is larger than the number of bytes only
/// the bytes from the first buffer are returned.
/// </param>
/// <param name="offsetPtr"> On input, contains how many bytes of
/// obj have been used to hold data. On
/// output, how many bytes are now being used.
/// </param>
internal int readBytes( TclObject obj, int bytesToRead, IntPtr offsetPtr )
{
int toRead, srcOff, srcLen, offset, length;
ChannelBuffer buf;
IntPtr srcRead, dstWrote;
byte[] src, dst;
offset = offsetPtr.i;
buf = inQueueHead;
src = buf.buf;
srcOff = buf.nextRemoved;
srcLen = buf.nextAdded - buf.nextRemoved;
System.Diagnostics.Debug.WriteLine( "readBytes() : src buffer len is " + buf.buf.Length );
System.Diagnostics.Debug.WriteLine( "readBytes() : buf.nextRemoved is " + buf.nextRemoved );
System.Diagnostics.Debug.WriteLine( "readBytes() : buf.nextAdded is " + buf.nextAdded );
toRead = bytesToRead;
if ( toRead > srcLen )
{
toRead = srcLen;
System.Diagnostics.Debug.WriteLine( "readBytes() : toRead set to " + toRead );
}
length = TclByteArray.getLength( null, obj );
dst = TclByteArray.getBytes( null, obj );
System.Diagnostics.Debug.WriteLine( "readBytes() : toRead is " + toRead );
System.Diagnostics.Debug.WriteLine( "readBytes() : length is " + length );
System.Diagnostics.Debug.WriteLine( "readBytes() : array length is " + dst.Length );
if ( toRead > length - offset - 1 )
{
System.Diagnostics.Debug.WriteLine( "readBytes() : TclObject too small" );
// Double the existing size of the object or make enough room to
// hold all the characters we may get from the source buffer,
// whichever is larger.
length = offset * 2;
if ( offset < toRead )
{
length = offset + toRead + 1;
}
dst = TclByteArray.setLength( null, obj, length );
}
if ( needNL )
{
needNL = false;
if ( ( srcLen == 0 ) || ( src[srcOff] != '\n' ) )
{
dst[offset] = (byte)SupportClass.Identity( '\r' );
offsetPtr.i += 1;
return 1;
}
dst[offset++] = (byte)SupportClass.Identity( '\n' );
srcOff++;
srcLen--;
toRead--;
}
srcRead = new IntPtr( this, srcLen );
dstWrote = new IntPtr( this, toRead );
if ( translateEOL( dst, offset, src, srcOff, dstWrote, srcRead ) != 0 )
{
if ( dstWrote.i == 0 )
{
return -1;
}
}
buf.nextRemoved += srcRead.i;
offsetPtr.i += dstWrote.i;
return dstWrote.i;
}
/// <summary> ReadChars -> readChars
///
/// Reads from the channel until the requested number of
/// characters have been seen, EOF is seen, or the channel would
/// block. Raw bytes from the channel are converted to characters
/// and stored in obj. EOL and EOF translation is done.
///
/// 'charsToRead' can safely be a very large number because
/// space is only allocated to hold data read from the channel
/// as needed.
///
/// The return value is the number of characters appended to
/// the object.
///
/// </summary>
/// <param name="obj,">the TclByteArrayObject we are operating on
/// </param>
/// <param name="charsToRead,">Maximum number of chars to store.
/// Chars are obtained from the first
/// buffer in the queue -- even if this number
/// is larger than the number of chars only
/// the chars from the first buffer are returned.
/// </param>
internal int readChars( TclObject obj, int charsToRead )
{
int toRead, factor, spaceLeft, length, srcLen, dstNeeded;
int srcOff, dstOff;
IntPtr srcRead, numChars, dstRead, dstWrote;
ChannelBuffer buf;
byte[] src;
char[] dst;
Object oldState;
srcRead = new IntPtr( this );
numChars = new IntPtr( this );
dstRead = new IntPtr( this );
dstWrote = new IntPtr( this );
buf = inQueueHead;
src = buf.buf;
srcOff = buf.nextRemoved;
srcLen = buf.nextAdded - buf.nextRemoved;
/* FIXME: Include final Tcl patch for srcLen == 0 case */
if ( srcLen == 0 )
{
if ( needNL )
{
TclString.append( obj, "\r" );
return 1;
}
return -1;
}
toRead = charsToRead;
if ( toRead > srcLen )
{
toRead = srcLen;
}
// FIXME : Do something to cache conversion buffer, or it might also
// to pass the TclObject directly into the externalToUnicode method
// so as to avoid the need for this extra buffer.
dstNeeded = toRead;
dst = new char[dstNeeded];
dstOff = 0;
oldState = encodingState;
if ( needNL )
{
// We want a '\n' because the last character we saw was '\r'.
needNL = false;
externalToUnicode( src, srcOff, srcLen, dst, dstOff, 1, srcRead, dstWrote, numChars );
if ( ( numChars.i > 0 ) && ( dst[dstOff] == '\n' ) )
{
// The next char was a '\n'. Consume it and produce a '\n'.
buf.nextRemoved += srcRead.i;
}
else
{
// The next char was not a '\n'. Produce a '\r'.
dst[dstOff] = '\r';
}
encodingStart = false;
TclString.append( obj, dst, dstOff, 1 );
return 1;
}
externalToUnicode( src, srcOff, srcLen, dst, dstOff, dstNeeded, srcRead, dstWrote, numChars );
// This block is disabled since the char converter does
// not inform us about partial chars, instead it silently
// stores the partial character internally.
//if (false && srcRead.i == 0)
//{
// // Not enough bytes in src buffer to make a complete char. Copy
// // the bytes to the next buffer to make a new contiguous string,
// // then tell the caller to fill the buffer with more bytes.
// ChannelBuffer next;
// next = buf.next;
// if (next == null)
// {
// if (srcLen > 0)
// {
// // There isn't enough data in the buffers to complete the next
// // character, so we need to wait for more data before the next
// // file event can be delivered.
// //
// // The exception to this is if the input buffer was
// // completely empty before we tried to convert its
// // contents. Nothing in, nothing out, and no incomplete
// // character data. The conversion before the current one
// // was complete.
// needMoreData = true;
// }
// return - 1;
// }
// next.nextRemoved -= srcLen;
// Array.Copy(src, srcOff, next.buf, next.nextRemoved, srcLen);
// recycleBuffer(buf, false);
// inQueueHead = next;
// return readChars(obj, charsToRead);
//}
dstRead.i = dstWrote.i;
if ( translateEOL( dst, dstOff, dst, dstOff, dstWrote, dstRead ) != 0 )
{
// Hit EOF char. How many bytes of src correspond to where the
// EOF was located in dst? Run the conversion again with an
// output buffer just big enough to hold the data so we can
// get the correct value for srcRead.
if ( dstWrote.i == 0 )
{
return -1;
}
encodingState = oldState;
if ( btc != null )
{
btc = this.encoding.GetDecoder();
}
externalToUnicode( src, srcOff, srcLen, dst, dstOff, dstRead.i, srcRead, dstWrote, numChars );
translateEOL( dst, dstOff, dst, dstOff, dstWrote, dstRead );
}
// The number of characters that we got may be less than the number
// that we started with because "\r\n" sequences may have been
// turned into just '\n' in dst.
numChars.i -= ( dstRead.i - dstWrote.i );
if ( numChars.i > toRead )
{
// Got too many chars.
int eof;
eof = toRead;
encodingState = oldState;
if ( btc != null )
{
btc = this.encoding.GetDecoder();
}
externalToUnicode( src, srcOff, srcLen, dst, dstOff, ( eof - dstOff ), srcRead, dstWrote, numChars );
dstRead.i = dstWrote.i;
translateEOL( dst, dstOff, dst, dstOff, dstWrote, dstRead );
numChars.i -= ( dstRead.i - dstWrote.i );
}
encodingStart = false;
buf.nextRemoved += srcRead.i;
TclString.append( obj, dst, dstOff, numChars.i );
return numChars.i;
}
// FIXME: Only define the ones that we actually need/use.
// The following definitions are the error codes returned by externalToUnicode
//
// TCL_OK: All characters were converted.
//
// TCL_CONVERT_NOSPACE: The output buffer would not have been large
// enough for all of the converted data; as many
// characters as could fit were converted though.
//
// TCL_CONVERT_MULTIBYTE: The last few bytes in the source string were
// the beginning of a multibyte sequence, but
// more bytes were needed to complete this
// sequence. A subsequent call to the conversion
// routine should pass the beginning of this
// unconverted sequence plus additional bytes
// from the source stream to properly convert
// the formerly split-up multibyte sequence.
//
// TCL_CONVERT_SYNTAX: The source stream contained an invalid
// character sequence. This may occur if the
// input stream has been damaged or if the input
// encoding method was misidentified. This error
// is reported only if TCL_ENCODING_STOPONERROR
// was specified.
//
// TCL_CONVERT_UNKNOWN: The source string contained a character
// that could not be represented in the target
// encoding. This error is reported only if
// TCL_ENCODING_STOPONERROR was specified.
private int TCL_CONVERT_MULTIBYTE = -1;
private int TCL_CONVERT_SYNTAX = -2;
private int TCL_CONVERT_UNKNOWN = -3;
private int TCL_CONVERT_NOSPACE = -4;
/// <summary> Tcl_ExternalToUtf -> externalToUnicode
///
/// Convert a source buffer from the specified encoding into Unicode.
///
/// FIXME: Add doc for return values
///
/// </summary>
/// <param name="src,"> Source bytes in specified encoding.
/// </param>
/// <param name="srcOff,"> First index in src input array.
/// </param>
/// <param name="srcLen,"> Number of bytes in src buffer.
/// </param>
/// <param name="dst,"> Array to store unicode characters in.
/// </param>
/// <param name="dstOff,"> First available index in dst array.
/// </param>
/// <param name="dstLen,"> Length of dst array.
/// </param>
/// <param name="srcReadPtr,"> Filled with the number of bytes from
/// the source string that were converted.
/// This may be less than the original source
/// length if there was a problem converting
/// some source characters.
/// </param>
/// <param name="dstWrotePtr,">Filled with the number of chars that were
/// stored in the output buffer as a result of
/// the conversion
/// </param>
/// <param name="dstCharsPtr,">Filled with the number of characters that
/// correspond to the bytes stored in the
/// output buffer.
/// </param>
internal int externalToUnicode( byte[] src, int srcOff, int srcLen, char[] dst, int dstOff, int dstLen, IntPtr srcReadPtr, IntPtr dstWrotePtr, IntPtr dstCharsPtr )
{
System.Text.Encoding encoding = this.encoding;
int result;
//Object state;
//String encoded_string;
if ( (System.Object)encoding == null )
{
// This should never happen
//encoding = Encoding.getJavaName("identity");
throw new TclRuntimeError( "externalToUnicode called with null encoding" );
}
// FIXME: This may no longer be needed after Tcl srcLen == 0 patch
if ( srcLen == 0 )
{
srcReadPtr.i = 0;
if ( dstWrotePtr != null )
dstWrotePtr.i = 0;
if ( dstCharsPtr != null )
dstCharsPtr.i = 0;
return 0;
}
// Convert bytes from src into unicode chars and store them in dst.
// FIXME: This allocated a buffer for the String and then copies the
// encoded data into a second buffer. Need to decode the data directly
// into the dst array since this is performance critical.
#if DEBUG
System.Diagnostics.Debug.WriteLine("now to decode byte array of length " + srcLen);
System.Diagnostics.Debug.WriteLine("srcOff is " + srcOff);
for (int i = srcOff; i < (srcOff + srcLen); i++)
{
System.Diagnostics.Debug.WriteLine("(byte) '" + ((char) src[i]) + "'");
}
System.Diagnostics.Debug.WriteLine("encoded as " + encoding);
#endif
// FIXME: In the cases where we know that we don't actually want
// to copy the data, we could pass a flag so that we could
// take advantage of encodings that had a one to one mapping
// from bytes to chars (now need to copy then to find bytes used).
if ( btc == null )
{
try
{
btc = this.encoding.GetDecoder();
}
catch ( IOException ex )
{
// Valid encodings should be checked already
throw new TclRuntimeError( "unsupported encoding \"" + encoding + "\"" );
}
}
int bytes_read, chars_written;
int required_chars = btc.GetCharCount( src, srcOff, srcLen );
if ( required_chars > dstLen )
{
srcLen = dstLen;
}
chars_written = btc.GetChars( src, srcOff, srcLen, dst, dstOff );
bytes_read = srcLen;
srcReadPtr.i = bytes_read;
if ( dstWrotePtr != null )
dstWrotePtr.i = chars_written;
if ( dstCharsPtr != null )
dstCharsPtr.i = chars_written;
// FIXME: When do we return error codes?
result = 0;
return result;
}
/// <summary> RecycleBuffer -> recycleBuffer
///
/// Helper function to recycle input buffers. Ensures that
/// two input buffers are saved (one in the input queue and
/// another in the saveInBuf field). Only if these conditions
/// are met is the buffer released so that it can be
/// garbage collected.
/// </summary>
private void recycleBuffer( ChannelBuffer buf, bool mustDiscard )
{
if ( mustDiscard )
return;
// Only save buffers which are at least as big as the requested
// buffersize for the channel. This is to honor dynamic changes
// of the buffersize made by the user.
if ( ( buf.bufLength - tcl.lang.ChannelBuffer.BUFFER_PADDING ) < bufSize )
{
return;
}
if ( inQueueHead == null )
{
inQueueHead = buf;
inQueueTail = buf;
buf.nextRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
buf.nextAdded = tcl.lang.ChannelBuffer.BUFFER_PADDING;
buf.next = null;
return;
}
if ( saveInBuf == null )
{
saveInBuf = buf;
buf.nextRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
buf.nextAdded = tcl.lang.ChannelBuffer.BUFFER_PADDING;
buf.next = null;
return;
}
}
/// <summary> DiscardInputQueued -> discardQueued
///
/// Discards any input read from the channel but not yet consumed
/// by Tcl reading commands.
/// </summary>
private void discardQueued( bool discardSavedBuffers )
{
ChannelBuffer buf, nxt;
buf = inQueueHead;
inQueueHead = null;
inQueueTail = null;
for ( ; buf != null; buf = nxt )
{
nxt = buf.next;
recycleBuffer( buf, discardSavedBuffers );
}
// If discardSavedBuffers is true, must also discard any previously
// saved buffer in the saveInBuf field.
if ( discardSavedBuffers )
{
if ( saveInBuf != null )
{
saveInBuf = null;
}
}
}
/// <summary> TranslateInputEOL -> translateEOL
///
/// Perform input EOL and EOF translation on the source buffer,
/// leaving the translated result in the destination buffer.
///
/// Results:
/// The return value is 1 if the EOF character was found when
/// copying bytes to the destination buffer, 0 otherwise.
///
/// </summary>
/// <param name="dstArray,">Output buffer to fill with translated bytes or chars.
/// </param>
/// <param name="dstStart,">First unused index in the dst output array.
/// </param>
/// <param name="srcArray,">Input buffer that holds the bytes or chars to translate
/// </param>
/// <param name="srcStart,">Index of first available byte in src array.
/// </param>
/// <param name="dstLenPtr,">On entry, the maximum length of output
/// buffer in bytes or chars; must be <= srcLenPtr.i. On
/// exit, the number of bytes or chars actually used in
/// output buffer.
/// </param>
/// <param name="srcLenPtr,">On entry, the length of source buffer.
/// On exit, the number of bytes or chars read from
/// the source buffer.
/// </param>
internal int translateEOL( System.Object dstArray, int dstStart, Object srcArray, int srcStart, IntPtr dstLenPtr, IntPtr srcLenPtr )
{
// Figure out if the srcArray and dstArray buffers
// are byte or char arrays.
bool isCharType;
char[] srcArrayChar, dstArrayChar;
byte[] srcArrayByte, dstArrayByte;
if ( ( srcArray is char[] ) && ( dstArray is char[] ) )
{
isCharType = true;
srcArrayChar = (char[])srcArray;
dstArrayChar = (char[])dstArray;
srcArrayByte = null;
dstArrayByte = null;
}
else if ( ( srcArray is byte[] ) && ( dstArray is byte[] ) )
{
isCharType = false;
srcArrayChar = null;
dstArrayChar = null;
srcArrayByte = (byte[])srcArray;
dstArrayByte = (byte[])dstArray;
}
else
{
throw new TclRuntimeError( "unknown array argument types" );
}
int dstLen, srcLen, inEofChar, index;
int eof;
dstLen = dstLenPtr.i;
eof = -1;
inEofChar = eofChar;
if ( inEofChar != '\x0000' )
{
// Find EOF in translated buffer then compress out the EOL. The
// source buffer may be much longer than the destination buffer --
// we only want to return EOF if the EOF has been copied to the
// destination buffer.
int src, srcMax;
srcMax = srcStart + srcLenPtr.i;
for ( src = srcStart; src < srcMax; src++ )
{
if ( isCharType )
{
index = srcArrayChar[src];
}
else
{
index = srcArrayByte[src];
}
if ( index == inEofChar )
{
eof = src;
srcLen = src - srcStart;
if ( srcLen < dstLen )
{
dstLen = srcLen;
}
srcLenPtr.i = srcLen;
break;
}
}
}
switch ( translation )
{
case TclIO.TRANS_LF:
{
if ( ( dstArray != srcArray ) || ( ( dstArray == srcArray ) && ( dstStart != srcStart ) ) )
{
Array.Copy( (System.Array)srcArray, srcStart, (System.Array)dstArray, dstStart, dstLen );
}
srcLen = dstLen;
break;
}
case TclIO.TRANS_CR:
{
int dst, dstEnd;
if ( ( dstArray != srcArray ) || ( ( dstArray == srcArray ) && ( dstStart != srcStart ) ) )
{
Array.Copy( (System.Array)srcArray, srcStart, (System.Array)dstArray, dstStart, dstLen );
}
dstEnd = dstStart + dstLen;
if ( isCharType )
{
for ( dst = dstStart; dst < dstEnd; dst++ )
{
if ( dstArrayChar[dst] == '\r' )
{
dstArrayChar[dst] = '\n';
}
}
}
else
{
for ( dst = dstStart; dst < dstEnd; dst++ )
{
if ( dstArrayByte[dst] == '\r' )
{
dstArrayByte[dst] = (byte)SupportClass.Identity( '\n' );
}
}
}
srcLen = dstLen;
break;
}
case TclIO.TRANS_CRLF:
{
int dst;
int src, srcEnd, srcMax;
dst = dstStart;
src = srcStart;
srcEnd = srcStart + dstLen;
srcMax = srcStart + srcLenPtr.i;
if ( isCharType )
{
for ( ; src < srcEnd; )
{
if ( srcArrayChar[src] == '\r' )
{
src++;
if ( src >= srcMax )
{
needNL = true;
}
else if ( srcArrayChar[src] == '\n' )
{
dstArrayChar[dst++] = srcArrayChar[src++];
}
else
{
dstArrayChar[dst++] = '\r';
}
}
else
{
dstArrayChar[dst++] = srcArrayChar[src++];
}
}
}
else
{
for ( ; src < srcEnd; )
{
if ( srcArrayByte[src] == '\r' )
{
src++;
if ( src >= srcMax )
{
needNL = true;
}
else if ( srcArrayByte[src] == '\n' )
{
dstArrayByte[dst++] = srcArrayByte[src++];
}
else
{
dstArrayByte[dst++] = (byte)SupportClass.Identity( '\r' );
}
}
else
{
dstArrayByte[dst++] = srcArrayByte[src++];
}
}
}
srcLen = src - srcStart;
dstLen = dst - dstStart;
break;
}
case TclIO.TRANS_AUTO:
{
int dst;
int src, srcEnd, srcMax;
dst = dstStart;
src = srcStart;
srcEnd = srcStart + dstLen;
srcMax = srcStart + srcLenPtr.i;
if ( sawCR_Renamed_Field && ( src < srcMax ) )
{
if ( isCharType )
{
index = srcArrayChar[src];
}
else
{
index = srcArrayByte[src];
}
if ( index == '\n' )
{
src++;
}
sawCR_Renamed_Field = false;
}
if ( isCharType )
{
for ( ; src < srcEnd; )
{
if ( srcArrayChar[src] == '\r' )
{
src++;
if ( src >= srcMax )
{
sawCR_Renamed_Field = true;
}
else if ( srcArrayChar[src] == '\n' )
{
if ( srcEnd < srcMax )
{
srcEnd++;
}
src++;
}
dstArrayChar[dst++] = '\n';
}
else
{
dstArrayChar[dst++] = srcArrayChar[src++];
}
}
}
else
{
for ( ; src < srcEnd; )
{
if ( srcArrayByte[src] == '\r' )
{
src++;
if ( src >= srcMax )
{
sawCR_Renamed_Field = true;
}
else if ( srcArrayByte[src] == '\n' )
{
if ( srcEnd < srcMax )
{
srcEnd++;
}
src++;
}
dstArrayByte[dst++] = (byte)SupportClass.Identity( '\n' );
}
else
{
dstArrayByte[dst++] = srcArrayByte[src++];
}
}
}
srcLen = src - srcStart;
dstLen = dst - dstStart;
break;
}
default:
{
throw new TclRuntimeError( "invalid translation" );
}
}
dstLenPtr.i = dstLen;
if ( ( eof != -1 ) && ( srcStart + srcLen >= eof ) )
{
// EOF character was seen in EOL translated range. Leave current
// file position pointing at the EOF character, but don't store the
// EOF character in the output string.
eofCond = true;
stickyEofCond = true;
encodingEnd = true;
sawCR_Renamed_Field = false;
needNL = false;
return 1;
}
srcLenPtr.i = srcLen;
return 0;
}
/// <summary> UpdateInterest -> updateInterest
///
/// Arrange for the notifier to call us back at appropriate times
/// based on the current state of the channel.
/// </summary>
internal void updateInterest()
{
// FIXME: Currently unimplemented
}
/// <summary> seekReset
///
/// Helper method used to reset state info when doing a seek.
/// </summary>
internal void seekReset()
{
discardQueued( false );
eofCond = false;
stickyEofCond = false;
blocked = false;
sawCR_Renamed_Field = false;
// FIXME: Change needed in Tcl
//needNL = false;
}
}
}