internal Task ExecuteAsync(IInteractiveWindow interactiveWindow, string title) { if (GetProjectProperties(out var references, out var referenceSearchPaths, out var sourceSearchPaths, out var projectNamespaces, out var projectDirectory, out var platform)) { // Now, we're going to do a bunch of async operations. So create a wait // indicator so the user knows something is happening, and also so they cancel. var waitIndicator = GetWaitIndicator(); var waitContext = waitIndicator.StartWait(title, InteractiveEditorFeaturesResources.Building_Project, allowCancel: true, showProgress: false); var resetInteractiveTask = ResetInteractiveAsync( interactiveWindow, references, referenceSearchPaths, sourceSearchPaths, projectNamespaces, projectDirectory, platform, waitContext); // Once we're done resetting, dismiss the wait indicator and focus the REPL window. return(resetInteractiveTask.SafeContinueWith( _ => { waitContext.Dispose(); ExecutionCompleted?.Invoke(this, new EventArgs()); }, TaskScheduler.FromCurrentSynchronizationContext())); } return(Task.CompletedTask); }
private void RaiseExecutionCompleted(string file, uint[] lines, bool isStepping, BreakState breakState) { var args = new ExecutionCompletedEventArgs(file, lines, isStepping); ExecutionCompleted?.Invoke(this, args); _breakLineTagger.OnExecutionCompleted(args); BreakEntered(this, breakState); }
public Completion Execute(Class m) { _current = m; if (_current == null) { return(null); } Completion c = Completion.Void; foreach (var func in _current.Functions) { if ("main".Equals(func.Format, StringComparison.OrdinalIgnoreCase)) { foreach (var v in _current.Variables) { RegisterValue(v.Name, v.Value); } var parameter = func.Params; ExecutionEnvironment current = new ExecutionEnvironment(this); ExecutionStarted?.Invoke(this, null); foreach (var p in parameter) { current.RegisterValue(p.Name, null); } try { IsCompleted = false; c = func.Execute(current); break; }catch (Exception e) { IsCompleted = true; Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); ExecutionAborted?.Invoke(this, new Completion(e.Message, CompletionType.Exception)); return(Completion.Void); } } } IsCompleted = true; if (c.Type == CompletionType.Value) { ExecutionCompleted?.Invoke(this, c); } else if (c.Type == CompletionType.Exception) { ExecutionAborted?.Invoke(this, c); } else { ExecutionAborted?.Invoke(this, Completion.Exception("Unknown exception", null)); } return(c); }
public void ExecuteScript(Node behaviorTree, Entity entity) { _currentTree = behaviorTree; _currentTree.Owner = entity; _executionToken = new CancellationTokenSource(); Task.Run(() => { while (!_executionToken.IsCancellationRequested && _currentTree.Execute() == ExecutingStatus.Running) { } }, _executionToken.Token).ContinueWith((t) => { if (t.IsFaulted) { Exception ex = t.Exception; while (ex is AggregateException && ex.InnerException != null) { ex = ex.InnerException; } Log.Write("The script execution failed: " + ex.Message); } else if (t.IsCanceled) { Log.Write("The script execution cancelled !"); } else { Log.Write("The script is executed successfully !"); } if (!t.IsFaulted) { _currentTree.Deactivate(); } ExecutionCompleted?.Invoke(_currentTree, EventArgs.Empty); _currentTree = null; }, TaskScheduler.FromCurrentSynchronizationContext()); }
private TaskResult RunTask() { try { BeforeExecution?.Invoke(this, new JobEventArgs { Context = Context }); Context.ExecutionStartedOn = DateTime.UtcNow; var result = Context.Task.Run(Context.JobName, Context.ScheduleName, Context.Parameters); Context.ExecutionFinishedOn = DateTime.UtcNow; ExecutionCompleted?.Invoke(this, new JobEventArgs { Context = Context }); return(result); } catch (Exception e) { ErrorHandler.HandleException(e); return(TaskResult.Aborted); } }
protected virtual void OnCompleted() { ExecutionCompleted?.Invoke(this, EventArgs.Empty); }
/// <summary> /// Fires the execution completed event. /// </summary> private void FireExecutionCompletedEvent() { Status = EngineStatus.Completed; ExecutionCompleted?.Invoke(this, new ExecutionCompletedEventArgs()); }
public Completion Execute(Class m) { IsAborting = false; IsCompleted = false; _current = m; if (_current == null) { return(null); } Completion c = Completion.Void; ExecutionEnvironment baseEnv = this.GetBaseEnvironment(); ExecutionEnvironment classEnv = new ExecutionEnvironment(baseEnv); ExecutionEnvironment instanceEnv = new ExecutionEnvironment(classEnv); foreach (var v in m.Variables) { instanceEnv.RegisterValue(v.Name, v.Value); } foreach (var func in _current.Functions) { if ("main".Equals(func.Name, StringComparison.OrdinalIgnoreCase)) { var parameter = func.Params; ExecutionEnvironment functionEnv = new ExecutionEnvironment(instanceEnv); ExecutionStarted?.Invoke(this, null); foreach (var p in parameter) { functionEnv.RegisterValue(p.Name, null); } foreach (var block in m.BlockStatements) { foreach (var s in block.Body) { if (s is ExpressionStatement) { Expression exp = (s as ExpressionStatement).Expression; if (exp is VariableDeclarationExpression) { exp.Execute(instanceEnv); } } } } try { IsCompleted = false; c = func.Execute(functionEnv); break; }catch (Exception e) { IsCompleted = true; Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); ExecutionAborted?.Invoke(this, new Completion(e.Message, CompletionType.Exception)); return(Completion.Void); } } } IsCompleted = true; if (c.Type == CompletionType.Value) { ExecutionCompleted?.Invoke(this, c); } else if (c.Type == CompletionType.Exception) { ExecutionAborted?.Invoke(this, c); } else { ExecutionAborted?.Invoke(this, Completion.Exception(Properties.Language.UnknowException, null)); } return(c); }