/// <summary> Sorts the list according to the sort mode and (optional) sort command.
/// The resulting list will contain no duplicates, if argument unique is
/// specifed as true.
/// If tobj is not a list object, an attempt will be made to
/// convert it to a list.
///
/// </summary>
/// <param name="interp">the current interpreter.
/// </param>
/// <param name="tobj">the list to sort.
/// </param>
/// <param name="sortMode">the sorting mode.
/// </param>
/// <param name="sortIncreasing">true if to sort the elements in increasing order.
/// </param>
/// <param name="command">the command to compute the order of two elements.
/// </param>
/// <param name="unique">true if the result should contain no duplicates.
/// </param>
/// <exception cref=""> TclException if tobj is not a valid list.
/// </exception>
internal static void sort(Interp interp, TclObject tobj, int sortMode, int sortIndex, bool sortIncreasing, string command, bool unique)
{
setListFromAny(interp, tobj);
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
int size = tlist.vector.Count;
if (size <= 1)
{
return;
}
TclObject[] objArray = new TclObject[size];
for (int i = 0; i < size; i++)
{
objArray[i] = (TclObject)tlist.vector[i];
}
QSort s = new QSort();
int newsize = s.sort(interp, objArray, sortMode, sortIndex, sortIncreasing, command, unique);
for (int i = 0; i < size; i++)
{
if (i < newsize)
{
tlist.vector[i] = objArray[i];
objArray[i] = null;
}
else
{
tlist.vector.RemoveAt(newsize);
}
}
}
/// <summary> Appends a string to a TclObject object. This method is equivalent to
/// Tcl_AppendToObj() in Tcl 8.0.
///
/// </summary>
/// <param name="tobj">the TclObject to append a string to.
/// </param>
/// <param name="string">the string to append to the object.
/// </param>
public static void append(TclObject tobj, string toAppend)
{
StringFromAny = tobj;
TclString tstr = (TclString)tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder(tobj.ToString());
}
tobj.invalidateStringRep();
tstr.sbuf.Append(toAppend);
}
/// <summary> Appends an array of characters to a TclObject Object.
/// Tcl_AppendUnicodeToObj() in Tcl 8.0.
///
/// </summary>
/// <param name="tobj">the TclObject to append a string to.
/// </param>
/// <param name="charArr">array of characters.
/// </param>
/// <param name="offset">index of first character to append.
/// </param>
/// <param name="length">number of characters to append.
/// </param>
public static void append(TclObject tobj, char[] charArr, int offset, int length)
{
StringFromAny = tobj;
TclString tstr = (TclString)tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder(tobj.ToString());
}
tobj.invalidateStringRep();
tstr.sbuf.Append(charArr, offset, length);
}
/// <summary> Tcl_ListObjAppendElement -> TclList.append()
///
/// Appends a TclObject element to a list object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to append an element to.
/// </param>
/// <param name="elemObj">the element to append to the object.
/// </param>
/// <exception cref=""> TclException if tobj cannot be converted into a list.
/// </exception>
public static void append(Interp interp, TclObject tobj, TclObject elemObj)
{
if (tobj.Shared)
{
throw new TclRuntimeError("TclList.append() called with shared object");
}
setListFromAny(interp, tobj);
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
elemObj.preserve();
tlist.vector.Add(elemObj);
}
// The new value for the object.
public static void set( TclObject tobj, double d )
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
if ( rep is TclDouble )
{
TclDouble tdouble = (TclDouble)rep;
tdouble.value = d;
}
else
{
tobj.InternalRep = new TclDouble( d );
}
}
/// <summary> Changes the object value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new object value.
/// </param>
public static void set(TclObject tobj, object o)
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclObj tint;
if (rep is TclObj)
{
tint = (TclObj)rep;
tint.value = o;
}
else
{
tobj.InternalRep = new TclObj(o);
}
}
/// <summary> Changes the long value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new long value.
/// </param>
public static void set(TclObject tobj, long i)
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclLong tlong;
if (rep is TclLong)
{
tlong = (TclLong)rep;
tlong.value = i;
}
else
{
tobj.InternalRep = new TclLong(i);
}
}
/// <summary> Changes the integer value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new integer value.
/// </param>
public static void set(TclObject tobj, int i)
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclInteger tint;
if (rep is TclInteger)
{
tint = (TclInteger)rep;
tint.value = i;
}
else
{
tobj.InternalRep = new TclInteger(i);
}
}
/// <summary> Changes the object value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new object value.
/// </param>
public static void set( TclObject tobj, object o )
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclObj tint;
if ( rep is TclObj )
{
tint = (TclObj)rep;
tint.value = o;
}
else
{
tobj.InternalRep = new TclObj( o );
}
}
public static void set(TclObject tobj, double d)
// The new value for the object.
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
if (rep is TclDouble)
{
TclDouble tdouble = (TclDouble)rep;
tdouble.value = d;
}
else
{
tobj.InternalRep = new TclDouble(d);
}
}
/// <summary> This procedure clears out an existing TclObject so
/// that it has a string representation of "".
/// </summary>
public static void empty(TclObject tobj)
{
StringFromAny = tobj;
TclString tstr = (TclString)tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder();
}
else
{
tstr.sbuf.Length = 0;
}
tobj.invalidateStringRep();
}
/// <summary> Tcl_ListObjAppendElement -> TclList.append()
///
/// Appends a TclObject element to a list object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to append an element to.
/// </param>
/// <param name="elemObj">the element to append to the object.
/// </param>
/// <exception cref=""> TclException if tobj cannot be converted into a list.
/// </exception>
public static void append(Interp interp, TclObject tobj, TclObject elemObj)
{
if (tobj.Shared)
{
throw new TclRuntimeError("TclList.append() called with shared object");
}
setListFromAny(interp, tobj);
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
if (!String.IsNullOrEmpty(elemObj.stringRep) && elemObj.stringRep[0] == '{')
{
elemObj = TclString.newInstance(elemObj.stringRep.Substring(1, elemObj.stringRep.Length - 2));
}
elemObj.preserve();
tlist.vector.Add(elemObj);
}
/// <summary>
/// This method changes the length of the byte array for this
/// object. Once the caller has set the length of the array, it
/// is acceptable to directly modify the bytes in the array up until
/// Tcl_GetStringFromObj() has been called on this object.
///
/// Results:
/// The new byte array of the specified length.
///
/// Side effects:
/// Allocates enough memory for an array of bytes of the requested
/// size. When growing the array, the old array is copied to the
/// new array; new bytes are undefined. When shrinking, the
/// old array is truncated to the specified length.
/// </summary>
public static byte[] setLength(Interp interp, TclObject tobj, int length)
{
if (tobj.Shared)
{
throw new TclRuntimeError("TclByteArray.setLength() called with shared object");
}
setByteArrayFromAny(interp, tobj);
TclByteArray tbyteArray = (TclByteArray)tobj.InternalRep;
if (length > tbyteArray.bytes.Length)
{
byte[] newBytes = new byte[length];
Array.Copy(tbyteArray.bytes, 0, newBytes, 0, tbyteArray.used);
tbyteArray.bytes = newBytes;
}
tobj.invalidateStringRep();
tbyteArray.used = length;
return(tbyteArray.bytes);
}
/// <summary> This procedure replaces zero or more elements of the list
/// referenced by tobj with the objects from an TclObject array.
/// If tobj is not a list object, an attempt will be made to
/// convert it to a list.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to use as a list.
/// </param>
/// <param name="index">the starting index of the replace operation. <=0 means
/// the beginning of the list. >= TclList.getLength(tobj) means
/// the end of the list.
/// </param>
/// <param name="count">the number of elements to delete from the list. <=0 means
/// no elements should be deleted and the operation is equivalent to
/// an insertion operation.
/// </param>
/// <param name="elements">the element(s) to insert.
/// </param>
/// <param name="from">insert elements starting from elements[from] (inclusive)
/// </param>
/// <param name="to">insert elements up to elements[to] (inclusive)
/// </param>
/// <exception cref=""> TclException if tobj is not a valid list.
/// </exception>
public static void replace(Interp interp, TclObject tobj, int index, int count, TclObject[] elements, int from, int to)
{
if (tobj.Shared)
{
throw new TclRuntimeError("TclList.replace() called with shared object");
}
setListFromAny(interp, tobj);
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
int size = tlist.vector.Count;
int i;
if (index >= size)
{
// Append to the end of the list. There is no need for deleting
// elements.
index = size;
}
else
{
if (index < 0)
{
index = 0;
}
if (count > size - index)
{
count = size - index;
}
for (i = 0; i < count; i++)
{
TclObject obj = (TclObject)tlist.vector[index];
obj.release();
tlist.vector.RemoveAt(index);
}
}
for (i = from; i <= to; i++)
{
elements[i].preserve();
tlist.vector.Insert(index++, elements[i]);
}
}
/// <summary> Changes the long value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new long value.
/// </param>
public static void set( TclObject tobj, long i )
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclLong tlong;
if ( rep is TclLong )
{
tlong = (TclLong)rep;
tlong.value = i;
}
else
{
tobj.InternalRep = new TclLong( i );
}
}
/// <summary>
/// This method changes the length of the byte array for this
/// object. Once the caller has set the length of the array, it
/// is acceptable to directly modify the bytes in the array up until
/// Tcl_GetStringFromObj() has been called on this object.
///
/// Results:
/// The new byte array of the specified length.
///
/// Side effects:
/// Allocates enough memory for an array of bytes of the requested
/// size. When growing the array, the old array is copied to the
/// new array; new bytes are undefined. When shrinking, the
/// old array is truncated to the specified length.
/// </summary>
public static byte[] setLength(Interp interp, TclObject tobj, int length)
{
if (tobj.Shared)
{
throw new TclRuntimeError("TclByteArray.setLength() called with shared object");
}
setByteArrayFromAny(interp, tobj);
TclByteArray tbyteArray = (TclByteArray) tobj.InternalRep;
if (length > tbyteArray.bytes.Length)
{
byte[] newBytes = new byte[length];
Array.Copy(tbyteArray.bytes, 0, newBytes, 0, tbyteArray.used);
tbyteArray.bytes = newBytes;
}
tobj.invalidateStringRep();
tbyteArray.used = length;
return tbyteArray.bytes;
}
/// <summary> Sorts the list according to the sort mode and (optional) sort command.
/// The resulting list will contain no duplicates, if argument unique is
/// specifed as true.
/// If tobj is not a list object, an attempt will be made to
/// convert it to a list.
///
/// </summary>
/// <param name="interp">the current interpreter.
/// </param>
/// <param name="tobj">the list to sort.
/// </param>
/// <param name="sortMode">the sorting mode.
/// </param>
/// <param name="sortIncreasing">true if to sort the elements in increasing order.
/// </param>
/// <param name="command">the command to compute the order of two elements.
/// </param>
/// <param name="unique">true if the result should contain no duplicates.
/// </param>
/// <exception cref=""> TclException if tobj is not a valid list.
/// </exception>
internal static void sort( Interp interp, TclObject tobj, int sortMode, int sortIndex, bool sortIncreasing, string command, bool unique )
{
setListFromAny( interp, tobj );
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
int size = tlist.vector.Count;
if ( size <= 1 )
{
return;
}
TclObject[] objArray = new TclObject[size];
for ( int i = 0 ; i < size ; i++ )
{
objArray[i] = (TclObject)tlist.vector[i];
}
QSort s = new QSort();
int newsize = s.sort( interp, objArray, sortMode, sortIndex, sortIncreasing, command, unique );
for ( int i = 0 ; i < size ; i++ )
{
if ( i < newsize )
{
tlist.vector[i] = objArray[i];
objArray[i] = null;
}
else tlist.vector.RemoveAt( newsize );
}
}
/// <summary> This procedure replaces zero or more elements of the list
/// referenced by tobj with the objects from an TclObject array.
/// If tobj is not a list object, an attempt will be made to
/// convert it to a list.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to use as a list.
/// </param>
/// <param name="index">the starting index of the replace operation. <=0 means
/// the beginning of the list. >= TclList.getLength(tobj) means
/// the end of the list.
/// </param>
/// <param name="count">the number of elements to delete from the list. <=0 means
/// no elements should be deleted and the operation is equivalent to
/// an insertion operation.
/// </param>
/// <param name="elements">the element(s) to insert.
/// </param>
/// <param name="from">insert elements starting from elements[from] (inclusive)
/// </param>
/// <param name="to">insert elements up to elements[to] (inclusive)
/// </param>
/// <exception cref=""> TclException if tobj is not a valid list.
/// </exception>
public static void replace( Interp interp, TclObject tobj, int index, int count, TclObject[] elements, int from, int to )
{
if ( tobj.Shared )
{
throw new TclRuntimeError( "TclList.replace() called with shared object" );
}
setListFromAny( interp, tobj );
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
int size = tlist.vector.Count;
int i;
if ( index >= size )
{
// Append to the end of the list. There is no need for deleting
// elements.
index = size;
}
else
{
if ( index < 0 )
{
index = 0;
}
if ( count > size - index )
{
count = size - index;
}
for ( i = 0 ; i < count ; i++ )
{
TclObject obj = (TclObject)tlist.vector[index];
obj.release();
tlist.vector.RemoveAt( index );
}
}
for ( i = from ; i <= to ; i++ )
{
elements[i].preserve();
tlist.vector.Insert( index++, elements[i] );
}
}
/// <summary> Tcl_ListObjAppendElement -> TclList.append()
///
/// Appends a TclObject element to a list object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to append an element to.
/// </param>
/// <param name="elemObj">the element to append to the object.
/// </param>
/// <exception cref=""> TclException if tobj cannot be converted into a list.
/// </exception>
public static void append( Interp interp, TclObject tobj, TclObject elemObj )
{
if ( tobj.Shared )
{
throw new TclRuntimeError( "TclList.append() called with shared object" );
}
setListFromAny( interp, tobj );
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
if ( !String.IsNullOrEmpty( elemObj.stringRep ) && elemObj.stringRep[0] == '{' ) elemObj = TclString.newInstance( elemObj.stringRep.Substring( 1, elemObj.stringRep.Length - 2 ) );
elemObj.preserve();
tlist.vector.Add( elemObj );
}
/// <summary> Appends an array of characters to a TclObject Object.
/// Tcl_AppendUnicodeToObj() in Tcl 8.0.
///
/// </summary>
/// <param name="tobj">the TclObject to append a string to.
/// </param>
/// <param name="charArr">array of characters.
/// </param>
/// <param name="offset">index of first character to append.
/// </param>
/// <param name="length">number of characters to append.
/// </param>
public static void append(TclObject tobj, char[] charArr, int offset, int length)
{
StringFromAny = tobj;
TclString tstr = (TclString) tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder(tobj.ToString());
}
tobj.invalidateStringRep();
tstr.sbuf.Append(charArr, offset, length);
}
/// <summary> Appends a string to a TclObject object. This method is equivalent to
/// Tcl_AppendToObj() in Tcl 8.0.
///
/// </summary>
/// <param name="tobj">the TclObject to append a string to.
/// </param>
/// <param name="string">the string to append to the object.
/// </param>
public static void append(TclObject tobj, string toAppend)
{
StringFromAny = tobj;
TclString tstr = (TclString) tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder(tobj.ToString());
}
tobj.invalidateStringRep();
tstr.sbuf.Append( toAppend );
}
/// <summary> Changes the integer value of the object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the object to operate on.
/// @paran i the new integer value.
/// </param>
public static void set( TclObject tobj, int i )
{
tobj.invalidateStringRep();
InternalRep rep = tobj.InternalRep;
TclInteger tint;
if ( rep is TclInteger )
{
tint = (TclInteger)rep;
tint.value = i;
}
else
{
tobj.InternalRep = new TclInteger( i );
}
}
/// <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> Tcl_ListObjAppendElement -> TclList.append()
///
/// Appends a TclObject element to a list object.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to append an element to.
/// </param>
/// <param name="elemObj">the element to append to the object.
/// </param>
/// <exception cref=""> TclException if tobj cannot be converted into a list.
/// </exception>
public static void append( Interp interp, TclObject tobj, TclObject elemObj )
{
if ( tobj.Shared )
{
throw new TclRuntimeError( "TclList.append() called with shared object" );
}
setListFromAny( interp, tobj );
tobj.invalidateStringRep();
TclList tlist = (TclList)tobj.InternalRep;
elemObj.preserve();
tlist.vector.Add( elemObj );
}
/// <summary> This procedure clears out an existing TclObject so
/// that it has a string representation of "".
/// </summary>
public static void empty(TclObject tobj)
{
StringFromAny = tobj;
TclString tstr = (TclString) tobj.InternalRep;
if (tstr.sbuf == null)
{
tstr.sbuf = new System.Text.StringBuilder();
}
else
{
tstr.sbuf.Length = 0;
}
tobj.invalidateStringRep();
}
