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); }