public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
{
int i;
Notifier notifier = (Notifier)interp.GetNotifier();
Object info;
if (_assocData == null)
{
// Create the "after" information associated for this interpreter, if it doesn't already exist.
_assocData = (AfterAssocData)interp.GetAssocData("tclAfter");
if (_assocData == null)
{
_assocData = new AfterAssocData(this);
interp.SetAssocData("tclAfter", _assocData);
}
}
if (argv.Length < 2)
{
throw new TclNumArgsException(interp, 1, argv, "option ?arg arg ...?");
}
// First lets see if the command was passed a number as the first argument.
bool isNumber = false;
int ms = 0;
if (argv[1].InternalRep is TclInteger)
{
ms = TclInteger.Get(interp, argv[1]);
isNumber = true;
}
else
{
string s = argv[1].ToString();
if (s.Length > 0 && char.IsDigit(s[0]))
{
ms = TclInteger.Get(interp, argv[1]);
isNumber = true;
}
}
if (isNumber)
{
if (ms < 0)
{
ms = 0;
}
if (argv.Length == 2)
{
// Sleep for at least the given milliseconds and return.
long endTime = DateTime.Now.Ticks / 10000 + ms;
while (true)
{
try
{
Thread.Sleep(ms);
return(TCL.CompletionCode.RETURN);
}
catch (ThreadInterruptedException e)
{
// We got interrupted. Sleep again if we havn't slept long enough yet.
long sysTime = System.DateTime.Now.Ticks / 10000;
if (sysTime >= endTime)
{
return(TCL.CompletionCode.RETURN);
}
ms = (int)(endTime - sysTime);
continue;
}
}
}
TclObject cmd = GetCmdObject(argv);
cmd.Preserve();
_assocData.LastAfterId++;
TimerInfo timerInfo = new TimerInfo(this, notifier, ms);
timerInfo.Interp = interp;
timerInfo.Command = cmd;
timerInfo.Id = _assocData.LastAfterId;
_assocData.Handlers.Add(timerInfo);
interp.SetResult("after#" + timerInfo.Id);
return(TCL.CompletionCode.RETURN);
}
// If it's not a number it must be a subcommand.
int index;
try { index = TclIndex.Get(interp, argv[1], _validOpts, "option", 0); }
catch (TclException e) { throw new TclException(interp, "bad argument \"" + argv[1] + "\": must be cancel, idle, info, or a number"); }
switch (index)
{
case OPT_CANCEL:
if (argv.Length < 3)
{
throw new TclNumArgsException(interp, 2, argv, "id|command");
}
TclObject arg = GetCmdObject(argv);
arg.Preserve();
// Search the timer/idle handler by id or by command.
info = null;
for (i = 0; i < _assocData.Handlers.Count; i++)
{
Object obj = _assocData.Handlers[i];
if (obj is TimerInfo)
{
TclObject cmd = ((TimerInfo)obj).Command;
if (cmd == arg || cmd.ToString().Equals(arg.ToString()))
{
info = obj;
break;
}
}
else
{
TclObject cmd = ((IdleInfo)obj).Command;
if (cmd == arg || cmd.ToString().Equals(arg.ToString()))
{
info = obj;
break;
}
}
}
if (info == null)
{
info = GetAfterEvent(arg.ToString());
}
arg.Release();
// Cancel the handler.
if (info != null)
{
if (info is TimerInfo)
{
((TimerInfo)info).Cancel();
((TimerInfo)info).Command.Release();
}
else
{
((IdleInfo)info).Cancel();
((IdleInfo)info).Command.Release();
}
SupportClass.VectorRemoveElement(_assocData.Handlers, info);
}
break;
case OPT_IDLE:
if (argv.Length < 3)
{
throw new TclNumArgsException(interp, 2, argv, "script script ...");
}
TclObject cmd2 = GetCmdObject(argv);
cmd2.Preserve();
_assocData.LastAfterId++;
IdleInfo idleInfo = new IdleInfo(this, notifier);
idleInfo.Interp = interp;
idleInfo.Command = cmd2;
idleInfo.Id = _assocData.LastAfterId;
_assocData.Handlers.Add(idleInfo);
interp.SetResult("after#" + idleInfo.Id);
break;
case OPT_INFO:
if (argv.Length == 2)
{
// No id is given. Return a list of current after id's.
TclObject list = TclList.NewInstance();
for (i = 0; i < _assocData.Handlers.Count; i++)
{
int id;
Object obj = _assocData.Handlers[i];
if (obj is TimerInfo)
{
id = ((TimerInfo)obj).Id;
}
else
{
id = ((IdleInfo)obj).Id;
}
TclList.Append(interp, list, TclString.NewInstance("after#" + id));
}
interp.ResetResult();
interp.SetResult(list);
return(TCL.CompletionCode.RETURN);
}
if (argv.Length != 3)
{
throw new TclNumArgsException(interp, 2, argv, "?id?");
}
// Return command and type of the given after id.
info = GetAfterEvent(argv[2].ToString());
if (info == null)
{
throw new TclException(interp, "event \"" + argv[2] + "\" doesn't exist");
}
TclObject list2 = TclList.NewInstance();
TclList.Append(interp, list2, ((info is TimerInfo) ? ((TimerInfo)info).Command : ((IdleInfo)info).Command));
TclList.Append(interp, list2, TclString.NewInstance((info is TimerInfo) ? "timer" : "idle"));
interp.ResetResult();
interp.SetResult(list2);
break;
}
return(TCL.CompletionCode.RETURN);
}
/// <summary> This procedure is invoked to process the "scan" Tcl command.
/// See the user documentation for details on what it does.
///
/// Each iteration of the cmdProc compares the scanArr's current index to
/// the frmtArr's index. If the chars are equal then the indicies are
/// incremented. If a '%' is found in the frmtArr, the formatSpecifier
/// is parced from the frmtArr, the corresponding value is extracted from
/// the scanArr, and that value is set in the Tcl Interp.
///
/// If the chars are not equal, or the conversion fails, the boolean
/// scanArrDone is set to true, indicating the scanArr is not to be
/// parced and no new values are to be set. However the frmtArr is still
/// parced because of the priority of error messages. In the C version
/// of Tcl, bad format specifiers throw errors before incorrect argument
/// input or other scan errors. Thus we need to parce the entire frmtArr
/// to verify correct formating. This is dumb and inefficient but it is
/// consistent w/ the current C-version of Tcl.
/// </summary>
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
{
if (argv.Length < 3)
{
throw new TclNumArgsException(interp, 1, argv, "string format ?varName varName ...?");
}
;
StrtoulResult strul; // Return value for parcing the scanArr when
// extracting integers/longs
StrtodResult strd;
; // Return value for parcing the scanArr when
// extracting doubles
char[] scanArr; // Array containing parce info
char[] frmtArr; // Array containing info on how to
// parse the scanArr
int scanIndex; // Index into the scan array
int frmtIndex; // Index into the frmt array
int tempIndex; // Temporary index holder
int argIndex; // Index into the current arg
int width; // Stores the user specified result width
int base_; // Base of the integer being converted
int numUnMatched; // Number of fields actually set.
int numMatched; // Number of fields actually matched.
int negateScan; // Mult by result, set to -1 if true
int i; // Generic variable
char ch; // Generic variable
bool cont; // Used in loops to indicate when to stop
bool scanOK; // Set to false if strtoul/strtod fails
bool scanArrDone; // Set to false if strtoul/strtod fails
bool widthFlag; // True is width is specified
bool discardFlag; // If a "%*" is in the formatString dont
// write output to arg
scanArr = argv[1].ToString().ToCharArray();
frmtArr = argv[2].ToString().ToCharArray();
width = base_ = numMatched = numUnMatched = 0;
scanIndex = frmtIndex = 0;
scanOK = true;
scanArrDone = false;
argIndex = 3;
// Skip all (if any) of the white space before getting to a char
frmtIndex = skipWhiteSpace(frmtArr, frmtIndex);
// Search through the frmtArr. If the next char is a '%' parse the
// next chars and determine the type (if any) of the format specifier.
// If the scanArr has been fully searched, do nothing but incerment
// "numUnMatched". The reason to continue the frmtArr search is for
// consistency in output. Previously scan format errors were reported
// before arg input mismatch, so this maintains the same level of error
// checking.
while (frmtIndex < frmtArr.Length)
{
discardFlag = widthFlag = false;
negateScan = 1;
cont = true;
// Parce the format array and read in the correct value from the
// scan array. When the correct value is retrieved, set the
// variable (from argv) in the interp.
if (frmtArr[frmtIndex] == '%')
{
frmtIndex++;
checkOverFlow(interp, frmtArr, frmtIndex);
// Two '%'s in a row, do nothing...
if (frmtArr[frmtIndex] == '%')
{
frmtIndex++;
scanIndex++;
continue;
}
// Check for a discard field flag
if (frmtArr[frmtIndex] == '*')
{
discardFlag = true;
frmtIndex++;
checkOverFlow(interp, frmtArr, frmtIndex);
}
// Check for a width field and accept the 'h', 'l', 'L'
// characters, but do nothing with them.
//
// Note: The order of the width specifier and the other
// chars is unordered, so we need to iterate until all
// of the specifiers are identified.
while (cont)
{
cont = false;
switch (frmtArr[frmtIndex])
{
case 'h':
case 'l':
case 'L':
{
// Just ignore these values
frmtIndex++;
cont = true;
break;
}
default:
{
if (System.Char.IsDigit(frmtArr[frmtIndex]))
{
strul = Util.Strtoul(new string(frmtArr), frmtIndex, base_);
frmtIndex = strul.Index;
width = (int)strul.value;
widthFlag = true;
cont = true;
}
}
break;
}
checkOverFlow(interp, frmtArr, frmtIndex);
}
// On all conversion specifiers except 'c', move the
// scanIndex to the next non-whitespace.
ch = frmtArr[frmtIndex];
if ((ch != 'c') && (ch != '[') && !scanArrDone)
{
scanIndex = skipWhiteSpace(scanArr, scanIndex);
}
if (scanIndex >= scanArr.Length)
{
scanArrDone = true;
}
if ((scanIndex < scanArr.Length) && (ch != 'c') && (ch != '['))
{
// Since strtoul dosent take signed numbers, make the
// value positive and store the sign.
if (scanArr[scanIndex] == '-')
{
negateScan = -1;
scanIndex++;
width--;
}
else if (scanArr[scanIndex] == '+')
{
scanIndex++;
width--;
}
// The width+scanIndex might be greater than
// the scanArr so we need to re-adjust when this
// happens.
if (widthFlag && (width + scanIndex > scanArr.Length))
{
width = scanArr.Length - scanIndex;
}
}
if (scanIndex >= scanArr.Length)
{
scanArrDone = true;
}
// Foreach iteration we want strul and strd to be
// null since we error check on this case.
strul = null;
strd = null;
switch (ch)
{
case 'd':
case 'o':
case 'x':
{
if (!scanArrDone)
{
if (ch == 'd')
{
base_ = 10;
}
else if (ch == 'o')
{
base_ = 8;
}
else
{
base_ = 16;
}
// If the widthFlag is set then convert only
// "width" characters to an ascii representation,
// else read in until the end of the integer. The
// scanIndex is moved to the point where we stop
// reading in.
if (widthFlag)
{
strul = Util.Strtoul(new string(scanArr, 0, width + scanIndex), scanIndex, base_);
}
else
{
strul = Util.Strtoul(new string(scanArr), scanIndex, base_);
}
if (strul.errno != 0)
{
scanOK = false;
break;
}
scanIndex = strul.Index;
if (!discardFlag)
{
i = (int)strul.value * negateScan;
if (argIndex == argv.Length)
{
numMatched--;
}
else
{
testAndSetVar(interp, argv, argIndex++, TclInteger.NewInstance(i));
}
}
}
break;
}
case 'c':
{
if (widthFlag)
{
errorCharFieldWidth(interp);
}
if (!discardFlag && !scanArrDone)
{
testAndSetVar(interp, argv, argIndex++, TclInteger.NewInstance(scanArr[scanIndex++]));
}
break;
}
case 's':
{
if (!scanArrDone)
{
// If the widthFlag is set then read only "width"
// characters into the string, else read in until
// the first whitespace or endArr is found. The
// scanIndex is moved to the point where we stop
// reading in.
tempIndex = scanIndex;
if (!widthFlag)
{
width = scanArr.Length;
}
for (i = 0; (scanIndex < scanArr.Length) && (i < width); i++)
{
ch = scanArr[scanIndex];
if ((ch == ' ') || (ch == '\n') || (ch == '\r') || (ch == '\t') || (ch == '\f'))
{
break;
}
scanIndex++;
}
if (!discardFlag)
{
string str = new string(scanArr, tempIndex, scanIndex - tempIndex);
testAndSetVar(interp, argv, argIndex++, TclString.NewInstance(str));
}
}
break;
}
case 'e':
case 'f':
case 'g':
{
if (!scanArrDone)
{
// If the wisthFlag is set then read only "width"
// characters into the string, else read in until
// the first whitespace or endArr is found. The
// scanIndex is moved to the point where we stop
// reading in.
if (widthFlag)
{
strd = Util.Strtod(new string(scanArr, 0, width + scanIndex), scanIndex);
}
else
{
strd = Util.Strtod(new string(scanArr), scanIndex);
}
if (strd.errno != 0)
{
scanOK = false;
break;
}
scanIndex = strd.index;
if (!discardFlag)
{
double d = strd.value * negateScan;
testAndSetVar(interp, argv, argIndex++, TclDouble.NewInstance(d));
}
}
break;
}
case '[':
{
bool charMatchFound = false;
bool charNotMatch = false;
char[] tempArr;
int startIndex;
int endIndex;
string unmatched = "unmatched [ in format string";
if ((++frmtIndex) >= frmtArr.Length)
{
throw new TclException(interp, unmatched);
}
if (frmtArr[frmtIndex] == '^')
{
charNotMatch = true;
frmtIndex += 2;
}
else
{
frmtIndex++;
}
tempIndex = frmtIndex - 1;
if (frmtIndex >= frmtArr.Length)
{
throw new TclException(interp, unmatched);
}
// Extract the list of chars for matching.
while (frmtArr[frmtIndex] != ']')
{
if ((++frmtIndex) >= frmtArr.Length)
{
throw new TclException(interp, unmatched);
}
}
tempArr = new string(frmtArr, tempIndex, frmtIndex - tempIndex).ToCharArray();
startIndex = scanIndex;
if (charNotMatch)
{
// Format specifier contained a '^' so interate
// until one of the chars in tempArr is found.
while (scanOK && !charMatchFound)
{
if (scanIndex >= scanArr.Length)
{
scanOK = false;
break;
}
for (i = 0; i < tempArr.Length; i++)
{
if (tempArr[i] == scanArr[scanIndex])
{
charMatchFound = true;
break;
}
}
if (widthFlag && ((scanIndex - startIndex) >= width))
{
break;
}
if (!charMatchFound)
{
scanIndex++;
}
}
}
else
{
// Iterate until the char in the scanArr is not
// in the tempArr.
charMatchFound = true;
while (scanOK && charMatchFound)
{
if (scanIndex >= scanArr.Length)
{
scanOK = false;
break;
}
charMatchFound = false;
for (i = 0; i < tempArr.Length; i++)
{
if (tempArr[i] == scanArr[scanIndex])
{
charMatchFound = true;
break;
}
}
if (widthFlag && (scanIndex - startIndex) >= width)
{
break;
}
if (charMatchFound)
{
scanIndex++;
}
}
}
// Indicates nothing was found.
endIndex = scanIndex - startIndex;
if (endIndex <= 0)
{
scanOK = false;
break;
}
if (!discardFlag)
{
string str = new string(scanArr, startIndex, endIndex);
testAndSetVar(interp, argv, argIndex++, TclString.NewInstance(str));
}
break;
}
default:
{
errorBadField(interp, ch);
}
break;
}
// As long as the scan was successful (scanOK), the format
// specifier did not contain a '*' (discardFlag), and
// we are not at the end of the scanArr (scanArrDone);
// increment the num of vars set in the interp. Otherwise
// increment the number of valid format specifiers.
if (scanOK && !discardFlag && !scanArrDone)
{
numMatched++;
}
else if ((scanArrDone || !scanOK) && !discardFlag)
{
numUnMatched++;
}
frmtIndex++;
}
else if (scanIndex < scanArr.Length && scanArr[scanIndex] == frmtArr[frmtIndex])
{
// No '%' was found, but the characters matched
scanIndex++;
frmtIndex++;
}
else
{
// No '%' found and the characters int frmtArr & scanArr
// did not match.
frmtIndex++;
}
}
// The numMatched is the return value: a count of the num of vars set.
// While the numUnMatched is the number of formatSpecifiers that
// passed the parsing stage, but did not match anything in the scanArr.
if ((numMatched + numUnMatched) != (argv.Length - 3))
{
errorDiffVars(interp);
}
interp.SetResult(TclInteger.NewInstance(numMatched));
return(TCL.CompletionCode.RETURN);
}
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
{
int firstWord; /* Index to the first non-switch arg */
int argLen = argv.Length; /* No of args to copy to argStrs */
int exit; /* denotes exit status of process */
int errorBytes = 0; /* number of bytes of process stderr */
//bool background; /* Indicates a bg process */
//bool keepNewline; /* Retains newline in pipline output */
System.Diagnostics.Process p; /* The exec-ed process */
string argStr; /* Conversion of argv to a string */
StringBuilder sbuf;
/*
* Check for a leading "-keepnewline" argument.
*/
for (firstWord = 1; firstWord < argLen; firstWord++)
{
argStr = argv[firstWord].ToString();
if ((argStr.Length > 0) && (argStr[0] == '-'))
{
//if (argStr.Equals("-keepnewline"))
//{
// keepNewline = true;
//}
//else
if (argStr.Equals("--"))
{
firstWord++;
break;
}
else
{
throw new TclException(interp, "bad switch \"" + argStr + "\": must be -keepnewline or --");
}
}
}
if (argLen <= firstWord)
{
throw new TclNumArgsException(interp, 1, argv, "?switches? arg ?arg ...?");
}
/*
* See if the command is to be run in background.
* Currently this does nothing, it is just for compatibility
*/
//if (argv[argLen - 1].ToString().Equals("&"))
//{
// argLen--;
// background = true;
//}
try
{
/*
* It is necessary to perform system specific
* operations before calling exec. For now Solaris
* and Windows execs are somewhat supported, in all other cases
* we simply call exec and give it our "best shot"
*/
if (execMethod != null)
{
p = execReflection(interp, argv, firstWord, argLen);
}
else if (Util.Unix)
{
p = execUnix(interp, argv, firstWord, argLen);
}
else if (Util.Windows)
{
p = execWin(interp, argv, firstWord, argLen);
}
else
{
p = execDefault(interp, argv, firstWord, argLen);
}
//note to self : buffer reading should be done in
//a separate thread and not by calling waitFor()
//because a process that is waited for can block
//Wait for the process to finish running,
try
{
p.Start();
p.WaitForExit();
exit = p.ExitCode;
}
catch (Exception e)
{
throw new TclException(interp, "exception in exec process: " + e.Message);
}
//Make buffer for the results of the subprocess execution
sbuf = new StringBuilder();
//read data on stdout stream into result buffer
readStreamIntoBuffer(p.StandardOutput.BaseStream, sbuf);
//if there is data on the stderr stream then append
//this data onto the result StringBuffer
//check for the special case where there is no error
//data but the process returns an error result
errorBytes = readStreamIntoBuffer(p.StandardError.BaseStream, sbuf);
if ((errorBytes == 0) && (exit != 0))
{
sbuf.Append("child process exited abnormally");
}
//If the last character of the result buffer is a newline, then
//remove the newline character (the newline would just confuse
//things). Finally, we set pass the result to the interpreter.
// Tcl supports lots of child status conditions.
// Unfortunately, we can only find the child's
// exit status using the Java API
if (exit != 0)
{
TclObject childstatus = TclList.NewInstance();
TclList.Append(interp, childstatus, TclString.NewInstance("CHILDSTATUS"));
// We don't know how to find the child's pid
TclList.Append(interp, childstatus, TclString.NewInstance("?PID?"));
TclList.Append(interp, childstatus, TclInteger.NewInstance(exit));
interp.SetErrorCode(childstatus);
}
//when the subprocess writes to its stderr stream or returns
//a non zero result we generate an error
if ((exit != 0) || (errorBytes != 0))
{
throw new TclException(interp, sbuf.ToString());
}
//otherwise things went well so set the result
interp.SetResult(sbuf.ToString());
}
catch (IOException e)
{
//if exec fails we end up catching the exception here
throw new TclException(interp, "couldn't execute \"" + argv[firstWord].ToString() + "\": no such file or directory");
}
catch (System.Threading.ThreadInterruptedException e)
{
/*
* Do Nothing...
*/
}
return(TCL.CompletionCode.RETURN);
}
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
{
string optLevel;
int result;
CallFrame savedVarFrame, frame;
int objc = objv.Length;
int objv_index;
TclObject cmd;
if (objv.Length < 2)
{
throw new TclNumArgsException(interp, 1, objv, "?level? command ?arg ...?");
}
// Find the level to use for executing the command.
optLevel = objv[1].ToString();
// Java does not support passing a reference by refernece so use an array
CallFrame[] frameArr = new CallFrame[1];
result = CallFrame.GetFrame(interp, optLevel, frameArr);
frame = frameArr[0];
objc -= (result + 1);
if (objc == 0)
{
throw new TclNumArgsException(interp, 1, objv, "?level? command ?arg ...?");
}
objv_index = (result + 1);
// Modify the interpreter state to execute in the given frame.
savedVarFrame = interp.VarFrame;
interp.VarFrame = frame;
// Execute the residual arguments as a command.
if (objc == 1)
{
cmd = objv[objv_index];
}
else
{
cmd = TclString.NewInstance(Util.concat(objv_index, objv.Length - 1, objv));
}
cmd.Preserve();
try
{
interp.Eval(cmd, 0);
}
catch (TclException e)
{
if (e.GetCompletionCode() == TCL.CompletionCode.ERROR)
{
interp.AddErrorInfo("\n (\"uplevel\" body line " + interp._errorLine + ")");
}
throw;
}
finally
{
interp.VarFrame = savedVarFrame;
cmd.Release();
}
return(TCL.CompletionCode.RETURN);
}
/// <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);
}
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
{
if (objv.Length < 2)
{
throw new TclNumArgsException(interp, 1, objv, "cmd ?arg ...?");
}
int cmd = TclIndex.Get(interp, objv[1], options, "option", 0);
switch (cmd)
{
case OPT_ALIAS:
{
if (objv.Length >= 4)
{
Interp slaveInterp = getInterp(interp, objv[2]);
if (objv.Length == 4)
{
InterpAliasCmd.describe(interp, slaveInterp, objv[3]);
return(TCL.CompletionCode.RETURN);
}
if ((objv.Length == 5) && ("".Equals(objv[4].ToString())))
{
InterpAliasCmd.delete(interp, slaveInterp, objv[3]);
return(TCL.CompletionCode.RETURN);
}
if (objv.Length > 5)
{
Interp masterInterp = getInterp(interp, objv[4]);
if ("".Equals(objv[5].ToString()))
{
if (objv.Length == 6)
{
InterpAliasCmd.delete(interp, slaveInterp, objv[3]);
return(TCL.CompletionCode.RETURN);
}
}
else
{
InterpAliasCmd.create(interp, slaveInterp, masterInterp, objv[3], objv[5], 6, objv);
return(TCL.CompletionCode.RETURN);
}
}
}
throw new TclNumArgsException(interp, 2, objv, "slavePath slaveCmd ?masterPath masterCmd? ?args ..?");
}
case OPT_ALIASES:
{
Interp slaveInterp = getInterp(interp, objv);
InterpAliasCmd.list(interp, slaveInterp);
break;
}
case OPT_CREATE:
{
// Weird historical rules: "-safe" is accepted at the end, too.
bool safe = interp._isSafe;
TclObject slaveNameObj = null;
bool last = false;
for (int i = 2; i < objv.Length; i++)
{
if ((!last) && (objv[i].ToString()[0] == '-'))
{
int index = TclIndex.Get(interp, objv[i], createOptions, "option", 0);
if (index == OPT_CREATE_SAFE)
{
safe = true;
continue;
}
i++;
last = true;
}
if (slaveNameObj != null)
{
throw new TclNumArgsException(interp, 2, objv, "?-safe? ?--? ?path?");
}
slaveNameObj = objv[i];
}
if (slaveNameObj == null)
{
// Create an anonymous interpreter -- we choose its name and
// the name of the command. We check that the command name
// that we use for the interpreter does not collide with an
// existing command in the master interpreter.
int i = 0;
while (interp.getCommand("interp" + i) != null)
{
i++;
}
slaveNameObj = TclString.NewInstance("interp" + i);
}
InterpSlaveCmd.create(interp, slaveNameObj, safe);
interp.SetResult(slaveNameObj);
break;
}
case OPT_DELETE:
{
for (int i = 2; i < objv.Length; i++)
{
Interp slaveInterp = getInterp(interp, objv[i]);
if (slaveInterp == interp)
{
throw new TclException(interp, "cannot delete the current interpreter");
}
InterpSlaveCmd slave = slaveInterp._slave;
slave.masterInterp.DeleteCommandFromToken(slave.interpCmd);
}
break;
}
case OPT_EVAL:
{
if (objv.Length < 4)
{
throw new TclNumArgsException(interp, 2, objv, "path arg ?arg ...?");
}
Interp slaveInterp = getInterp(interp, objv[2]);
InterpSlaveCmd.eval(interp, slaveInterp, 3, objv);
break;
}
case OPT_EXISTS:
{
bool exists = true;
try
{
getInterp(interp, objv);
}
catch (TclException e)
{
if (objv.Length > 3)
{
throw;
}
exists = false;
}
interp.SetResult(exists);
break;
}
case OPT_EXPOSE:
{
if (objv.Length < 4 || objv.Length > 5)
{
throw new TclNumArgsException(interp, 2, objv, "path hiddenCmdName ?cmdName?");
}
Interp slaveInterp = getInterp(interp, objv[2]);
InterpSlaveCmd.expose(interp, slaveInterp, 3, objv);
break;
}
case OPT_HIDE:
{
if (objv.Length < 4 || objv.Length > 5)
{
throw new TclNumArgsException(interp, 2, objv, "path cmdName ?hiddenCmdName?");
}
Interp slaveInterp = getInterp(interp, objv[2]);
InterpSlaveCmd.hide(interp, slaveInterp, 3, objv);
break;
}
case OPT_HIDDEN:
{
Interp slaveInterp = getInterp(interp, objv);
InterpSlaveCmd.hidden(interp, slaveInterp);
break;
}
case OPT_ISSAFE:
{
Interp slaveInterp = getInterp(interp, objv);
interp.SetResult(slaveInterp._isSafe);
break;
}
case OPT_INVOKEHIDDEN:
{
bool global = false;
int i;
for (i = 3; i < objv.Length; i++)
{
if (objv[i].ToString()[0] != '-')
{
break;
}
int index = TclIndex.Get(interp, objv[i], hiddenOptions, "option", 0);
if (index == OPT_HIDDEN_GLOBAL)
{
global = true;
}
else
{
i++;
break;
}
}
if (objv.Length - i < 1)
{
throw new TclNumArgsException(interp, 2, objv, "path ?-global? ?--? cmd ?arg ..?");
}
Interp slaveInterp = getInterp(interp, objv[2]);
InterpSlaveCmd.invokeHidden(interp, slaveInterp, global, i, objv);
break;
}
case OPT_MARKTRUSTED:
{
if (objv.Length != 3)
{
throw new TclNumArgsException(interp, 2, objv, "path");
}
Interp slaveInterp = getInterp(interp, objv[2]);
InterpSlaveCmd.markTrusted(interp, slaveInterp);
break;
}
case OPT_SLAVES:
{
Interp slaveInterp = getInterp(interp, objv);
TclObject result = TclList.NewInstance();
interp.SetResult(result);
IEnumerator keys = slaveInterp._slaveTable.Keys.GetEnumerator();
while (keys.MoveNext())
{
string inString = (string)keys.Current;
TclList.Append(interp, result, TclString.NewInstance(inString));
}
break;
}
case OPT_SHARE:
{
if (objv.Length != 5)
{
throw new TclNumArgsException(interp, 2, objv, "srcPath channelId destPath");
}
Interp masterInterp = getInterp(interp, objv[2]);
Channel chan = TclIO.getChannel(masterInterp, objv[3].ToString());
if (chan == null)
{
throw new TclException(interp, "can not find channel named \"" + objv[3].ToString() + "\"");
}
Interp slaveInterp = getInterp(interp, objv[4]);
TclIO.registerChannel(slaveInterp, chan);
break;
}
case OPT_TARGET:
{
if (objv.Length != 4)
{
throw new TclNumArgsException(interp, 2, objv, "path alias");
}
Interp slaveInterp = getInterp(interp, objv[2]);
string aliasName = objv[3].ToString();
Interp targetInterp = InterpAliasCmd.getTargetInterp(slaveInterp, aliasName);
if (targetInterp == null)
{
throw new TclException(interp, "alias \"" + aliasName + "\" in path \"" + objv[2].ToString() + "\" not found");
}
if (!getInterpPath(interp, targetInterp))
{
throw new TclException(interp, "target interpreter for alias \"" + aliasName + "\" in path \"" + objv[2].ToString() + "\" is not my descendant");
}
break;
}
case OPT_TRANSFER:
{
if (objv.Length != 5)
{
throw new TclNumArgsException(interp, 2, objv, "srcPath channelId destPath");
}
Interp masterInterp = getInterp(interp, objv[2]);
Channel chan = TclIO.getChannel(masterInterp, objv[3].ToString());
if (chan == null)
{
throw new TclException(interp, "can not find channel named \"" + objv[3].ToString() + "\"");
}
Interp slaveInterp = getInterp(interp, objv[4]);
TclIO.registerChannel(slaveInterp, chan);
TclIO.unregisterChannel(masterInterp, chan);
break;
}
}
return(TCL.CompletionCode.RETURN);
}
private const char FORMAT_END = ' '; // End of format was found.
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
{
int arg; // Index of next argument to consume.
char[] format = null; // User specified format string.
char cmd; // Current format character.
int cursor; // Current position within result buffer.
int maxPos; // Greatest position within result buffer that cursor has visited.
int value = 0; // Current integer value to be packed.
int offset, size = 0, length; // Initialized to avoid compiler warning.
if (argv.Length < 2)
{
throw new TclNumArgsException(interp, 1, argv, "option ?arg arg ...?");
}
int cmdIndex = TclIndex.Get(interp, argv[1], _validCmds, "option", 0);
switch (cmdIndex)
{
case CMD_FORMAT:
{
if (argv.Length < 3)
{
throw new TclNumArgsException(interp, 2, argv, "formatString ?arg arg ...?");
}
// To avoid copying the data, we format the string in two passes. The first pass computes the size of the output buffer. The
// second pass places the formatted data into the buffer.
format = argv[2].ToString().ToCharArray();
arg = 3;
length = 0;
offset = 0;
int parsePos = 0;
while ((cmd = GetFormatSpec(format, ref parsePos)) != FORMAT_END)
{
int count = GetFormatCount(format, ref parsePos);
switch (cmd)
{
case 'a':
case 'A':
case 'b':
case 'B':
case 'h':
case 'H':
{
// For string-type specifiers, the count corresponds to the number of bytes in a single argument.
if (arg >= argv.Length)
{
MissingArg(interp);
}
if (count == BINARY_ALL)
{
count = TclByteArray.getLength(interp, argv[arg]);
}
else if (count == BINARY_NOCOUNT)
{
count = 1;
}
arg++;
switch (cmd)
{
case 'a':
case 'A':
offset += count;
break;
case 'b':
case 'B':
offset += (count + 7) / 8;
break;
case 'h':
case 'H':
offset += (count + 1) / 2;
break;
}
break;
}
case 'c':
case 's':
case 'S':
case 'i':
case 'I':
case 'f':
case 'd':
{
if (arg >= argv.Length)
{
MissingArg(interp);
}
switch (cmd)
{
case 'c':
size = 1;
break;
case 's':
case 'S':
size = 2;
break;
case 'i':
case 'I':
size = 4;
break;
case 'f':
size = 4;
break;
case 'd':
size = 8;
break;
}
// For number-type specifiers, the count corresponds to the number of elements in the list stored in
// a single argument. If no count is specified, then the argument is taken as a single non-list value.
if (count == BINARY_NOCOUNT)
{
arg++;
count = 1;
}
else
{
int listc = TclList.getLength(interp, argv[arg++]);
if (count == BINARY_ALL)
{
count = listc;
}
else if (count > listc)
{
throw new TclException(interp, "number of elements in list" + " does not match count");
}
}
offset += count * size;
break;
}
case 'x':
{
if (count == BINARY_ALL)
{
throw new TclException(interp, "cannot use \"*\"" + " in format string with \"x\"");
}
if (count == BINARY_NOCOUNT)
{
count = 1;
}
offset += count;
break;
}
case 'X':
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count > offset || count == BINARY_ALL)
{
count = offset;
}
if (offset > length)
{
length = offset;
}
offset -= count;
break;
}
case '@':
{
if (offset > length)
{
length = offset;
}
if (count == BINARY_ALL)
{
offset = length;
}
else if (count == BINARY_NOCOUNT)
{
AlephWithoutCount(interp);
}
else
{
offset = count;
}
break;
}
default:
{
BadField(interp, cmd);
}
break;
}
}
if (offset > length)
{
length = offset;
}
if (length == 0)
{
return(TCL.CompletionCode.RETURN);
}
// Prepare the result object by preallocating the calculated number of bytes and filling with nulls.
TclObject resultObj = TclByteArray.NewInstance();
byte[] resultBytes = TclByteArray.SetLength(interp, resultObj, length);
interp.SetResult(resultObj);
// Pack the data into the result object. Note that we can skip the error checking during this pass, since we have already parsed the string once.
arg = 3;
cursor = 0;
maxPos = cursor;
parsePos = 0;
while ((cmd = GetFormatSpec(format, ref parsePos)) != FORMAT_END)
{
int count = GetFormatCount(format, ref parsePos);
if (count == 0 && cmd != '@')
{
arg++;
continue;
}
switch (cmd)
{
case 'a':
case 'A':
{
byte pad = (cmd == 'a' ? (byte)0 : (byte)SupportClass.Identity(' '));
byte[] bytes = TclByteArray.getBytes(interp, argv[arg++]);
length = bytes.Length;
if (count == BINARY_ALL)
{
count = length;
}
else if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (length >= count)
{
Array.Copy(bytes, 0, resultBytes, cursor, count);
}
else
{
Array.Copy(bytes, 0, resultBytes, cursor, length);
for (int ix = 0; ix < count - length; ix++)
{
resultBytes[cursor + length + ix] = pad;
}
}
cursor += count;
break;
}
case 'b':
case 'B':
{
char[] str = argv[arg++].ToString().ToCharArray();
if (count == BINARY_ALL)
{
count = str.Length;
}
else if (count == BINARY_NOCOUNT)
{
count = 1;
}
int last = cursor + ((count + 7) / 8);
if (count > str.Length)
{
count = str.Length;
}
if (cmd == 'B')
{
for (offset = 0; offset < count; offset++)
{
value <<= 1;
if (str[offset] == '1')
{
value |= 1;
}
else if (str[offset] != '0')
{
ExpectedButGot(interp, "binary", new string(str));
}
if (((offset + 1) % 8) == 0)
{
resultBytes[cursor++] = (byte)value;
value = 0;
}
}
}
else
{
for (offset = 0; offset < count; offset++)
{
value >>= 1;
if (str[offset] == '1')
{
value |= 128;
}
else if (str[offset] != '0')
{
ExpectedButGot(interp, "binary", new string(str));
}
if (((offset + 1) % 8) == 0)
{
resultBytes[cursor++] = (byte)value;
value = 0;
}
}
}
if ((offset % 8) != 0)
{
if (cmd == 'B')
{
value <<= 8 - (offset % 8);
}
else
{
value >>= 8 - (offset % 8);
}
resultBytes[cursor++] = (byte)value;
}
while (cursor < last)
{
resultBytes[cursor++] = 0;
}
break;
}
case 'h':
case 'H':
{
char[] str = argv[arg++].ToString().ToCharArray();
if (count == BINARY_ALL)
{
count = str.Length;
}
else if (count == BINARY_NOCOUNT)
{
count = 1;
}
int last = cursor + ((count + 1) / 2);
if (count > str.Length)
{
count = str.Length;
}
if (cmd == 'H')
{
for (offset = 0; offset < count; offset++)
{
value <<= 4;
int c = HEXDIGITS.IndexOf(Char.ToLower(str[offset]));
if (c < 0)
{
ExpectedButGot(interp, "hexadecimal", new string(str));
}
value |= (c & 0xf);
if ((offset % 2) != 0)
{
resultBytes[cursor++] = (byte)value;
value = 0;
}
}
}
else
{
for (offset = 0; offset < count; offset++)
{
value >>= 4;
int c = HEXDIGITS.IndexOf(Char.ToLower(str[offset]));
if (c < 0)
{
ExpectedButGot(interp, "hexadecimal", new string(str));
}
value |= ((c << 4) & 0xf0);
if ((offset % 2) != 0)
{
resultBytes[cursor++] = (byte)value;
value = 0;
}
}
}
if ((offset % 2) != 0)
{
if (cmd == 'H')
{
value <<= 4;
}
else
{
value >>= 4;
}
resultBytes[cursor++] = (byte)value;
}
while (cursor < last)
{
resultBytes[cursor++] = 0;
}
break;
}
case 'c':
case 's':
case 'S':
case 'i':
case 'I':
case 'f':
case 'd':
{
TclObject[] listv;
if (count == BINARY_NOCOUNT)
{
listv = new TclObject[1];
listv[0] = argv[arg++];
count = 1;
}
else
{
listv = TclList.getElements(interp, argv[arg++]);
if (count == BINARY_ALL)
{
count = listv.Length;
}
}
for (int ix = 0; ix < count; ix++)
{
cursor = FormatNumber(interp, cmd, listv[ix], resultBytes, cursor);
}
break;
}
case 'x':
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
for (int ix = 0; ix < count; ix++)
{
resultBytes[cursor++] = 0;
}
break;
}
case 'X':
{
if (cursor > maxPos)
{
maxPos = cursor;
}
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count == BINARY_ALL || count > cursor)
{
cursor = 0;
}
else
{
cursor -= count;
}
break;
}
case '@':
{
if (cursor > maxPos)
{
maxPos = cursor;
}
if (count == BINARY_ALL)
{
cursor = maxPos;
}
else
{
cursor = count;
}
break;
}
}
}
break;
}
case CMD_SCAN:
{
if (argv.Length < 4)
{
throw new TclNumArgsException(interp, 2, argv, "value formatString ?varName varName ...?");
}
byte[] src = TclByteArray.getBytes(interp, argv[2]);
length = src.Length;
format = argv[3].ToString().ToCharArray();
arg = 4;
cursor = 0;
offset = 0;
int parsePos = 0;
while ((cmd = GetFormatSpec(format, ref parsePos)) != FORMAT_END)
{
int count = GetFormatCount(format, ref parsePos);
switch (cmd)
{
case 'a':
case 'A':
{
if (arg >= argv.Length)
{
MissingArg(interp);
}
if (count == BINARY_ALL)
{
count = length - offset;
}
else
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count > length - offset)
{
break;
}
}
size = count;
// Trim trailing nulls and spaces, if necessary.
if (cmd == 'A')
{
while (size > 0)
{
if (src[offset + size - 1] != '\x0000' && src[offset + size - 1] != ' ')
{
break;
}
size--;
}
}
interp.SetVar(argv[arg++], TclByteArray.NewInstance(src, offset, size), 0);
offset += count;
break;
}
case 'b':
case 'B':
{
if (arg >= argv.Length)
{
MissingArg(interp);
}
if (count == BINARY_ALL)
{
count = (length - offset) * 8;
}
else
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count > (length - offset) * 8)
{
break;
}
}
StringBuilder s = new StringBuilder(count);
int thisOffset = offset;
if (cmd == 'b')
{
for (int ix = 0; ix < count; ix++)
{
if ((ix % 8) != 0)
{
value >>= 1;
}
else
{
value = src[thisOffset++];
}
s.Append((value & 1) != 0 ? '1' : '0');
}
}
else
{
for (int ix = 0; ix < count; ix++)
{
if ((ix % 8) != 0)
{
value <<= 1;
}
else
{
value = src[thisOffset++];
}
s.Append((value & 0x80) != 0 ? '1' : '0');
}
}
interp.SetVar(argv[arg++], TclString.NewInstance(s.ToString()), 0);
offset += (count + 7) / 8;
break;
}
case 'h':
case 'H':
{
if (arg >= argv.Length)
{
MissingArg(interp);
}
if (count == BINARY_ALL)
{
count = (length - offset) * 2;
}
else
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count > (length - offset) * 2)
{
break;
}
}
StringBuilder s = new StringBuilder(count);
int thisOffset = offset;
if (cmd == 'h')
{
for (int ix = 0; ix < count; ix++)
{
if ((ix % 2) != 0)
{
value >>= 4;
}
else
{
value = src[thisOffset++];
}
s.Append(HEXDIGITS[value & 0xf]);
}
}
else
{
for (int ix = 0; ix < count; ix++)
{
if ((ix % 2) != 0)
{
value <<= 4;
}
else
{
value = src[thisOffset++];
}
s.Append(HEXDIGITS[value >> 4 & 0xf]);
}
}
interp.SetVar(argv[arg++], TclString.NewInstance(s.ToString()), 0);
offset += (count + 1) / 2;
break;
}
case 'c':
case 's':
case 'S':
case 'i':
case 'I':
case 'f':
case 'd':
{
if (arg >= argv.Length)
{
MissingArg(interp);
}
switch (cmd)
{
case 'c':
size = 1;
break;
case 's':
case 'S':
size = 2;
break;
case 'i':
case 'I':
size = 4;
break;
case 'f':
size = 4;
break;
case 'd':
size = 8;
break;
}
TclObject valueObj;
if (count == BINARY_NOCOUNT)
{
if (length - offset < size)
{
break;
}
valueObj = ScanNumber(src, offset, cmd);
offset += size;
}
else
{
if (count == BINARY_ALL)
{
count = (length - offset) / size;
}
if (length - offset < count * size)
{
break;
}
valueObj = TclList.NewInstance();
int thisOffset = offset;
for (int ix = 0; ix < count; ix++)
{
TclList.Append(null, valueObj, ScanNumber(src, thisOffset, cmd));
thisOffset += size;
}
offset += count * size;
}
interp.SetVar(argv[arg++], valueObj, 0);
break;
}
case 'x':
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count == BINARY_ALL || count > length - offset)
{
offset = length;
}
else
{
offset += count;
}
break;
}
case 'X':
{
if (count == BINARY_NOCOUNT)
{
count = 1;
}
if (count == BINARY_ALL || count > offset)
{
offset = 0;
}
else
{
offset -= count;
}
break;
}
case '@':
{
if (count == BINARY_NOCOUNT)
{
AlephWithoutCount(interp);
}
if (count == BINARY_ALL || count > length)
{
offset = length;
}
else
{
offset = count;
}
break;
}
default:
{
BadField(interp, cmd);
}
break;
}
}
// Set the result to the last position of the cursor.
interp.SetResult(arg - 4);
}
break;
}
return(TCL.CompletionCode.RETURN);
}
internal static double getDouble(Interp interp, string s)
{
int len = s.Length;
bool sign;
int i = 0;
// Skip any leading blanks.
while (i < len && System.Char.IsWhiteSpace(s[i]))
{
i++;
}
if (i >= len)
{
throw new TclException(interp, "expected floating-point number but got \"" + s + "\"");
}
char c = s[i];
if (c == '-')
{
sign = true;
i += 1;
}
else
{
if (c == '+')
{
i += 1;
}
sign = false;
}
StrtodResult res = Strtod(s, i);
if (res.errno != 0)
{
if (res.errno == TCL.DOUBLE_RANGE)
{
if (interp != null)
{
interp.SetErrorCode(TclString.NewInstance(fpTooBigCode));
}
throw new TclException(interp, "floating-point value too large to represent");
}
else
{
throw new TclException(interp, "expected floating-point number but got \"" + s + "\"");
}
}
else if (res.index < len)
{
for (i = res.index; i < len; i++)
{
if (!System.Char.IsWhiteSpace(s[i]))
{
throw new TclException(interp, "expected floating-point number but got \"" + s + "\"");
}
}
}
if (sign)
{
return((double)(-res.value));
}
else
{
return((double)(res.value));
}
}
internal static long getLong(Interp interp, string s)
{
int len = s.Length;
bool sign;
int i = 0;
// Skip any leading blanks.
while (i < len && System.Char.IsWhiteSpace(s[i]))
{
i++;
}
if (i >= len)
{
throw new TclException(interp, "expected integer but got \"" + s + "\"");
}
char c = s[i];
if (c == '-')
{
sign = true;
i += 1;
}
else
{
if (c == '+')
{
i += 1;
}
sign = false;
}
StrtoulResult res = Strtoul(s, i, 0);
if (res.errno < 0)
{
if (res.errno == TCL.INTEGER_RANGE)
{
if (interp != null)
{
interp.SetErrorCode(TclString.NewInstance(intTooBigCode));
}
throw new TclException(interp, "integer value too large to represent");
}
else
{
throw new TclException(interp, "expected integer but got \"" + s + "\"" + checkBadOctal(interp, s));
}
}
else if (res.Index < len)
{
for (i = res.Index; i < len; i++)
{
if (!System.Char.IsWhiteSpace(s[i]))
{
throw new TclException(interp, "expected integer but got \"" + s + "\"" + checkBadOctal(interp, s));
}
}
}
if (sign)
{
return((long)(-res.value));
}
else
{
return((long)(res.value));
}
}
/// <summary> Tcl_ForeachObjCmd -> ForeachCmd.cmdProc
///
/// This procedure is invoked to process the "foreach" Tcl command.
/// See the user documentation for details on what it does.
///
/// </summary>
/// <param name="interp">the current interpreter.
/// </param>
/// <param name="objv">command arguments.
/// </param>
/// <exception cref=""> TclException if script causes error.
/// </exception>
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
{
if (objv.Length < 4 || (objv.Length % 2) != 0)
{
throw new TclNumArgsException(interp, 1, objv, "varList list ?varList list ...? command");
}
// foreach {n1 n2} {1 2 3 4} {n3} {1 2} {puts $n1-$n2-$n3}
// name[0] = {n1 n2} value[0] = {1 2 3 4}
// name[1] = {n3} value[0] = {1 2}
TclObject[] name = new TclObject[(objv.Length - 2) / 2];
TclObject[] value = new TclObject[(objv.Length - 2) / 2];
int c, i, j, base_;
int maxIter = 0;
TclObject command = objv[objv.Length - 1];
bool done = false;
for (i = 0; i < objv.Length - 2; i += 2)
{
int x = i / 2;
name[x] = objv[i + 1];
value[x] = objv[i + 2];
int nSize = TclList.getLength(interp, name[x]);
int vSize = TclList.getLength(interp, value[x]);
if (nSize == 0)
{
throw new TclException(interp, "foreach varlist is empty");
}
int iter = (vSize + nSize - 1) / nSize;
if (maxIter < iter)
{
maxIter = iter;
}
}
for (c = 0; !done && c < maxIter; c++)
{
// Set up the variables
for (i = 0; i < objv.Length - 2; i += 2)
{
int x = i / 2;
int nSize = TclList.getLength(interp, name[x]);
base_ = nSize * c;
for (j = 0; j < nSize; j++)
{
// Test and see if the name variable is an array.
Var[] result = Var.LookupVar(interp, name[x].ToString(), null, 0, null, false, false);
Var var = null;
if (result != null)
{
if (result[1] != null)
{
var = result[1];
}
else
{
var = result[0];
}
}
try
{
if (base_ + j >= TclList.getLength(interp, value[x]))
{
interp.SetVar(TclList.index(interp, name[x], j), TclString.NewInstance(""), 0);
}
else
{
interp.SetVar(TclList.index(interp, name[x], j), TclList.index(interp, value[x], base_ + j), 0);
}
}
catch (TclException e)
{
throw new TclException(interp, "couldn't set loop variable: \"" + TclList.index(interp, name[x], j) + "\"");
}
}
}
// Execute the script
try
{
interp.Eval(command, 0);
}
catch (TclException e)
{
switch (e.GetCompletionCode())
{
case TCL.CompletionCode.BREAK:
done = true;
break;
case TCL.CompletionCode.CONTINUE:
continue;
case TCL.CompletionCode.ERROR:
interp.AddErrorInfo("\n (\"foreach\" body line " + interp._errorLine + ")");
throw;
default:
throw;
}
}
}
interp.ResetResult();
return(TCL.CompletionCode.RETURN);
}
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
{
bool all = false;
bool nocase = false;
try
{
int i = 1;
while (argv[i].ToString().StartsWith("-"))
{
int index = TclIndex.Get(interp, argv[i], validOpts, "switch", 0);
i++;
switch (index)
{
case OPT_ALL:
{
all = true;
break;
}
case OPT_NOCASE:
{
nocase = true;
break;
}
case OPT_LAST:
{
goto opts_brk;
}
}
}
opts_brk:
;
TclObject exp = argv[i++];
string inString = argv[i++].ToString();
string subSpec = argv[i++].ToString();
string varName = null;
if (i != argv.Length)
{
varName = argv[i++].ToString();
}
if (i != argv.Length)
{
throw new System.IndexOutOfRangeException();
}
Regexp r = TclRegexp.compile(interp, exp, nocase);
int count = 0;
string result;
if (all == false)
{
result = r.sub(inString, subSpec);
if ((System.Object)result == null)
{
result = inString;
}
else
{
count++;
}
}
else
{
StringBuilder sb = new StringBuilder();
Regsub s = new Regsub(r, inString);
while (s.nextMatch())
{
count++;
sb.Append(s.skipped());
Regexp.applySubspec(s, subSpec, sb);
}
sb.Append(s.rest());
result = sb.ToString();
}
TclObject obj = TclString.NewInstance(result);
if (varName == null)
{
interp.SetResult(result);
}
else
{
try
{
interp.SetVar(varName, obj, 0);
}
catch (TclException e)
{
throw new TclException(interp, "couldn't set variable \"" + varName + "\"");
}
interp.SetResult(count);
}
}
catch (System.IndexOutOfRangeException e)
{
throw new TclNumArgsException(interp, 1, argv, "?switches? exp string subSpec ?varName?");
}
return(TCL.CompletionCode.RETURN);
}
