internal EvaluationState WithScriptState(ScriptState<object> state)
 {
     return new EvaluationState(
         state,
         ScriptOptions,
         SourceSearchPaths,
         ReferenceSearchPaths,
         WorkingDirectory);
 }

		public ScriptResult(
			ScriptState state,
			string output,
			TimeSpan elapsed = default(TimeSpan))
		{
			this.State = state;
			this.Output = output;
			this.Elapsed = elapsed;
		}

		public LogPack(
			ulong tweetId,
			DateTimeOffset tweetTime,
			string scriptContent,
			string resultContent,
			ScriptState state)
		{
			this.TweetId = tweetId;
			this.TweetTime = tweetTime;
			this.ScriptContent = scriptContent;
			this.ResultContent = resultContent;
			this.State = state;
		}

 internal EvaluationState(
     ScriptState<object> scriptState,
     ScriptOptions scriptOptions,
     ImmutableArray<string> sourceSearchPaths,
     ImmutableArray<string> referenceSearchPaths,
     string workingDirectory)
 {
     ScriptStateOpt = scriptState;
     ScriptOptions = scriptOptions;
     SourceSearchPaths = sourceSearchPaths;
     ReferenceSearchPaths = referenceSearchPaths;
     WorkingDirectory = workingDirectory;
 }

        public void ExecuteScript(Script script)
        {
            // wrap the script in our state
            ScriptState scriptState = new ScriptState(script);

            // the script may complete in one go
            scriptState.Execute(null);

            // if not, add it to our list
            if (!scriptState.IsComplete)
            {
                scripts.Add(scriptState);
            }
        }

                internal EvaluationState(
                    ScriptState<object> scriptStateOpt,
                    ScriptOptions scriptOptions,
                    ImmutableArray<string> sourceSearchPaths,
                    ImmutableArray<string> referenceSearchPaths,
                    string workingDirectory)
                {
                    Debug.Assert(scriptOptions != null);
                    Debug.Assert(!sourceSearchPaths.IsDefault);
                    Debug.Assert(!referenceSearchPaths.IsDefault);
                    Debug.Assert(workingDirectory != null);

                    ScriptStateOpt = scriptStateOpt;
                    ScriptOptions = scriptOptions;
                    SourceSearchPaths = sourceSearchPaths;
                    ReferenceSearchPaths = referenceSearchPaths;
                    WorkingDirectory = workingDirectory;
                }

 public override void SetScriptState(ScriptState state)
 {
     activeScript.SetScriptState(state);
 }

            private async Task<ScriptState<object>> ExecuteOnUIThread(Script<object> script, ScriptState<object> stateOpt)
            {
                return await Task.Factory.StartNew(async () =>
                {
                    try
                    {
                        var task = (stateOpt == null) ?
                            script.RunAsync(_hostObject, CancellationToken.None) :
                            script.ContinueAsync(stateOpt, CancellationToken.None);

                        return await task.ConfigureAwait(false);
                    }
                    catch (Exception e)
                    {
                        // TODO (tomat): format exception
                        Console.Error.WriteLine(e);
                        return null;
                    }
                },
                CancellationToken.None,
                TaskCreationOptions.None,
                s_UIThreadScheduler).Unwrap().ConfigureAwait(false);
            }

        private void BuildAndRun(Script<object> newScript, InteractiveScriptGlobals globals, ref ScriptState<object> state, ref ScriptOptions options, bool displayResult, CancellationToken cancellationToken)
        {
            var diagnostics = newScript.Compile(cancellationToken);
            DisplayDiagnostics(diagnostics);
            if (diagnostics.HasAnyErrors())
            {
                return;
            }

            var task = (state == null) ?
                newScript.RunAsync(globals, catchException: e => true, cancellationToken: cancellationToken) :
                newScript.RunFromAsync(state, catchException: e => true, cancellationToken: cancellationToken);

            state = task.GetAwaiter().GetResult();
            if (state.Exception != null)
            {
                DisplayException(state.Exception);
            }
            else if (displayResult && newScript.HasReturnValue())
            {
                globals.Print(state.ReturnValue);
            }

            options = UpdateOptions(options, globals);
        }

 void IActiveScriptSite.OnStateChange(ScriptState scriptState)
 {
     //Trace.WriteLine("OnStateChange scriptState=" + scriptState);
 }

        /// <summary>
        /// Executes the specified code.
        /// </summary>
        /// <param name="code">The code.</param>
        private void Execute(string code)
        {
            try
            {
                InteractiveScriptBase.Current = scriptBase;
                scriptBase._ScriptState_ = scriptState;
                scriptState = scriptState.ContinueWithAsync(code).Result;
                importedCode = ExtractImportedCode(scriptState.Script, importedCode);
                UpdateUsings(scriptState.Script, usings);
                UpdateReferences(scriptState.Script, references);
                scriptBase.Dump(scriptState.ReturnValue);

                if (scriptBase._InteractiveScriptBaseType_ != null && scriptBase._InteractiveScriptBaseType_ != scriptBase.GetType())
                {
                    var oldScriptBase = scriptBase;

                    scriptBase = (InteractiveScriptBase)Activator.CreateInstance(scriptBase._InteractiveScriptBaseType_);
                    scriptBase.ObjectWriter = oldScriptBase.ObjectWriter;
                    scriptBase._InternalObjectWriter_ = oldScriptBase._InternalObjectWriter_;

                    // TODO: Changing globals, but we need to store previous variables
                    scriptState = CSharpScript.RunAsync("", scriptState.Script.Options, scriptBase).Result;
                }
            }
            finally
            {
                InteractiveScriptBase.Current = null;
            }
        }

            private async Task<ScriptState<object>> ExecuteOnUIThread(Script<object> script, ScriptState<object> stateOpt, bool displayResult)
            {
                return await ((Task<ScriptState<object>>)s_control.Invoke(
                    (Func<Task<ScriptState<object>>>)(async () =>
                    {
                        var task = (stateOpt == null) ?
                            script.RunAsync(_globals, catchException: e => true, cancellationToken: CancellationToken.None) :
                            script.RunFromAsync(stateOpt, catchException: e => true, cancellationToken: CancellationToken.None);

                        var newState = await task.ConfigureAwait(false);

                        if (newState.Exception != null)
                        {
                            DisplayException(newState.Exception);
                        }
                        else if (displayResult && newState.Script.HasReturnValue())
                        {
                            _globals.Print(newState.ReturnValue);
                        }

                        return newState;

                    }))).ConfigureAwait(false);
            }

 public abstract void GetScriptState(out ScriptState state);

 private static void DisplaySubmissionResult(ScriptState<object> state)
 {
     // TODO
     //if (state.Script.GetCompilation().HasSubmissionResult())
     if (state.ReturnValue != null)
     {
         state.ReturnValue.Dump();
     }
 }

        private bool TryBuildAndRun(Script<object> newScript, object globals, ref ScriptState<object> state, CancellationToken cancellationToken)
        {
            var diagnostics = newScript.Build(cancellationToken);
            DisplayDiagnostics(diagnostics);
            if (diagnostics.HasAnyErrors())
            {
                return false;
            }

            try
            {
                var task = (state == null) ?
                    newScript.RunAsync(globals, cancellationToken) :
                    newScript.ContinueAsync(state, cancellationToken);

                state = task.GetAwaiter().GetResult();
            }
            catch (Exception e)
            {
                DisplayException(e);
                return false;
            }

            return true;
        }

 public void OnStateChange(ScriptState scriptState)
 {
     GlobalLog.Print("AutoWebProxyScriptWrapper.ScriptHost#" + ValidationHelper.HashString(this) + "::OnStateChange() state:" + ValidationHelper.ToString(scriptState));
     if (scriptState == ScriptState.Closed)
     {
         helper = null;
     }
 }

 public void InitNew()
 {
     Debug.WriteLine ("InitNew()");
     DotNet.Enable ();
     CLOS.Init ();
     this.currentScriptState = ScriptState.Disconnected;
     if (this.site != null)
         this.site.OnStateChange (this.currentScriptState);
     CL.Readtable.Case = ReadtableCase.Preserve;
 }

 public void GetScriptState(out ScriptState scriptState)
 {
     Debug.WriteLine ("GetScriptState()");
     scriptState = this.currentScriptState;
 }

 private async Task<ScriptState<object>> ExecuteOnUIThread(Script<object> script, ScriptState<object> stateOpt)
 {
     return await ((Task<ScriptState<object>>)s_control.Invoke(
         (Func<Task<ScriptState<object>>>)(async () =>
         {
             try
             {
                 var task = (stateOpt == null) ?
                     script.RunAsync(_globals, CancellationToken.None) :
                     script.ContinueAsync(stateOpt, CancellationToken.None);
                 return await task.ConfigureAwait(false);
             }
             catch (FileLoadException e) when (e.InnerException is InteractiveAssemblyLoaderException)
             {
                 Console.Error.WriteLine(e.InnerException.Message);
                 return null;
             }
             catch (Exception e)
             {
                 // TODO (tomat): format exception
                 Console.Error.WriteLine(e);
                 return null;
             }
         }))).ConfigureAwait(false);
 }

        private bool TryBuildAndRun(Script<object> newScript, InteractiveScriptGlobals globals, ref ScriptState<object> state, ref ScriptOptions options, CancellationToken cancellationToken)
        {
            var diagnostics = newScript.Compile(cancellationToken);
            DisplayDiagnostics(diagnostics);
            if (diagnostics.HasAnyErrors())
            {
                return false;
            }

            try
            {
                var task = (state == null) ?
                    newScript.RunAsync(globals, cancellationToken) :
                    newScript.ContinueAsync(state, cancellationToken);

                state = task.GetAwaiter().GetResult();
            }
            catch (FileLoadException e) when (e.InnerException is InteractiveAssemblyLoaderException)
            {
                var oldColor = _console.ForegroundColor;
                try
                {
                    _console.ForegroundColor = ConsoleColor.Red;
                    _console.Out.WriteLine(e.InnerException.Message);
                }
                finally
                {
                    _console.ForegroundColor = oldColor;
                }

                return false;
            }
            catch (Exception e)
            {
                DisplayException(e);
                return false;
            }

            options = UpdateOptions(options, globals);

            return true;
        }