wasCSharpSQLite – Rev 1
?pathlinks?
/*
* StringCmd.java
*
* Copyright (c) 1997 Cornell University.
* Copyright (c) 1997 Sun Microsystems, Inc.
* Copyright (c) 1998-2000 Scriptics Corporation.
* Copyright (c) 2000 Christian Krone.
*
* 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: StringCmd.java,v 1.4 2000/08/20 08:37:47 mo Exp $
*
*/
using System.Text;
namespace tcl.lang
{
/// <summary> This class implements the built-in "string" command in Tcl.</summary>
class StringCmd : Command
{
private static readonly string[] options = new string[] { "bytelength", "compare", "equal", "first", "index", "is", "last", "length", "map", "match", "range", "repeat", "replace", "tolower", "toupper", "totitle", "trim", "trimleft", "trimright", "wordend", "wordstart" };
private const int STR_BYTELENGTH = 0;
private const int STR_COMPARE = 1;
private const int STR_EQUAL = 2;
private const int STR_FIRST = 3;
private const int STR_INDEX = 4;
private const int STR_IS = 5;
private const int STR_LAST = 6;
private const int STR_LENGTH = 7;
private const int STR_MAP = 8;
private const int STR_MATCH = 9;
private const int STR_RANGE = 10;
private const int STR_REPEAT = 11;
private const int STR_REPLACE = 12;
private const int STR_TOLOWER = 13;
private const int STR_TOUPPER = 14;
private const int STR_TOTITLE = 15;
private const int STR_TRIM = 16;
private const int STR_TRIMLEFT = 17;
private const int STR_TRIMRIGHT = 18;
private const int STR_WORDEND = 19;
private const int STR_WORDSTART = 20;
private static readonly string[] isOptions = new string[] { "alnum", "alpha", "ascii", "control", "boolean", "digit", "double", "false", "graph", "integer", "lower", "print", "punct", "space", "true", "upper", "wideinteger", "wordchar", "xdigit" };
private const int STR_IS_ALNUM = 0;
private const int STR_IS_ALPHA = 1;
private const int STR_IS_ASCII = 2;
private const int STR_IS_CONTROL = 3;
private const int STR_IS_BOOL = 4;
private const int STR_IS_DIGIT = 5;
private const int STR_IS_DOUBLE = 6;
private const int STR_IS_FALSE = 7;
private const int STR_IS_GRAPH = 8;
private const int STR_IS_INT = 9;
private const int STR_IS_LOWER = 10;
private const int STR_IS_PRINT = 11;
private const int STR_IS_PUNCT = 12;
private const int STR_IS_SPACE = 13;
private const int STR_IS_TRUE = 14;
private const int STR_IS_UPPER = 15;
private const int STR_IS_WIDE = 16;
private const int STR_IS_WORD = 17;
private const int STR_IS_XDIGIT = 18;
/// <summary> Java's Character class has a many boolean test functions to check
/// the kind of a character (like isLowerCase() or isISOControl()).
/// Unfortunately some are missing (like isPunct() or isPrint()), so
/// here we define bitsets to compare the result of Character.getType().
/// </summary>
private static readonly int ALPHA_BITS = ( ( 1 << (byte)System.Globalization.UnicodeCategory.UppercaseLetter ) | ( 1 << (byte)System.Globalization.UnicodeCategory.LowercaseLetter ) | ( 1 << (byte)System.Globalization.UnicodeCategory.TitlecaseLetter ) | ( 1 << (byte)System.Globalization.UnicodeCategory.ModifierLetter ) | ( 1 << (byte)System.Globalization.UnicodeCategory.OtherLetter ) );
private static readonly int PUNCT_BITS = ( ( 1 << (byte)System.Globalization.UnicodeCategory.ConnectorPunctuation ) | ( 1 << (byte)System.Globalization.UnicodeCategory.DashPunctuation ) | ( 1 << (byte)System.Globalization.UnicodeCategory.InitialQuotePunctuation ) | ( 1 << (byte)System.Globalization.UnicodeCategory.FinalQuotePunctuation ) | ( 1 << (byte)System.Globalization.UnicodeCategory.OtherPunctuation ) );
private static readonly int PRINT_BITS = ( ALPHA_BITS | ( 1 << (byte)System.Globalization.UnicodeCategory.DecimalDigitNumber ) | ( 1 << (byte)System.Globalization.UnicodeCategory.SpaceSeparator ) | ( 1 << (byte)System.Globalization.UnicodeCategory.LineSeparator ) | ( 1 << (byte)System.Globalization.UnicodeCategory.ParagraphSeparator ) | ( 1 << (byte)System.Globalization.UnicodeCategory.NonSpacingMark ) | ( 1 << (byte)System.Globalization.UnicodeCategory.EnclosingMark ) | ( 1 << (byte)System.Globalization.UnicodeCategory.SpacingCombiningMark ) | ( 1 << (byte)System.Globalization.UnicodeCategory.LetterNumber ) | ( 1 << (byte)System.Globalization.UnicodeCategory.OtherNumber ) | PUNCT_BITS | ( 1 << (byte)System.Globalization.UnicodeCategory.MathSymbol ) | ( 1 << (byte)System.Globalization.UnicodeCategory.CurrencySymbol ) | ( 1 << (byte)System.Globalization.UnicodeCategory.ModifierSymbol ) | ( 1 << (byte)System.Globalization.UnicodeCategory.OtherSymbol ) );
private static readonly int WORD_BITS = ( ALPHA_BITS | ( 1 << (byte)System.Globalization.UnicodeCategory.DecimalDigitNumber ) | ( 1 << (byte)System.Globalization.UnicodeCategory.ConnectorPunctuation ) );
/// <summary>----------------------------------------------------------------------
///
/// Tcl_StringObjCmd -> StringCmd.cmdProc
///
/// This procedure is invoked to process the "string" Tcl command.
/// See the user documentation for details on what it does.
///
/// Results:
/// None.
///
/// Side effects:
/// See the user documentation.
///
/// ----------------------------------------------------------------------
/// </summary>
public TCL.CompletionCode cmdProc( Interp interp, TclObject[] objv )
{
if ( objv.Length < 2 )
{
throw new TclNumArgsException( interp, 1, objv, "option arg ?arg ...?" );
}
int index = TclIndex.get( interp, objv[1], options, "option", 0 );
switch ( index )
{
case STR_EQUAL:
case STR_COMPARE:
{
if ( objv.Length < 4 || objv.Length > 7 )
{
throw new TclNumArgsException( interp, 2, objv, "?-nocase? ?-length int? string1 string2" );
}
bool nocase = false;
int reqlength = -1;
for ( int i = 2; i < objv.Length - 2; i++ )
{
string string2 = objv[i].ToString();
int length2 = string2.Length;
if ( ( length2 > 1 ) && "-nocase".StartsWith( string2 ) )
{
nocase = true;
}
else if ( ( length2 > 1 ) && "-length".StartsWith( string2 ) )
{
if ( i + 1 >= objv.Length - 2 )
{
throw new TclNumArgsException( interp, 2, objv, "?-nocase? ?-length int? string1 string2" );
}
reqlength = TclInteger.get( interp, objv[++i] );
}
else
{
throw new TclException( interp, "bad option \"" + string2 + "\": must be -nocase or -length" );
}
}
string string1 = objv[objv.Length - 2].ToString();
string string3 = objv[objv.Length - 1].ToString();
int length1 = string1.Length;
int length3 = string3.Length;
// This is the min length IN BYTES of the two strings
int length = ( length1 < length3 ) ? length1 : length3;
int match;
if ( reqlength == 0 )
{
// Anything matches at 0 chars, right?
match = 0;
}
else if ( nocase || ( ( reqlength > 0 ) && ( reqlength <= length ) ) )
{
// In Java, strings are always encoded in unicode, so we do
// not need to worry about individual char lengths
// Do the reqlength check again, against 0 as well for
// the benfit of nocase
if ( ( reqlength > 0 ) && ( reqlength < length ) )
{
length = reqlength;
}
else if ( reqlength < 0 )
{
// The requested length is negative, so we ignore it by
// setting it to the longer of the two lengths.
reqlength = ( length1 > length3 ) ? length1 : length3;
}
if ( nocase )
{
string1 = string1.ToLower();
string3 = string3.ToLower();
}
match = System.Globalization.CultureInfo.InvariantCulture.CompareInfo.Compare( string1, 0, length, string3, 0, length, System.Globalization.CompareOptions.Ordinal );
// match = string1.Substring(0, (length) - (0)).CompareTo(string3.Substring(0, (length) - (0)));
if ( ( match == 0 ) && ( reqlength > length ) )
{
match = length1 - length3;
}
}
else
{
match = System.Globalization.CultureInfo.InvariantCulture.CompareInfo.Compare( string1, 0, length, string3, 0, length, System.Globalization.CompareOptions.Ordinal );
// ATK match = string1.Substring(0, (length) - (0)).CompareTo(string3.Substring(0, (length) - (0)));
if ( match == 0 )
{
match = length1 - length3;
}
}
if ( index == STR_EQUAL )
{
interp.setResult( ( match != 0 ) ? false : true );
}
else
{
interp.setResult( ( ( match > 0 ) ? 1 : ( match < 0 ) ? -1 : 0 ) );
}
break;
}
case STR_FIRST:
{
if ( objv.Length < 4 || objv.Length > 5 )
{
throw new TclNumArgsException( interp, 2, objv, "subString string ?startIndex?" );
}
string string1 = objv[2].ToString();
string string2 = objv[3].ToString();
int length2 = string2.Length;
int start = 0;
if ( objv.Length == 5 )
{
// If a startIndex is specified, we will need to fast
// forward to that point in the string before we think
// about a match.
start = Util.getIntForIndex( interp, objv[4], length2 - 1 );
if ( start >= length2 )
{
interp.setResult( -1 );
return TCL.CompletionCode.RETURN;
}
}
if ( string1.Length == 0 )
{
interp.setResult( -1 );
}
else
{
interp.setResult( string2.IndexOf( string1, start ) );
}
break;
}
case STR_INDEX:
{
if ( objv.Length != 4 )
{
throw new TclNumArgsException( interp, 2, objv, "string charIndex" );
}
string string1 = objv[2].ToString();
int length1 = string1.Length;
int i = Util.getIntForIndex( interp, objv[3], length1 - 1 );
if ( ( i >= 0 ) && ( i < length1 ) )
{
interp.setResult( string1.Substring( i, ( i + 1 ) - ( i ) ) );
}
break;
}
case STR_IS:
{
if ( objv.Length < 4 || objv.Length > 7 )
{
throw new TclNumArgsException( interp, 2, objv, "class ?-strict? ?-failindex var? str" );
}
index = TclIndex.get( interp, objv[2], isOptions, "class", 0 );
bool strict = false;
TclObject failVarObj = null;
if ( objv.Length != 4 )
{
for ( int i = 3; i < objv.Length - 1; i++ )
{
string string2 = objv[i].ToString();
int length2 = string2.Length;
if ( ( length2 > 1 ) && "-strict".StartsWith( string2 ) )
{
strict = true;
}
else if ( ( length2 > 1 ) && "-failindex".StartsWith( string2 ) )
{
if ( i + 1 >= objv.Length - 1 )
{
throw new TclNumArgsException( interp, 3, objv, "?-strict? ?-failindex var? str" );
}
failVarObj = objv[++i];
}
else
{
throw new TclException( interp, "bad option \"" + string2 + "\": must be -strict or -failindex" );
}
}
}
bool result = true;
int failat = 0;
// We get the objPtr so that we can short-cut for some classes
// by checking the object type (int and double), but we need
// the string otherwise, because we don't want any conversion
// of type occuring (as, for example, Tcl_Get*FromObj would do
TclObject obj = objv[objv.Length - 1];
string string1 = obj.ToString();
int length1 = string1.Length;
if ( length1 == 0 )
{
if ( strict )
{
result = false;
}
}
switch ( index )
{
case STR_IS_BOOL:
case STR_IS_TRUE:
case STR_IS_FALSE:
{
if ( obj.InternalRep is TclBoolean )
{
if ( ( ( index == STR_IS_TRUE ) && !TclBoolean.get( interp, obj ) ) || ( ( index == STR_IS_FALSE ) && TclBoolean.get( interp, obj ) ) )
{
result = false;
}
}
else
{
try
{
bool i = TclBoolean.get( null, obj );
if ( ( ( index == STR_IS_TRUE ) && !i ) || ( ( index == STR_IS_FALSE ) && i ) )
{
result = false;
}
}
catch ( TclException e )
{
result = false;
}
}
break;
}
case STR_IS_DOUBLE:
{
if ( ( obj.InternalRep is TclDouble ) || ( obj.InternalRep is TclInteger ) )
{
break;
}
// This is adapted from Tcl_GetDouble
//
// The danger in this function is that
// "12345678901234567890" is an acceptable 'double',
// but will later be interp'd as an int by something
// like [expr]. Therefore, we check to see if it looks
// like an int, and if so we do a range check on it.
// If strtoul gets to the end, we know we either
// received an acceptable int, or over/underflow
if ( Expression.looksLikeInt( string1, length1, 0 ) )
{
char c = string1[0];
int signIx = ( c == '-' || c == '+' ) ? 1 : 0;
StrtoulResult res = Util.strtoul( string1, signIx, 0 );
if ( res.index == length1 )
{
if ( res.errno == TCL.INTEGER_RANGE )
{
result = false;
failat = -1;
}
break;
}
}
char c2 = string1[0];
int signIx2 = ( c2 == '-' || c2 == '+' ) ? 1 : 0;
StrtodResult res2 = Util.strtod( string1, signIx2 );
if ( res2.errno == TCL.DOUBLE_RANGE )
{
// if (errno == ERANGE), then it was an over/underflow
// problem, but in this method, we only want to know
// yes or no, so bad flow returns 0 (false) and sets
// the failVarObj to the string length.
result = false;
failat = -1;
}
else if ( res2.index == 0 )
{
// In this case, nothing like a number was found
result = false;
failat = 0;
}
else
{
// Go onto SPACE, since we are
// allowed trailing whitespace
failat = res2.index;
for ( int i = res2.index; i < length1; i++ )
{
if ( !System.Char.IsWhiteSpace( string1[i] ) )
{
result = false;
break;
}
}
}
break;
}
case STR_IS_INT:
{
if ( obj.InternalRep is TclInteger )
{
break;
}
bool isInteger = true;
try
{
TclInteger.get( null, obj );
}
catch ( TclException e )
{
isInteger = false;
}
if ( isInteger )
{
break;
}
char c = string1[0];
int signIx = ( c == '-' || c == '+' ) ? 1 : 0;
StrtoulResult res = Util.strtoul( string1, signIx, 0 );
if ( res.errno == TCL.INTEGER_RANGE )
{
// if (errno == ERANGE), then it was an over/underflow
// problem, but in this method, we only want to know
// yes or no, so bad flow returns false and sets
// the failVarObj to the string length.
result = false;
failat = -1;
}
else if ( res.index == 0 )
{
// In this case, nothing like a number was found
result = false;
failat = 0;
}
else
{
// Go onto SPACE, since we are
// allowed trailing whitespace
failat = res.index;
for ( int i = res.index; i < length1; i++ )
{
if ( !System.Char.IsWhiteSpace( string1[i] ) )
{
result = false;
break;
}
}
}
break;
}
case STR_IS_WIDE:
{
if ( obj.InternalRep is TclLong )
{
break;
}
bool isInteger = true;
try
{
TclLong.get( null, obj );
}
catch ( TclException e )
{
isInteger = false;
}
if ( isInteger )
{
break;
}
char c = string1[0];
int signIx = ( c == '-' || c == '+' ) ? 1 : 0;
StrtoulResult res = Util.strtoul( string1, signIx, 0 );
if ( res.errno == TCL.INTEGER_RANGE )
{
// if (errno == ERANGE), then it was an over/underflow
// problem, but in this method, we only want to know
// yes or no, so bad flow returns false and sets
// the failVarObj to the string length.
result = false;
failat = -1;
}
else if ( res.index == 0 )
{
// In this case, nothing like a number was found
result = false;
failat = 0;
}
else
{
// Go onto SPACE, since we are
// allowed trailing whitespace
failat = res.index;
for ( int i = res.index; i < length1; i++ )
{
if ( !System.Char.IsWhiteSpace( string1[i] ) )
{
result = false;
break;
}
}
}
break;
}
default:
{
for ( failat = 0; failat < length1; failat++ )
{
char c = string1[failat];
switch ( index )
{
case STR_IS_ASCII:
result = c < 0x80;
break;
case STR_IS_ALNUM:
result = System.Char.IsLetterOrDigit( c );
break;
case STR_IS_ALPHA:
result = System.Char.IsLetter( c );
break;
case STR_IS_DIGIT:
result = System.Char.IsDigit( c );
break;
case STR_IS_GRAPH:
result = ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & PRINT_BITS ) != 0 && c != ' ';
break;
case STR_IS_PRINT:
result = ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & PRINT_BITS ) != 0;
break;
case STR_IS_PUNCT:
result = ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & PUNCT_BITS ) != 0;
break;
case STR_IS_UPPER:
result = System.Char.IsUpper( c );
break;
case STR_IS_SPACE:
result = System.Char.IsWhiteSpace( c );
break;
case STR_IS_CONTROL:
result = ( System.Char.GetUnicodeCategory( c ) == System.Globalization.UnicodeCategory.Control );
break;
case STR_IS_LOWER:
result = System.Char.IsLower( c );
break;
case STR_IS_WORD:
result = ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & WORD_BITS ) != 0;
break;
case STR_IS_XDIGIT:
result = "0123456789ABCDEFabcdef".IndexOf( c ) >= 0;
break;
default:
throw new TclRuntimeError( "unimplemented" );
}
if ( !result )
{
break;
}
}
}
break;
}
// Only set the failVarObj when we will return 0
// and we have indicated a valid fail index (>= 0)
if ( ( !result ) && ( failVarObj != null ) )
{
interp.setVar( failVarObj, TclInteger.newInstance( failat ), 0 );
}
interp.setResult( result );
break;
}
case STR_LAST:
{
if ( objv.Length < 4 || objv.Length > 5 )
{
throw new TclNumArgsException( interp, 2, objv, "subString string ?startIndex?" );
}
string string1 = objv[2].ToString();
string string2 = objv[3].ToString();
int length2 = string2.Length;
int start = 0;
if ( objv.Length == 5 )
{
// If a startIndex is specified, we will need to fast
// forward to that point in the string before we think
// about a match.
start = Util.getIntForIndex( interp, objv[4], length2 - 1 );
if ( start < 0 )
{
interp.setResult( -1 );
break;
}
else if ( start < length2 )
{
string2 = string2.Substring( 0, ( start + 1 ) - ( 0 ) );
}
}
if ( string1.Length == 0 )
{
interp.setResult( -1 );
}
else
{
interp.setResult( string2.LastIndexOf( string1 ) );
}
break;
}
case STR_BYTELENGTH:
if ( objv.Length != 3 )
{
throw new TclNumArgsException( interp, 2, objv, "string" );
}
interp.setResult( Utf8Count( objv[2].ToString() ) );
break;
case STR_LENGTH:
{
if ( objv.Length != 3 )
{
throw new TclNumArgsException( interp, 2, objv, "string" );
}
interp.setResult( objv[2].ToString().Length );
break;
}
case STR_MAP:
{
if ( objv.Length < 4 || objv.Length > 5 )
{
throw new TclNumArgsException( interp, 2, objv, "?-nocase? charMap string" );
}
bool nocase = false;
if ( objv.Length == 5 )
{
string string2 = objv[2].ToString();
int length2 = string2.Length;
if ( ( length2 > 1 ) && "-nocase".StartsWith( string2 ) )
{
nocase = true;
}
else
{
throw new TclException( interp, "bad option \"" + string2 + "\": must be -nocase" );
}
}
TclObject[] mapElemv = TclList.getElements( interp, objv[objv.Length - 2] );
if ( mapElemv.Length == 0 )
{
// empty charMap, just return whatever string was given
interp.setResult( objv[objv.Length - 1] );
}
else if ( ( mapElemv.Length % 2 ) != 0 )
{
// The charMap must be an even number of key/value items
throw new TclException( interp, "char map list unbalanced" );
}
string string1 = objv[objv.Length - 1].ToString();
string cmpString1;
if ( nocase )
{
cmpString1 = string1.ToLower();
}
else
{
cmpString1 = string1;
}
int length1 = string1.Length;
if ( length1 == 0 )
{
// Empty input string, just stop now
break;
}
// Precompute pointers to the unicode string and length.
// This saves us repeated function calls later,
// significantly speeding up the algorithm.
string[] mapStrings = new string[mapElemv.Length];
int[] mapLens = new int[mapElemv.Length];
for ( int ix = 0; ix < mapElemv.Length; ix++ )
{
mapStrings[ix] = mapElemv[ix].ToString();
mapLens[ix] = mapStrings[ix].Length;
}
string[] cmpStrings;
if ( nocase )
{
cmpStrings = new string[mapStrings.Length];
for ( int ix = 0; ix < mapStrings.Length; ix++ )
{
cmpStrings[ix] = mapStrings[ix].ToLower();
}
}
else
{
cmpStrings = mapStrings;
}
TclObject result = TclString.newInstance( "" );
int p, str1;
for ( p = 0, str1 = 0; str1 < length1; str1++ )
{
for ( index = 0; index < mapStrings.Length; index += 2 )
{
// Get the key string to match on
string string2 = mapStrings[index];
int length2 = mapLens[index];
if ( ( length2 > 0 ) && ( cmpString1.Substring( str1 ).StartsWith( cmpStrings[index] ) ) )
{
if ( p != str1 )
{
// Put the skipped chars onto the result first
TclString.append( result, string1.Substring( p, ( str1 ) - ( p ) ) );
p = str1 + length2;
}
else
{
p += length2;
}
// Adjust len to be full length of matched string
str1 = p - 1;
// Append the map value to the unicode string
TclString.append( result, mapStrings[index + 1] );
break;
}
}
}
if ( p != str1 )
{
// Put the rest of the unmapped chars onto result
TclString.append( result, string1.Substring( p, ( str1 ) - ( p ) ) );
}
interp.setResult( result );
break;
}
case STR_MATCH:
{
if ( objv.Length < 4 || objv.Length > 5 )
{
throw new TclNumArgsException( interp, 2, objv, "?-nocase? pattern string" );
}
string string1, string2;
if ( objv.Length == 5 )
{
string inString = objv[2].ToString();
if ( !( ( inString.Length > 1 ) && "-nocase".StartsWith( inString ) ) )
{
throw new TclException( interp, "bad option \"" + inString + "\": must be -nocase" );
}
string1 = objv[4].ToString().ToLower();
string2 = objv[3].ToString().ToLower();
}
else
{
string1 = objv[3].ToString();
string2 = objv[2].ToString();
}
interp.setResult( Util.stringMatch( string1, string2 ) );
break;
}
case STR_RANGE:
{
if ( objv.Length != 5 )
{
throw new TclNumArgsException( interp, 2, objv, "string first last" );
}
string string1 = objv[2].ToString();
int length1 = string1.Length;
int first = Util.getIntForIndex( interp, objv[3], length1 - 1 );
if ( first < 0 )
{
first = 0;
}
int last = Util.getIntForIndex( interp, objv[4], length1 - 1 );
if ( last >= length1 )
{
last = length1 - 1;
}
if ( first > last )
{
interp.resetResult();
}
else
{
interp.setResult( string1.Substring( first, ( last + 1 ) - ( first ) ) );
}
break;
}
case STR_REPEAT:
{
if ( objv.Length != 4 )
{
throw new TclNumArgsException( interp, 2, objv, "string count" );
}
int count = TclInteger.get( interp, objv[3] );
string string1 = objv[2].ToString();
if ( string1.Length > 0 )
{
TclObject tstr = TclString.newInstance( "" );
for ( index = 0; index < count; index++ )
{
TclString.append( tstr, string1 );
}
interp.setResult( tstr );
}
break;
}
case STR_REPLACE:
{
if ( objv.Length < 5 || objv.Length > 6 )
{
throw new TclNumArgsException( interp, 2, objv, "string first last ?string?" );
}
string string1 = objv[2].ToString();
int length1 = string1.Length - 1;
int first = Util.getIntForIndex( interp, objv[3], length1 );
int last = Util.getIntForIndex( interp, objv[4], length1 );
if ( ( last < first ) || ( first > length1 ) || ( last < 0 ) )
{
interp.setResult( objv[2] );
}
else
{
if ( first < 0 )
{
first = 0;
}
string start = string1.Substring( first );
int ind = ( ( last > length1 ) ? length1 : last ) - first + 1;
string end;
if ( ind <= 0 )
{
end = start;
}
else if ( ind >= start.Length )
{
end = "";
}
else
{
end = start.Substring( ind );
}
TclObject tstr = TclString.newInstance( string1.Substring( 0, ( first ) - ( 0 ) ) );
if ( objv.Length == 6 )
{
TclString.append( tstr, objv[5] );
}
if ( last < length1 )
{
TclString.append( tstr, end );
}
interp.setResult( tstr );
}
break;
}
case STR_TOLOWER:
case STR_TOUPPER:
case STR_TOTITLE:
{
if ( objv.Length < 3 || objv.Length > 5 )
{
throw new TclNumArgsException( interp, 2, objv, "string ?first? ?last?" );
}
string string1 = objv[2].ToString();
if ( objv.Length == 3 )
{
if ( index == STR_TOLOWER )
{
interp.setResult( string1.ToLower() );
}
else if ( index == STR_TOUPPER )
{
interp.setResult( string1.ToUpper() );
}
else
{
interp.setResult( Util.toTitle( string1 ) );
}
}
else
{
int length1 = string1.Length - 1;
int first = Util.getIntForIndex( interp, objv[3], length1 );
if ( first < 0 )
{
first = 0;
}
int last = first;
if ( objv.Length == 5 )
{
last = Util.getIntForIndex( interp, objv[4], length1 );
}
if ( last >= length1 )
{
last = length1;
}
if ( last < first )
{
interp.setResult( objv[2] );
break;
}
string string2;
StringBuilder buf = new StringBuilder();
buf.Append( string1.Substring( 0, ( first ) - ( 0 ) ) );
if ( last + 1 > length1 )
{
string2 = string1.Substring( first );
}
else
{
string2 = string1.Substring( first, ( last + 1 ) - ( first ) );
}
if ( index == STR_TOLOWER )
{
buf.Append( string2.ToLower() );
}
else if ( index == STR_TOUPPER )
{
buf.Append( string2.ToUpper() );
}
else
{
buf.Append( Util.toTitle( string2 ) );
}
if ( last + 1 <= length1 )
{
buf.Append( string1.Substring( last + 1 ) );
}
interp.setResult( buf.ToString() );
}
break;
}
case STR_TRIM:
{
if ( objv.Length == 3 )
{
// Case 1: "string trim str" --
// Remove leading and trailing white space
interp.setResult( objv[2].ToString().Trim() );
}
else if ( objv.Length == 4 )
{
// Case 2: "string trim str chars" --
// Remove leading and trailing chars in the chars set
string tmp = Util.TrimLeft( objv[2].ToString(), objv[3].ToString() );
interp.setResult( Util.TrimRight( tmp, objv[3].ToString() ) );
}
else
{
// Case 3: Wrong # of args
throw new TclNumArgsException( interp, 2, objv, "string ?chars?" );
}
break;
}
case STR_TRIMLEFT:
{
if ( objv.Length == 3 )
{
// Case 1: "string trimleft str" --
// Remove leading and trailing white space
interp.setResult( Util.TrimLeft( objv[2].ToString() ) );
}
else if ( objv.Length == 4 )
{
// Case 2: "string trimleft str chars" --
// Remove leading and trailing chars in the chars set
interp.setResult( Util.TrimLeft( objv[2].ToString(), objv[3].ToString() ) );
}
else
{
// Case 3: Wrong # of args
throw new TclNumArgsException( interp, 2, objv, "string ?chars?" );
}
break;
}
case STR_TRIMRIGHT:
{
if ( objv.Length == 3 )
{
// Case 1: "string trimright str" --
// Remove leading and trailing white space
interp.setResult( Util.TrimRight( objv[2].ToString() ) );
}
else if ( objv.Length == 4 )
{
// Case 2: "string trimright str chars" --
// Remove leading and trailing chars in the chars set
interp.setResult( Util.TrimRight( objv[2].ToString(), objv[3].ToString() ) );
}
else
{
// Case 3: Wrong # of args
throw new TclNumArgsException( interp, 2, objv, "string ?chars?" );
}
break;
}
case STR_WORDEND:
{
if ( objv.Length != 4 )
{
throw new TclNumArgsException( interp, 2, objv, "string index" );
}
string string1 = objv[2].ToString();
char[] strArray = string1.ToCharArray();
int cur;
int length1 = string1.Length;
index = Util.getIntForIndex( interp, objv[3], length1 - 1 );
if ( index < 0 )
{
index = 0;
}
if ( index >= length1 )
{
interp.setResult( length1 );
return TCL.CompletionCode.RETURN;
}
for ( cur = index; cur < length1; cur++ )
{
char c = strArray[cur];
if ( ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & WORD_BITS ) == 0 )
{
break;
}
}
if ( cur == index )
{
cur = index + 1;
}
interp.setResult( cur );
break;
}
case STR_WORDSTART:
{
if ( objv.Length != 4 )
{
throw new TclNumArgsException( interp, 2, objv, "string index" );
}
string string1 = objv[2].ToString();
char[] strArray = string1.ToCharArray();
int cur;
int length1 = string1.Length;
index = Util.getIntForIndex( interp, objv[3], length1 - 1 );
if ( index > length1 )
{
index = length1 - 1;
}
if ( index < 0 )
{
interp.setResult( 0 );
return TCL.CompletionCode.RETURN;
}
for ( cur = index; cur >= 0; cur-- )
{
char c = strArray[cur];
if ( ( ( 1 << (int)System.Char.GetUnicodeCategory( c ) ) & WORD_BITS ) == 0 )
{
break;
}
}
if ( cur != index )
{
cur += 1;
}
interp.setResult( cur );
break;
}
}
return TCL.CompletionCode.RETURN;
}
// return the number of Utf8 bytes that would be needed to store s
private int Utf8Count( string s )
{
int p = 0;
int len = s.Length;
char c;
int sum = 0;
while ( p < len )
{
c = s[p++];
if ( ( c > 0 ) && ( c < 0x80 ) )
{
sum += 1;
continue;
}
if ( c <= 0x7FF )
{
sum += 2;
continue;
}
if ( c <= 0xFFFF )
{
sum += 3;
continue;
}
}
return sum;
}
} // end StringCmd
}