internal static void eval(Interp interp, Interp slaveInterp, int objIx, TclObject[] objv) { TCL.CompletionCode result; slaveInterp.preserve(); slaveInterp.allowExceptions(); try { if (objIx + 1 == objv.Length) { slaveInterp.eval(objv[objIx], 0); } else { TclObject obj = TclList.newInstance(); for (int ix = objIx; ix < objv.Length; ix++) { TclList.append(interp, obj, objv[ix]); } obj.preserve(); slaveInterp.eval(obj, 0); obj.release(); } result = slaveInterp.returnCode; } catch (TclException e) { result = e.getCompletionCode(); } slaveInterp.release(); interp.transferResult(slaveInterp, result); }
public static void Tcl_Free(ref TclObject to) { while (to.refCount > 0) { to.release(); } }
/// <summary> Chain this frame into the call frame stack and binds the parameters /// values to the formal parameters of the procedure. /// /// </summary> /// <param name="proc">the procedure. /// </param> /// <param name="proc">argv the parameter values. /// </param> /// <exception cref=""> TclException if wrong number of arguments. /// </exception> internal void chain( Procedure proc, TclObject[] objv ) { // FIXME: double check this ns thing in case where proc is renamed to different ns. this.ns = proc.ns; this.objv = objv; // FIXME : quick level hack : fix later level = ( interp.varFrame == null ) ? 1 : ( interp.varFrame.level + 1 ); caller = interp.frame; callerVar = interp.varFrame; interp.frame = this; interp.varFrame = this; // parameter bindings int numArgs = proc.argList.Length; if ( ( !proc.isVarArgs ) && ( objv.Length - 1 > numArgs ) ) { wrongNumProcArgs( objv[0], proc ); } int i, j; for ( i = 0, j = 1; i < numArgs; i++, j++ ) { // Handle the special case of the last formal being // "args". When it occurs, assign it a list consisting of // all the remaining actual arguments. TclObject varName = proc.argList[i][0]; TclObject value = null; if ( ( i == ( numArgs - 1 ) ) && proc.isVarArgs ) { value = TclList.newInstance(); value.preserve(); for ( int k = j; k < objv.Length; k++ ) { TclList.append( interp, value, objv[k] ); } interp.setVar( varName, value, 0 ); value.release(); } else { if ( j < objv.Length ) { value = objv[j]; } else if ( proc.argList[i][1] != null ) { value = proc.argList[i][1]; } else { wrongNumProcArgs( objv[0], proc ); } interp.setVar( varName, value, 0 ); } } }
public static void Tcl_DecrRefCount(ref TclObject to) { to.release(); if (to.internalRep == null) { to = null; } }
public static void Tcl_SetLongObj(TclObject to, long result) { while (to.Shared) { to.release(); } TclLong.set(to, result); to.preserve(); }
public static void Tcl_SetIntObj(TclObject to, int result ) { while (to.Shared) { to.release(); } TclInteger.set(to, result); to.preserve(); }
public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { targetInterp.preserve(); targetInterp.nestLevel++; targetInterp.resetResult(); targetInterp.allowExceptions(); // Append the arguments to the command prefix and invoke the command // in the target interp's global namespace. TclObject[] prefv = TclList.getElements(interp, prefix); TclObject cmd = TclList.newInstance(); cmd.preserve(); TclList.replace(interp, cmd, 0, 0, prefv, 0, prefv.Length - 1); TclList.replace(interp, cmd, prefv.Length, 0, argv, 1, argv.Length - 1); TclObject[] cmdv = TclList.getElements(interp, cmd); TCL.CompletionCode result = targetInterp.invoke(cmdv, Interp.INVOKE_NO_TRACEBACK); cmd.release(); targetInterp.nestLevel--; // Check if we are at the bottom of the stack for the target interpreter. // If so, check for special return codes. if (targetInterp.nestLevel == 0) { if (result == TCL.CompletionCode.RETURN) { result = targetInterp.updateReturnInfo(); } if (result != TCL.CompletionCode.OK && result != TCL.CompletionCode.ERROR) { try { targetInterp.processUnexpectedResult(result); } catch (TclException e) { result = e.getCompletionCode(); } } } targetInterp.release(); interp.transferResult(targetInterp, result); return(TCL.CompletionCode.RETURN); }
public void disposeCmd() { if ((System.Object)aliasEntry != null) { SupportClass.HashtableRemove(slaveInterp.aliasTable, aliasEntry); } if (slaveCmd != null) { SupportClass.HashtableRemove(targetInterp.targetTable, slaveCmd); } name.release(); prefix.release(); }
public override void processIdleEvent() { try { SupportClass.VectorRemoveElement(Enclosing_Instance.assocData.handlers, this); interp.eval(command, TCL.EVAL_GLOBAL); } catch (TclException e) { interp.addErrorInfo("\n (\"after\" script)"); interp.backgroundError(); } finally { command.release(); command = null; } }
/// <summary> See Tcl user documentation for details.</summary> public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { TclObject list = TclList.newInstance(); list.preserve(); try { for (int i = 1; i < argv.Length; i++) { TclList.append(interp, list, argv[i]); } interp.setResult(list); } finally { list.release(); } return(TCL.CompletionCode.RETURN); }
/// <summary> This procedure replaces zero or more elements of the list /// referenced by tobj with the objects from an TclObject array. /// If tobj is not a list object, an attempt will be made to /// convert it to a list. /// /// </summary> /// <param name="interp">current interpreter. /// </param> /// <param name="tobj">the TclObject to use as a list. /// </param> /// <param name="index">the starting index of the replace operation. <=0 means /// the beginning of the list. >= TclList.getLength(tobj) means /// the end of the list. /// </param> /// <param name="count">the number of elements to delete from the list. <=0 means /// no elements should be deleted and the operation is equivalent to /// an insertion operation. /// </param> /// <param name="elements">the element(s) to insert. /// </param> /// <param name="from">insert elements starting from elements[from] (inclusive) /// </param> /// <param name="to">insert elements up to elements[to] (inclusive) /// </param> /// <exception cref=""> TclException if tobj is not a valid list. /// </exception> public static void replace(Interp interp, TclObject tobj, int index, int count, TclObject[] elements, int from, int to) { if (tobj.Shared) { throw new TclRuntimeError("TclList.replace() called with shared object"); } setListFromAny(interp, tobj); tobj.invalidateStringRep(); TclList tlist = (TclList)tobj.InternalRep; int size = tlist.vector.Count; int i; if (index >= size) { // Append to the end of the list. There is no need for deleting // elements. index = size; } else { if (index < 0) { index = 0; } if (count > size - index) { count = size - index; } for (i = 0; i < count; i++) { TclObject obj = (TclObject)tlist.vector[index]; obj.release(); tlist.vector.RemoveAt(index); } } for (i = from; i <= to; i++) { elements[i].preserve(); tlist.vector.Insert(index++, elements[i]); } }
/// <summary> See Tcl user documentation for details.</summary> /// <exception cref=""> TclException If incorrect number of arguments. /// </exception> public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { if (argv.Length < 4) { throw new TclNumArgsException(interp, 1, argv, "list index element ?element ...?"); } int size = TclList.getLength(interp, argv[1]); int index = Util.getIntForIndex(interp, argv[2], size); TclObject list = argv[1]; bool isDuplicate = false; // If the list object is unshared we can modify it directly. Otherwise // we create a copy to modify: this is "copy on write". if (list.Shared) { list = list.duplicate(); isDuplicate = true; } try { TclList.insert(interp, list, index, argv, 3, argv.Length - 1); interp.setResult(list); } catch (TclException e) { if (isDuplicate) { list.release(); } throw; } return(TCL.CompletionCode.RETURN); }
public void release() { value.release(); }
/// <summary> See Tcl user documentation for details.</summary> /// <exception cref=""> TclException If incorrect number of arguments. /// </exception> public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { if (argv.Length < 4) { throw new TclNumArgsException(interp, 1, argv, "list first last ?element element ...?"); } int size = TclList.getLength(interp, argv[1]); int first = Util.getIntForIndex(interp, argv[2], size - 1); int last = Util.getIntForIndex(interp, argv[3], size - 1); int numToDelete; if (first < 0) { first = 0; } // Complain if the user asked for a start element that is greater // than the list length. This won't ever trigger for the "end*" // case as that will be properly constrained by getIntForIndex // because we use size-1 (to allow for replacing the last elem). if ((first >= size) && (size > 0)) { throw new TclException(interp, "list doesn't contain element " + argv[2]); } if (last >= size) { last = size - 1; } if (first <= last) { numToDelete = (last - first + 1); } else { numToDelete = 0; } TclObject list = argv[1]; bool isDuplicate = false; // If the list object is unshared we can modify it directly. Otherwise // we create a copy to modify: this is "copy on write". if (list.Shared) { list = list.duplicate(); isDuplicate = true; } try { TclList.replace(interp, list, first, numToDelete, argv, 4, argv.Length - 1); interp.setResult(list); } catch (TclException e) { if (isDuplicate) { list.release(); } throw; } return(TCL.CompletionCode.RETURN); }
/// <summary> This procedure is invoked to process the "split" Tcl /// command. See Tcl user documentation for details. /// /// </summary> /// <param name="interp">the current interpreter. /// </param> /// <param name="argv">command arguments. /// </param> /// <exception cref=""> TclException If incorrect number of arguments. /// </exception> public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { char[] splitChars = null; string inString; if (argv.Length == 2) { splitChars = defSplitChars; } else if (argv.Length == 3) { splitChars = argv[2].ToString().ToCharArray(); } else { throw new TclNumArgsException(interp, 1, argv, "string ?splitChars?"); } inString = argv[1].ToString(); int len = inString.Length; int num = splitChars.Length; /* * Handle the special case of splitting on every character. */ if (num == 0) { TclObject list = TclList.newInstance(); list.preserve(); try { for (int i = 0; i < len; i++) { TclList.append(interp, list, TclString.newInstance(inString[i])); } interp.setResult(list); } finally { list.release(); } return(TCL.CompletionCode.RETURN); } /* * Normal case: split on any of a given set of characters. * Discard instances of the split characters. */ TclObject list2 = TclList.newInstance(); int elemStart = 0; list2.preserve(); try { int i, j; for (i = 0; i < len; i++) { char c = inString[i]; for (j = 0; j < num; j++) { if (c == splitChars[j]) { TclList.append(interp, list2, TclString.newInstance(inString.Substring(elemStart, (i) - (elemStart)))); elemStart = i + 1; break; } } } if (i != 0) { TclList.append(interp, list2, TclString.newInstance(inString.Substring(elemStart))); } interp.setResult(list2); } finally { list2.release(); } return(TCL.CompletionCode.RETURN); }
public static void Tcl_DStringFree(ref TclObject str) { str.release(); }
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) && (System.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 = System.DateTime.Now.Ticks / 10000 + ms; while (true) { try { System.Threading.Thread.Sleep(ms); return(TCL.CompletionCode.RETURN); } catch (System.Threading.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> See Tcl user documentation for details.</summary> /// <exception cref=""> TclException If incorrect number of arguments. /// </exception> public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { if (argv.Length != 4) { throw new TclNumArgsException(interp, 1, argv, "list first last"); } int size = TclList.getLength(interp, argv[1]); int first; int last; first = Util.getIntForIndex(interp, argv[2], size - 1); last = Util.getIntForIndex(interp, argv[3], size - 1); if (last < 0) { interp.resetResult(); return(TCL.CompletionCode.RETURN); } if (first >= size) { interp.resetResult(); return(TCL.CompletionCode.RETURN); } if (first <= 0 && last >= size) { interp.setResult(argv[1]); return(TCL.CompletionCode.RETURN); } if (first < 0) { first = 0; } if (first >= size) { first = size - 1; } if (last < 0) { last = 0; } if (last >= size) { last = size - 1; } if (first > last) { interp.resetResult(); return(TCL.CompletionCode.RETURN); } TclObject list = TclList.newInstance(); list.preserve(); try { for (int i = first; i <= last; i++) { TclList.append(interp, list, TclList.index(interp, argv[1], i)); } interp.setResult(list); } finally { list.release(); } return(TCL.CompletionCode.RETURN); }
/* *---------------------------------------------------------------------- * * cmdProc -- * * This procedure is invoked as part of the Command interface to * process the "lsort" Tcl command. See the user documentation for * details on what it does. * * Results: * A standard Tcl result. * * Side effects: * See the user documentation. * *---------------------------------------------------------------------- */ public TCL.CompletionCode cmdProc(Interp interp, TclObject[] argv) { if (argv.Length < 2) { throw new TclNumArgsException(interp, 1, argv, "?options? list"); } string command = null; int sortMode = QSort.ASCII; int sortIndex = -1; bool sortIncreasing = true; bool unique = false; for (int i = 1; i < argv.Length - 1; i++) { int index = TclIndex.get(interp, argv[i], validOpts, "option", 0); switch (index) { case 0: sortMode = QSort.ASCII; break; case 1: if (i == argv.Length - 2) { throw new TclException(interp, "\"-command\" option must be" + " followed by comparison command"); } sortMode = QSort.COMMAND; command = argv[i + 1].ToString(); i++; break; case 2: sortIncreasing = false; break; case 3: sortMode = QSort.DICTIONARY; break; case 4: sortIncreasing = true; break; case 5: if (i == argv.Length - 2) { throw new TclException(interp, "\"-index\" option must be followed by list index"); } sortIndex = Util.getIntForIndex(interp, argv[i + 1], -2); command = argv[i + 1].ToString(); i++; break; case 6: sortMode = QSort.INTEGER; break; case 7: sortMode = QSort.REAL; break; case 8: /* -unique */ unique = true; break; } } TclObject list = argv[argv.Length - 1]; bool isDuplicate = false; // If the list object is unshared we can modify it directly. Otherwise // we create a copy to modify: this is "copy on write". if (list.Shared) { list = list.duplicate(); isDuplicate = true; } try { TclList.sort(interp, list, sortMode, sortIndex, sortIncreasing, command, unique); interp.setResult(list); } catch (TclException e) { if (isDuplicate) { list.release(); } throw; } return(TCL.CompletionCode.RETURN); }
public TCL.CompletionCode cmdProc(Interp interp, TclObject[] objv) { int len; if (objv.Length < 2) { throw new TclNumArgsException(interp, 1, objv, "option [arg arg ...]"); } int opt = TclIndex.get(interp, objv[1], validCmds, "option", 0); switch (opt) { case OPT_VARIABLE: case OPT_VDELETE: if (objv.Length != 5) { if (opt == OPT_VARIABLE) { throw new TclNumArgsException(interp, 1, objv, "variable name ops command"); } else { throw new TclNumArgsException(interp, 1, objv, "vdelete name ops command"); } } TCL.VarFlag flags = 0; string ops = objv[3].ToString(); len = ops.Length; { for (int i = 0; i < len; i++) { switch (ops[i]) { case 'r': flags |= TCL.VarFlag.TRACE_READS; break; case 'w': flags |= TCL.VarFlag.TRACE_WRITES; break; case 'u': flags |= TCL.VarFlag.TRACE_UNSETS; break; default: flags = 0; goto check_ops_brk; } } } check_ops_brk: ; if (flags == 0) { throw new TclException(interp, "bad operations \"" + objv[3] + "\": should be one or more of rwu"); } if (opt == OPT_VARIABLE) { CmdTraceProc trace = new CmdTraceProc(objv[4].ToString(), flags); Var.traceVar(interp, objv[2], flags, trace); } else { // Search through all of our traces on this variable to // see if there's one with the given command. If so, then // delete the first one that matches. ArrayList traces = Var.getTraces(interp, objv[2].ToString(), 0); if (traces != null) { len = traces.Count; for (int i = 0; i < len; i++) { TraceRecord rec = (TraceRecord)traces[i]; if (rec.trace is CmdTraceProc) { CmdTraceProc proc = (CmdTraceProc)rec.trace; if (proc.flags == flags && proc.command.ToString().Equals(objv[4].ToString())) { Var.untraceVar(interp, objv[2], flags, proc); break; } } } } } break; case OPT_VINFO: if (objv.Length != 3) { throw new TclNumArgsException(interp, 2, objv, "name"); } ArrayList traces2 = Var.getTraces(interp, objv[2].ToString(), 0); if (traces2 != null) { len = traces2.Count; TclObject list = TclList.newInstance(); TclObject cmd = null; list.preserve(); try { for (int i = 0; i < len; i++) { TraceRecord rec = (TraceRecord)traces2[i]; if (rec.trace is CmdTraceProc) { CmdTraceProc proc = (CmdTraceProc)rec.trace; TCL.VarFlag mode = proc.flags; mode &= (TCL.VarFlag.TRACE_READS | TCL.VarFlag.TRACE_WRITES | TCL.VarFlag.TRACE_UNSETS); int modeInt = (int)mode; modeInt /= ((int)TCL.VarFlag.TRACE_READS); cmd = TclList.newInstance(); TclList.append(interp, cmd, opStr[modeInt]); TclList.append(interp, cmd, TclString.newInstance(proc.command)); TclList.append(interp, list, cmd); } } interp.setResult(list); } finally { list.release(); } } break; } return(TCL.CompletionCode.RETURN); }
public override int processEvent(int flags) { // See if the command is a complete Tcl command if (Interp.commandComplete(command)) { if (tcl.lang.ConsoleThread.debug) { WriteLine("line was a complete command"); } bool eval_exception = true; TclObject commandObj = TclString.newInstance(command); try { commandObj.preserve(); Enclosing_Instance.interp.recordAndEval(commandObj, 0); eval_exception = false; } catch (TclException e) { if (tcl.lang.ConsoleThread.debug) { WriteLine("eval returned exceptional condition"); } TCL.CompletionCode code = e.getCompletionCode(); switch (code) { case TCL.CompletionCode.ERROR: Enclosing_Instance.putLine(Enclosing_Instance.err, Enclosing_Instance.interp.getResult().ToString()); break; case TCL.CompletionCode.BREAK: Enclosing_Instance.putLine(Enclosing_Instance.err, "invoked \"break\" outside of a loop"); break; case TCL.CompletionCode.CONTINUE: Enclosing_Instance.putLine(Enclosing_Instance.err, "invoked \"continue\" outside of a loop"); break; default: Enclosing_Instance.putLine(Enclosing_Instance.err, "command returned bad code: " + code); break; } } finally { commandObj.release(); } if (!eval_exception) { if (tcl.lang.ConsoleThread.debug) { WriteLine("eval returned normally"); } string evalResult = Enclosing_Instance.interp.getResult().ToString(); if (tcl.lang.ConsoleThread.debug) { WriteLine("eval result was \"" + evalResult + "\""); } if (evalResult.Length > 0) { Enclosing_Instance.putLine(Enclosing_Instance.out_Renamed, evalResult); } } // Empty out the incoming command buffer Enclosing_Instance.sbuf.Length = 0; // See if the user set a custom shell prompt for the next command TclObject prompt; try { prompt = Enclosing_Instance.interp.getVar("tcl_prompt1", TCL.VarFlag.GLOBAL_ONLY); } catch (TclException e) { prompt = null; } if (prompt != null) { try { Enclosing_Instance.interp.eval(prompt.ToString(), TCL.EVAL_GLOBAL); } catch (TclException e) { Enclosing_Instance.put(Enclosing_Instance.out_Renamed, "% "); } } else { Enclosing_Instance.put(Enclosing_Instance.out_Renamed, "% "); } return(1); } else { // Interp.commandComplete() returned false if (tcl.lang.ConsoleThread.debug) { WriteLine("line was not a complete command"); } // We don't have a complete command yet. Print out a level 2 // prompt message and wait for further inputs. TclObject prompt; try { prompt = Enclosing_Instance.interp.getVar("tcl_prompt2", TCL.VarFlag.GLOBAL_ONLY); } catch (TclException) { prompt = null; } if (prompt != null) { try { Enclosing_Instance.interp.eval(prompt.ToString(), TCL.EVAL_GLOBAL); } catch (TclException e) { Enclosing_Instance.put(Enclosing_Instance.out_Renamed, ""); } } else { Enclosing_Instance.put(Enclosing_Instance.out_Renamed, ""); } return(1); } } // end processEvent method
public override void processIdleEvent() { // During the execution of this method, elements may be removed from // the errors list (because a TCL.CompletionCode.BREAK was returned by the bgerror // command, or because the interp was deleted). We remove this // BgError instance from the list first so that this instance won't // be deleted twice. SupportClass.VectorRemoveElement(Enclosing_Instance.errors, this); // Restore important state variables to what they were at // the time the error occurred. try { Enclosing_Instance.interp.setVar("errorInfo", null, errorInfo, TCL.VarFlag.GLOBAL_ONLY); } catch (TclException e) { // Ignore any TclException's, possibly caused by variable traces on // the errorInfo variable. This is compatible with the behavior of // the Tcl C API. } try { Enclosing_Instance.interp.setVar("errorCode", null, errorCode, TCL.VarFlag.GLOBAL_ONLY); } catch (TclException e) { // Ignore any TclException's, possibly caused by variable traces on // the errorCode variable. This is compatible with the behavior of // the Tcl C API. } // Make sure, that the interpreter will surive the invocation // of the bgerror command. Enclosing_Instance.interp.preserve(); try { // Invoke the bgerror command. TclObject[] argv = new TclObject[2]; argv[0] = Enclosing_Instance.bgerrorCmdObj; argv[1] = errorMsg; Parser.evalObjv(Enclosing_Instance.interp, argv, 0, TCL.EVAL_GLOBAL); } catch (TclException e) { switch (e.getCompletionCode()) { case TCL.CompletionCode.ERROR: try { Channel chan = TclIO.getStdChannel(StdChannel.STDERR); if (Enclosing_Instance.interp.getResult().ToString().Equals("\"bgerror\" is an invalid command name or ambiguous abbreviation")) { chan.write(Enclosing_Instance.interp, errorInfo); chan.write(Enclosing_Instance.interp, "\n"); } else { chan.write(Enclosing_Instance.interp, "bgerror failed to handle background error.\n"); chan.write(Enclosing_Instance.interp, " Original error: "); chan.write(Enclosing_Instance.interp, errorMsg); chan.write(Enclosing_Instance.interp, "\n"); chan.write(Enclosing_Instance.interp, " Error in bgerror: "); chan.write(Enclosing_Instance.interp, Enclosing_Instance.interp.getResult()); chan.write(Enclosing_Instance.interp, "\n"); } chan.flush(Enclosing_Instance.interp); } catch (TclException e1) { // Ignore. } catch (System.IO.IOException e2) { // Ignore, too. } break; case TCL.CompletionCode.BREAK: for (int i = Enclosing_Instance.errors.Count - 1; i >= 0; i--) { BgError bgErr = (BgError)Enclosing_Instance.errors[i]; Enclosing_Instance.errors.RemoveAt(i); bgErr.cancel(); bgErr.errorMsg.release(); bgErr.errorMsg = null; bgErr.errorInfo.release(); bgErr.errorInfo = null; bgErr.errorCode.release(); bgErr.errorCode = null; } break; } } Enclosing_Instance.interp.release(); errorMsg.release(); errorMsg = null; errorInfo.release(); errorInfo = null; errorCode.release(); errorCode = null; }