/// <summary> SetIntFromAny -> TclInteger.setIntegerFromAny
///
/// Called to convert the other object's internal rep to this type.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="forIndex">true if this methid is called by getForIndex.
/// </param>
/// <param name="tobj">the TclObject to convert to use the
/// representation provided by this class.
/// </param>
private static void setIntegerFromAny(Interp interp, TclObject tobj)
{
InternalRep rep = tobj.InternalRep;
if (rep is TclInteger)
{
// Do nothing.
}
else if (rep is TclBoolean)
{
bool b = TclBoolean.get(interp, tobj);
if (b)
{
tobj.InternalRep = new TclInteger(1);
}
else
{
tobj.InternalRep = new TclInteger(0);
}
}
else
{
// (ToDo) other short-cuts
tobj.InternalRep = new TclInteger(interp, tobj.ToString());
}
}
/// <summary> Returns the value of the object as an boolean.
///
/// </summary>
/// <param name="interp">current interpreter.
/// </param>
/// <param name="tobj">the TclObject to use as an boolean.
/// </param>
/// <returns> the boolean value of the object.
/// </returns>
/// <exception cref=""> TclException if the object cannot be converted into a
/// boolean.
/// </exception>
public static bool get(Interp interp, TclObject tobj)
{
setBooleanFromAny(interp, tobj);
TclBoolean tbool = (TclBoolean)(tobj.InternalRep);
return(tbool.value);
}
public static bool Tcl_GetBooleanFromObj(Interp interp, TclObject to, out bool result)
{
try
{
result = TclBoolean.get(interp, to);
return(false);
}
catch
{
result = false;
return(true);
}
}
public static bool Tcl_GetBoolean(Interp interp, TclObject to, out int result)
{
try
{
result = (TclBoolean.get(interp, to) ? 1 : 0);
return(false);
}
catch
{
result = 0;
return(true);
}
}
private static void setDoubleFromAny(Interp interp, TclObject tobj)
{
InternalRep rep = tobj.InternalRep;
if (rep is TclDouble)
{
/*
* Do nothing.
*/
}
else if (rep is TclBoolean)
{
/*
* Short-cut.
*/
bool b = TclBoolean.get(interp, tobj);
if (b)
{
tobj.InternalRep = new TclDouble(1.0);
}
else
{
tobj.InternalRep = new TclDouble(0.0);
}
}
else if (rep is TclInteger)
{
/*
* Short-cut.
*/
int i = TclInteger.get(interp, tobj);
tobj.InternalRep = new TclDouble(i);
}
else
{
tobj.InternalRep = new TclDouble(interp, tobj.ToString());
}
}
private static void getAndStoreStatData(Interp interp, string fileName, string varName)
{
System.IO.FileInfo fileObj = FileUtil.getNewFileObj(interp, fileName);
bool tmpBool;
if (System.IO.File.Exists(fileObj.FullName))
{
tmpBool = true;
}
else
{
tmpBool = System.IO.Directory.Exists(fileObj.FullName);
}
if (!tmpBool)
{
throw new TclPosixException(interp, TclPosixException.ENOENT, true, "could not read \"" + fileName + "\"");
}
try
{
int mtime = getMtime(interp, fileName, fileObj);
TclObject mtimeObj = TclInteger.newInstance(mtime);
TclObject atimeObj = TclInteger.newInstance(mtime);
TclObject ctimeObj = TclInteger.newInstance(mtime);
interp.setVar(varName, "atime", atimeObj, 0);
interp.setVar(varName, "ctime", ctimeObj, 0);
interp.setVar(varName, "mtime", mtimeObj, 0);
}
catch (System.Security.SecurityException e)
{
throw new TclException(interp, e.Message);
}
catch (TclException e)
{
throw new TclException(interp, "can't set \"" + varName + "(dev)\": variable isn't array");
}
try
{
TclObject sizeObj = TclInteger.newInstance((int)SupportClass.FileLength(fileObj));
interp.setVar(varName, "size", sizeObj, 0);
}
catch (System.Exception e)
{
// Do nothing.
}
try
{
TclObject typeObj = TclString.newInstance(getType(interp, fileName, fileObj));
interp.setVar(varName, "type", typeObj, 0);
}
catch (System.Exception e)
{
}
try
{
TclObject uidObj = TclBoolean.newInstance(isOwner(interp, fileObj));
interp.setVar(varName, "uid", uidObj, 0);
}
catch (TclException e)
{
// Do nothing.
}
}
public static void Tcl_SetBooleanObj(TclObject to, int result)
{
to.stringRep = TclBoolean.newInstance(result != 0).ToString();
to.preserve();
}
public static TclObject Tcl_NewBooleanObj(int value)
{
return(TclBoolean.newInstance(value != 0));
}
/// <summary> This procedure is invoked to process the "fconfigure" Tcl command.
/// See the user documentation for details on what it does.
///
/// </summary>
/// <param name="interp">the current interpreter.
/// </param>
/// <param name="argv">command arguments.
/// </param>
public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv)
{
Channel chan; // The channel being operated on this method
if ((argv.Length < 2) || (((argv.Length % 2) == 1) && (argv.Length != 3)))
{
throw new TclNumArgsException(interp, 1, argv, "channelId ?optionName? ?value? ?optionName value?...");
}
chan = TclIO.getChannel(interp, argv[1].ToString());
if (chan == null)
{
throw new TclException(interp, "can not find channel named \"" + argv[1].ToString() + "\"");
}
if (argv.Length == 2)
{
// return list of all name/value pairs for this channelId
TclObject list = TclList.newInstance();
TclList.append(interp, list, TclString.newInstance("-blocking"));
TclList.append(interp, list, TclBoolean.newInstance(chan.Blocking));
TclList.append(interp, list, TclString.newInstance("-buffering"));
TclList.append(interp, list, TclString.newInstance(TclIO.getBufferingString(chan.Buffering)));
TclList.append(interp, list, TclString.newInstance("-buffersize"));
TclList.append(interp, list, TclInteger.newInstance(chan.BufferSize));
// -encoding
TclList.append(interp, list, TclString.newInstance("-encoding"));
System.Text.Encoding javaEncoding = chan.Encoding;
string tclEncoding;
if ((System.Object)javaEncoding == null)
{
tclEncoding = "binary";
}
else
{
tclEncoding = EncodingCmd.getTclName(javaEncoding);
}
TclList.append(interp, list, TclString.newInstance(tclEncoding));
// -eofchar
TclList.append(interp, list, TclString.newInstance("-eofchar"));
if (chan.ReadOnly)
{
char eofChar = chan.InputEofChar;
TclList.append(interp, list, (eofChar == 0) ? TclString.newInstance("") : TclString.newInstance(eofChar));
}
else if (chan.WriteOnly)
{
char eofChar = chan.OutputEofChar;
TclList.append(interp, list, (eofChar == 0) ? TclString.newInstance("") : TclString.newInstance(eofChar));
}
else if (chan.ReadWrite)
{
char inEofChar = chan.InputEofChar;
char outEofChar = chan.OutputEofChar;
TclObject eofchar_pair = TclList.newInstance();
TclList.append(interp, eofchar_pair, (inEofChar == 0) ? TclString.newInstance("") : TclString.newInstance(inEofChar));
TclList.append(interp, eofchar_pair, (outEofChar == 0) ? TclString.newInstance("") : TclString.newInstance(outEofChar));
TclList.append(interp, list, eofchar_pair);
}
else
{
// Not readable or writeable, do nothing
}
// -translation
TclList.append(interp, list, TclString.newInstance("-translation"));
if (chan.ReadOnly)
{
TclList.append(interp, list, TclString.newInstance(TclIO.getTranslationString(chan.InputTranslation)));
}
else if (chan.WriteOnly)
{
TclList.append(interp, list, TclString.newInstance(TclIO.getTranslationString(chan.OutputTranslation)));
}
else if (chan.ReadWrite)
{
TclObject translation_pair = TclList.newInstance();
TclList.append(interp, translation_pair, TclString.newInstance(TclIO.getTranslationString(chan.InputTranslation)));
TclList.append(interp, translation_pair, TclString.newInstance(TclIO.getTranslationString(chan.OutputTranslation)));
TclList.append(interp, list, translation_pair);
}
else
{
// Not readable or writeable, do nothing
}
interp.setResult(list);
}
if (argv.Length == 3)
{
// return value for supplied name
int index = TclIndex.get(interp, argv[2], validCmds, "option", 0);
switch (index)
{
case OPT_BLOCKING:
{
// -blocking
interp.setResult(chan.Blocking);
break;
}
case OPT_BUFFERING:
{
// -buffering
interp.setResult(TclIO.getBufferingString(chan.Buffering));
break;
}
case OPT_BUFFERSIZE:
{
// -buffersize
interp.setResult(chan.BufferSize);
break;
}
case OPT_ENCODING:
{
// -encoding
System.Text.Encoding javaEncoding = chan.Encoding;
if ((System.Object)javaEncoding == null)
{
interp.setResult("binary");
}
else
{
interp.setResult(EncodingCmd.getTclName(javaEncoding));
}
break;
}
case OPT_EOFCHAR:
{
// -eofchar
if (chan.ReadOnly)
{
char eofChar = chan.InputEofChar;
interp.setResult((eofChar == 0) ? TclString.newInstance("") : TclString.newInstance(eofChar));
}
else if (chan.WriteOnly)
{
char eofChar = chan.OutputEofChar;
interp.setResult((eofChar == 0) ? TclString.newInstance("") : TclString.newInstance(eofChar));
}
else if (chan.ReadWrite)
{
char inEofChar = chan.InputEofChar;
char outEofChar = chan.OutputEofChar;
TclObject eofchar_pair = TclList.newInstance();
TclList.append(interp, eofchar_pair, (inEofChar == 0) ? TclString.newInstance("") : TclString.newInstance(inEofChar));
TclList.append(interp, eofchar_pair, (outEofChar == 0) ? TclString.newInstance("") : TclString.newInstance(outEofChar));
interp.setResult(eofchar_pair);
}
else
{
// Not readable or writeable, do nothing
}
break;
}
case OPT_TRANSLATION:
{
// -translation
if (chan.ReadOnly)
{
interp.setResult(TclIO.getTranslationString(chan.InputTranslation));
}
else if (chan.WriteOnly)
{
interp.setResult(TclIO.getTranslationString(chan.OutputTranslation));
}
else if (chan.ReadWrite)
{
TclObject translation_pair = TclList.newInstance();
TclList.append(interp, translation_pair, TclString.newInstance(TclIO.getTranslationString(chan.InputTranslation)));
TclList.append(interp, translation_pair, TclString.newInstance(TclIO.getTranslationString(chan.OutputTranslation)));
interp.setResult(translation_pair);
}
else
{
// Not readable or writeable, do nothing
}
break;
}
default:
{
throw new TclRuntimeError("Fconfigure.cmdProc() error: " + "incorrect index returned from TclIndex.get()");
}
}
}
for (int i = 3; i < argv.Length; i += 2)
{
// Iterate through the list setting the name with the
// corresponding value.
int index = TclIndex.get(interp, argv[i - 1], validCmds, "option", 0);
switch (index)
{
case OPT_BLOCKING:
{
// -blocking
chan.Blocking = TclBoolean.get(interp, argv[i]);
break;
}
case OPT_BUFFERING:
{
// -buffering
int id = TclIO.getBufferingID(argv[i].ToString());
if (id == -1)
{
throw new TclException(interp, "bad value for -buffering: must be " + "one of full, line, or none");
}
chan.Buffering = id;
break;
}
case OPT_BUFFERSIZE:
{
// -buffersize
chan.BufferSize = TclInteger.get(interp, argv[i]);
break;
}
case OPT_ENCODING:
{
// -encoding
string tclEncoding = argv[i].ToString();
if (tclEncoding.Equals("") || tclEncoding.Equals("binary"))
{
chan.Encoding = null;
}
else
{
System.Text.Encoding javaEncoding = EncodingCmd.getJavaName(tclEncoding);
if ((System.Object)javaEncoding == null)
{
throw new TclException(interp, "unknown encoding \"" + tclEncoding + "\"");
}
chan.Encoding = javaEncoding;
}
break;
}
case OPT_EOFCHAR:
{
// -eofchar
TclList.setListFromAny(interp, argv[i]);
int length = TclList.getLength(interp, argv[i]);
if (length > 2)
{
throw new TclException(interp, "bad value for -eofchar: " + "should be a list of zero, one, or two elements");
}
char inputEofChar, outputEofChar;
string s;
if (length == 0)
{
inputEofChar = outputEofChar = (char)(0);
}
else if (length == 1)
{
s = TclList.index(interp, argv[i], 0).ToString();
inputEofChar = outputEofChar = s[0];
}
else
{
s = TclList.index(interp, argv[i], 0).ToString();
inputEofChar = s[0];
s = TclList.index(interp, argv[i], 1).ToString();
outputEofChar = s[0];
}
chan.InputEofChar = inputEofChar;
chan.OutputEofChar = outputEofChar;
break;
}
case OPT_TRANSLATION:
{
// -translation
TclList.setListFromAny(interp, argv[i]);
int length = TclList.getLength(interp, argv[i]);
if (length < 1 || length > 2)
{
throw new TclException(interp, "bad value for -translation: " + "must be a one or two element list");
}
string inputTranslationArg, outputTranslationArg;
int inputTranslation, outputTranslation;
if (length == 2)
{
inputTranslationArg = TclList.index(interp, argv[i], 0).ToString();
inputTranslation = TclIO.getTranslationID(inputTranslationArg);
outputTranslationArg = TclList.index(interp, argv[i], 1).ToString();
outputTranslation = TclIO.getTranslationID(outputTranslationArg);
}
else
{
outputTranslationArg = inputTranslationArg = argv[i].ToString();
outputTranslation = inputTranslation = TclIO.getTranslationID(outputTranslationArg);
}
if ((inputTranslation == -1) || (outputTranslation == -1))
{
throw new TclException(interp, "bad value for -translation: " + "must be one of auto, binary, cr, lf, " + "crlf, or platform");
}
if (outputTranslation == TclIO.TRANS_AUTO)
{
outputTranslation = TclIO.TRANS_PLATFORM;
}
if (chan.ReadOnly)
{
chan.InputTranslation = inputTranslation;
if (inputTranslationArg.Equals("binary"))
{
chan.Encoding = null;
}
}
else if (chan.WriteOnly)
{
chan.OutputTranslation = outputTranslation;
if (outputTranslationArg.Equals("binary"))
{
chan.Encoding = null;
}
}
else if (chan.ReadWrite)
{
chan.InputTranslation = inputTranslation;
chan.OutputTranslation = outputTranslation;
if (inputTranslationArg.Equals("binary") || outputTranslationArg.Equals("binary"))
{
chan.Encoding = null;
}
}
else
{
// Not readable or writeable, do nothing
}
break;
}
default:
{
throw new TclRuntimeError("Fconfigure.cmdProc() error: " + "incorrect index returned from TclIndex.get()");
}
}
}
return(TCL.CompletionCode.RETURN);
}
/// <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;
}
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;
System.Text.StringBuilder buf = new System.Text.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);
}
