/// <summary>Registers a script block on a page.</summary>
/// <param name="page">The page onto which to added the script.</param>
/// <param name="script">The script to add.</param>
/// <param name="position">Where to add the script.</param>
/// <param name="options">Script registration options.</param>
public static void JavaScript(this Page page, string script, ScriptPosition position, ScriptOptions options)
{
if (page == null) throw new ArgumentNullException("page");
if (position == ScriptPosition.Header)
{
JavaScript(page, script, options);
}
else if (position == ScriptPosition.Bottom)
{
string key = script.GetHashCode().ToString();
if (options.Is(ScriptOptions.None))
page.ClientScript.RegisterStartupScript(typeof(Register), key, script);
else if (options.Is(ScriptOptions.ScriptTags))
page.ClientScript.RegisterStartupScript(typeof(Register), key, script, true);
else if (options.Is(ScriptOptions.DocumentReady))
{
page.JQuery();
page.ClientScript.RegisterStartupScript(typeof(Register), key, EmbedDocumentReady(script), true);
}
else if (options.Is(ScriptOptions.Include))
page.ClientScript.RegisterClientScriptInclude(key, Url.ResolveTokens(script));
else
throw new ArgumentException("options");
}
else
throw new ArgumentException("position");
}
/// <summary>Registers a script block on a page.</summary>
/// <param name="page">The page onto which to added the script.</param>
/// <param name="script">The script to add.</param>
/// <param name="position">Where to add the script.</param>
/// <param name="options">Script registration options.</param>
public static void JavaScript(Page page, string script, ScriptPosition position, ScriptOptions options)
{
if (page == null) throw new ArgumentNullException("page");
if (position == ScriptPosition.Header)
{
JavaScript(page, script, options);
}
else if (position == ScriptPosition.Bottom)
{
string key = script.GetHashCode().ToString();
if (Is(options, ScriptOptions.None))
page.ClientScript.RegisterClientScriptBlock(typeof (Register), key, script);
else if (Is(options, ScriptOptions.ScriptTags))
page.ClientScript.RegisterClientScriptBlock(typeof (Register), key, script, true);
else if (Is(options, ScriptOptions.DocumentReady))
{
JQuery(page);
page.ClientScript.RegisterClientScriptBlock(typeof (Register), key, EmbedDocumentReady(script), true);
}
else if (Is(options, ScriptOptions.Include))
page.ClientScript.RegisterClientScriptInclude(key, page.Engine().ManagementPaths.ResolveResourceUrl(script));
else
throw new ArgumentException("options");
}
else
throw new ArgumentException("position");
}
public static void JavaScript(Page page, string script, ScriptOptions options)
{
if (page == null) throw new ArgumentNullException("page");
if (page.Items[script] == null)
{
PlaceHolder holder = GetPlaceHolder(page);
if (Is(options, ScriptOptions.Include))
{
AddScriptInclude(page, script, holder, Is(options, ScriptOptions.Prioritize));
}
else if (Is(options, ScriptOptions.None))
{
holder.Page.Items[script] = AddString(script, holder, Is(options, ScriptOptions.Prioritize));
}
else
{
Script scriptHolder = GetScriptHolder(page);
if (Is(options, ScriptOptions.ScriptTags))
{
holder.Page.Items[script] = AddString(script + Environment.NewLine, scriptHolder, Is(options, ScriptOptions.Prioritize));
}
else if (Is(options, ScriptOptions.DocumentReady))
{
JQuery(page);
holder.Page.Items[script] = AddString(EmbedDocumentReady(script) + Environment.NewLine, scriptHolder, Is(options, ScriptOptions.Prioritize));
}
}
}
}
public void GenerateJavaScriptOptionsDoesAlwaysQuotingObjecLiteralKeys()
{
var literal = JS.Object(new {name = "Dave", function = "Developer"});
var without = new ScriptOptions {AlwaysQuoteObjectLiteralKeys = false, PreferredQuoteChar = '"'};
var with = new ScriptOptions {AlwaysQuoteObjectLiteralKeys = true, PreferredQuoteChar = '"'};
Assert.AreEqual("{name:\"Dave\",function:\"Developer\"};", literal.ToString(true, without, false));
Assert.AreEqual("{\"name\":\"Dave\",\"function\":\"Developer\"};", literal.ToString(true, with, false));
}
public void GenerateJavaScriptOptionsCanBeSet()
{
ScriptOptions options = new ScriptOptions();
options.PreferredQuoteChar = '\'';
Assert.AreEqual('\'', options.PreferredQuoteChar);
Expect.Throw<ArgumentException>(
"The preferred quote char can only be one of the allowed quote chars.\r\nParameter name: value",
() => options.PreferredQuoteChar = '@');
}
internal override Script Make(string code, string path, ScriptOptions options, Type globalsType, Type returnType, ScriptBuilder builder, Script previous)
{
return(new CSharpScript(code, path, options, globalsType, returnType, builder, previous));
}
public override Script <T> CreateScript <T>(string code, ScriptOptions options, Type globalsTypeOpt, InteractiveAssemblyLoader assemblyLoader)
{
return(CSharpScript.Create <T>(code, options, globalsTypeOpt, assemblyLoader));
}
private static bool Is(this ScriptOptions options, ScriptOptions expectedOption)
{
return (options & expectedOption) == expectedOption;
}
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;
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable <string> namespaces, ScriptPackSession scriptPackSession)
{
if (scriptPackSession == null)
{
throw new ArgumentNullException("scriptPackSession");
}
if (references == null)
{
throw new ArgumentNullException("references");
}
_log.Debug("Starting to create execution components");
_log.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.Assemblies, references.Paths);
executionReferences.Union(scriptPackSession.References);
ScriptResult scriptResult;
SessionState <ScriptState> sessionState;
var isFirstExecution = !scriptPackSession.State.ContainsKey(SessionKey);
if (isFirstExecution)
{
var host = _scriptHostFactory.CreateScriptHost(
new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
ScriptLibraryWrapper.SetHost(host);
_log.Debug("Creating session");
var hostType = host.GetType();
ScriptOptions = ScriptOptions.AddReferences(hostType.Assembly);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
}
foreach (var @namespace in allNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddNamespaces(@namespace);
}
sessionState = new SessionState <ScriptState> {
References = executionReferences, Namespaces = new HashSet <string>(allNamespaces)
};
scriptPackSession.State[SessionKey] = sessionState;
scriptResult = Execute(code, host, sessionState);
}
else
{
_log.Debug("Reusing existing session");
sessionState = (SessionState <ScriptState>)scriptPackSession.State[SessionKey];
if (sessionState.References == null)
{
sessionState.References = new AssemblyReferences();
}
if (sessionState.Namespaces == null)
{
sessionState.Namespaces = new HashSet <string>();
}
var newReferences = executionReferences.Except(sessionState.References);
foreach (var reference in newReferences.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
sessionState.References = sessionState.References.Union(new[] { reference });
}
foreach (var assembly in newReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
sessionState.References = sessionState.References.Union(new[] { assembly });
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddNamespaces(@namespace);
sessionState.Namespaces.Add(@namespace);
}
if (string.IsNullOrWhiteSpace(code))
{
return(ScriptResult.Empty);
}
scriptResult = Execute(code, sessionState.Session, sessionState);
}
return(scriptResult);
//todo handle namespace failures
//https://github.com/dotnet/roslyn/issues/1012
}
private Func <IQueuedTaskToken, long> CompileCalculateDelayTicksTaskAfterFailureFnFromConfig(StakhanoviseSetupDefaultsConfig defaultsConfig,
ScriptOptions parseOptions)
{
if (!string.IsNullOrEmpty(defaultsConfig.CalculateDelayTicksTaskAfterFailure))
{
return(CSharpScript.EvaluateAsync <Func <IQueuedTaskToken, long> >(defaultsConfig.CalculateDelayTicksTaskAfterFailure,
options: parseOptions)
.Result);
}
else
{
return(null);
}
}
/// <summary>
/// Parses the given source code by using the supplied type name
/// (otherwise it is text/css) and returns the created stylesheet.
/// </summary>
/// <param name="configuration">The configuration to use.</param>
/// <param name="response">
/// The response with the stream representing the source of the script.
/// </param>
/// <param name="options">
/// The options for running the script.
/// </param>
/// <param name="type">
/// The optional mime-type of the source code.
/// </param>
public static void RunScript(this IConfiguration configuration, IResponse response, ScriptOptions options, String type = null)
{
if (configuration.IsScripting)
{
var engine = configuration.GetScriptEngine(type ?? MimeTypes.DefaultJavaScript);
if (engine != null)
{
engine.Evaluate(response, options);
}
}
}
/// <summary>
/// Run a C# script.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// <param name="globals">An object instance whose members can be accessed by the script as global variables,
/// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
public static ScriptState Run(string code, ScriptOptions options, object globals)
{
return(Create(code, options).Run(globals));
}
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);
}
private void AddScripts(IEnumerable<string> names, ScriptOptions options)
{
if (null != names)
{
foreach (var script in names)
{
Converter.AddScript(script, options);
}
}
}
private void RunInteractiveLoop(ScriptOptions options, CancellationToken cancellationToken)
{
var globals = new InteractiveScriptGlobals(_console.Out, _objectFormatter);
globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
ScriptState <object> state = null;
while (true)
{
_console.Out.Write("> ");
var input = new StringBuilder();
string line;
bool cancelSubmission = false;
while (true)
{
line = _console.In.ReadLine();
if (line == null)
{
if (input.Length == 0)
{
return;
}
cancelSubmission = true;
break;
}
input.AppendLine(line);
var tree = _scriptCompiler.ParseSubmission(SourceText.From(input.ToString()), cancellationToken);
if (_scriptCompiler.IsCompleteSubmission(tree))
{
break;
}
_console.Out.Write(". ");
}
if (cancelSubmission)
{
continue;
}
string code = input.ToString();
Script<object> newScript;
if (state == null)
{
newScript = Script.CreateInitialScript<object>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
}
else
{
newScript = state.Script.ContinueWith(code, options);
}
var newCompilation = newScript.GetCompilation();
try
{
newScript.Build(cancellationToken);
// display warnings:
DisplayDiagnostics(newCompilation.GetDiagnostics(cancellationToken).Where(d => d.Severity == DiagnosticSeverity.Warning));
}
catch (CompilationErrorException e)
{
DisplayDiagnostics(e.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error || d.Severity == DiagnosticSeverity.Warning));
continue;
}
try
{
var task = (state == null) ?
newScript.RunAsync(globals, cancellationToken) :
newScript.ContinueAsync(state, cancellationToken);
state = task.GetAwaiter().GetResult();
}
catch (Exception e)
{
DisplayException(e);
continue;
}
bool hasValue;
ITypeSymbol resultType = newCompilation.GetSubmissionResultType(out hasValue);
if (hasValue)
{
if (resultType != null && resultType.SpecialType == SpecialType.System_Void)
{
_console.Out.WriteLine(_objectFormatter.VoidDisplayString);
}
else
{
globals.Print(state.ReturnValue);
}
}
}
}
public void AddScript(string filename, ScriptOptions options)
{
switch(options)
{
case ScriptOptions.Framework:
_frameworkscripts.Add(filename);
break;
case ScriptOptions.Before:
_scriptsbefore.Add(filename);
break;
case ScriptOptions.After:
_scriptsafter.Add(filename);
break;
default:
throw new ArgumentException("invalid script option specified.");
}
}
/// <summary>
/// Run a C# script and return its resulting value.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// <param name="globals">An object instance whose members can be accessed by the script as global variables,
/// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
/// <return>Returns the value returned by running the script.</return>
public static object Eval(string code, ScriptOptions options, object globals)
{
return(Run(code, options, globals).ReturnValue);
}
private CSharpScript(string code, string path, ScriptOptions options, Type globalsType, Type returnType, ScriptBuilder builder, Script previous)
: base(code, path, options, globalsType, returnType, builder, previous)
{
}
public static void JavaScript(this Page page, string script, ScriptOptions options)
{
if (page == null) return;
if (page.Items[script] == null)
{
PlaceHolder holder = GetPlaceHolder(page);
if (options.Is(ScriptOptions.Include))
{
AddScriptInclude(page, script, holder, options.Is(ScriptOptions.Prioritize));
}
else if (options.Is(ScriptOptions.None))
{
holder.Page.Items[script] = AddString(holder, script, options.Is(ScriptOptions.Prioritize));
}
else
{
Script scriptHolder = GetScriptHolder(page);
if (options.Is(ScriptOptions.ScriptTags))
{
holder.Page.Items[script] = AddString(scriptHolder, script + Environment.NewLine, Is(options, ScriptOptions.Prioritize));
}
else if (options.Is(ScriptOptions.DocumentReady))
{
JQuery(page);
holder.Page.Items[script] = AddString(scriptHolder, EmbedDocumentReady(script) + Environment.NewLine, options.Is(ScriptOptions.Prioritize));
}
}
}
}
internal override Script Make(string code, string path, ScriptOptions options, Type globalsType, Type returnType, ScriptBuilder builder, Script previous)
{
return new CSharpScript(code, path, options, globalsType, returnType, builder, previous);
}
private void RunInteractiveLoop(
ScriptOptions options,
string initialScriptCodeOpt,
CancellationToken cancellationToken
)
{
var globals = new InteractiveScriptGlobals(_console.Out, _objectFormatter);
globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
ScriptState <object> state = null;
if (initialScriptCodeOpt != null)
{
var script = Script.CreateInitialScript <object>(
_scriptCompiler,
SourceText.From(initialScriptCodeOpt),
options,
globals.GetType(),
assemblyLoaderOpt: null
);
BuildAndRun(
script,
globals,
ref state,
ref options,
displayResult: false,
cancellationToken: cancellationToken
);
}
while (true)
{
_console.Out.Write("> ");
var input = new StringBuilder();
string line;
bool cancelSubmission = false;
while (true)
{
line = _console.In.ReadLine();
if (line == null)
{
if (input.Length == 0)
{
return;
}
cancelSubmission = true;
break;
}
input.AppendLine(line);
var tree = _scriptCompiler.ParseSubmission(
SourceText.From(input.ToString()),
options.ParseOptions,
cancellationToken
);
if (_scriptCompiler.IsCompleteSubmission(tree))
{
break;
}
_console.Out.Write(". ");
}
if (cancelSubmission)
{
continue;
}
string code = input.ToString();
if (IsHelpCommand(code))
{
DisplayHelpText();
continue;
}
Script <object> newScript;
if (state == null)
{
newScript = Script.CreateInitialScript <object>(
_scriptCompiler,
SourceText.From(code ?? string.Empty),
options,
globals.GetType(),
assemblyLoaderOpt: null
);
}
else
{
newScript = state.Script.ContinueWith(code, options);
}
BuildAndRun(
newScript,
globals,
ref state,
ref options,
displayResult: true,
cancellationToken: cancellationToken
);
}
}
/// <summary>
/// Create a new C# script.
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// </summary>
public static Script Create(string code, ScriptOptions options)
{
return new CSharpScript(code, null, options, null, typeof(object), null, null);
}
public static string JavaScript(ICollection<string> stateCollection, string script, ScriptOptions options)
{
const string scriptFormat = "<script type=\"text/javascript\">//<![CDATA[\n{0}//]]></script>";
if (IsRegistered(stateCollection, script))
return null;
RegisterResource(stateCollection, script);
if (options == ScriptOptions.Include)
return JavaScript(stateCollection, script);
if (options == ScriptOptions.None)
return script;
if (options == ScriptOptions.ScriptTags)
return String.Format(scriptFormat, script);
if (options == ScriptOptions.DocumentReady)
return String.Format(scriptFormat, EmbedDocumentReady(script));
throw new NotSupportedException(options + " not supported");
}
/// <summary>
/// Run a C# script.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// <param name="globals">An object instance whose members can be accessed by the script as global variables,
/// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
public static ScriptState Run(string code, ScriptOptions options, object globals)
{
return Create(code, options).Run(globals);
}
public ResourcesHelper JavaScript(string script, ScriptOptions options)
{
Writer.Write(N2.Resources.Register.JavaScript(ViewData, script, options));
return this;
}
/// <summary>
/// Run a C# script.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
public static ScriptState Run(string code, ScriptOptions options)
{
return Run(code, options, globals: null);
}
private int RunScript(ScriptOptions options, string code, ErrorLogger errorLogger, CancellationToken cancellationToken)
{
var globals = new CommandLineScriptGlobals(_console.Out, _objectFormatter);
globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
var script = Script.CreateInitialScript<object>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
try
{
script.RunAsync(globals, cancellationToken).Wait();
// TODO: use the return value of the script https://github.com/dotnet/roslyn/issues/5773
return CommonCompiler.Succeeded;
}
catch (CompilationErrorException e)
{
_compiler.ReportErrors(e.Diagnostics, _console.Out, errorLogger);
return CommonCompiler.Failed;
}
}
/// <summary>
/// Run a C# script and return its resulting value.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// <param name="globals">An object instance whose members can be accessed by the script as global variables,
/// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
/// <return>Returns the value returned by running the script.</return>
public static object Eval(string code, ScriptOptions options, object globals)
{
return Run(code, options, globals).ReturnValue;
}
static ComputedString()
{
Options = ScriptOptions.Default
.WithReferences(typeof(Console).Assembly, typeof(MemberExpression).Assembly)
.WithImports("System", "System.Text", "System.Linq", "System.Collections.Generic");
}
private Script <object> TryCompile(Script previousScript, string code, string path, ScriptOptions options)
{
Script script;
var scriptOptions = options.WithFilePath(path);
if (previousScript != null)
{
script = previousScript.ContinueWith(code, scriptOptions);
}
else
{
script = _replServiceProvider.CreateScript <object>(code, scriptOptions, _globals.GetType(), _assemblyLoader);
}
var diagnostics = script.Compile();
if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
DisplayInteractiveErrors(diagnostics, Console.Error);
return(null);
}
return((Script <object>)script);
}
private CSharpScript(string code, string path, ScriptOptions options, Type globalsType, Type returnType, ScriptBuilder builder, Script previous)
: base(code, path, options, globalsType, returnType, builder, previous)
{
}
public ScriptCompilationContext(Script <TReturn> script, SourceText sourceText, InteractiveAssemblyLoader loader, ScriptOptions scriptOptions, RuntimeDependency[] runtimeDependencies)
{
Script = script;
SourceText = sourceText;
ScriptOptions = scriptOptions;
Loader = loader;
RuntimeDependencies = runtimeDependencies;
}
/// <summary>
/// Create a new C# script.
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
/// </summary>
public static Script Create(string code, ScriptOptions options)
{
return(new CSharpScript(code, null, options, null, typeof(object), null, null));
}
public void RunScript(string comPort, string host, string path)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
string[] template = File.ReadAllLines(TemplateFile);
string[] script = File.ReadAllLines(path);
List <string> builder = new List <string>();
bool skip = false;
int offset = 0;
int count = 0;
foreach (var line in template)
{
string trimed = line.Trim().ToUpper();
if (trimed.StartsWith("//[*"))
{
skip = true;
}
else if (trimed.StartsWith("//*]"))
{
skip = false;
}
else if (trimed.StartsWith("//[SCRIPT]"))
{
offset = count;
builder.AddRange(script);
}
else
{
if (!skip)
{
count++;
builder.Add(line);
}
}
}
string text = string.Join("\r\n", builder) + $"\r\nnew {Template}(\"{comPort}\",\"{host}\")";
try
{
ScriptOptions options = ScriptOptions.Default
.WithImports("System", "System.Text", "System.Math", "System.Collections.Generic",
"System.Net", "Codeplex.Data", "System.IO.Ports", "System.Timers", "System.Threading", "System.Threading.Tasks",
"MQTTnet", "MQTTnet.Client", "MQTTnet.Client.Options"
)
.WithReferences(
"System.IO.Ports.dll",
Path.GetFullPath(@"MQTTnet.dll"),
Path.GetFullPath(@"Serial2MQTT.dll")
);
var task = CSharpScript.RunAsync(text, options);
task.Wait();
}catch (Exception ex)
{
string message = ex.Message;
var regex = new Regex(@"\((\d+),(\d+)\)(.*)");
var match = regex.Match(message);
if (match.Success)
{
int line = Convert.ToInt32(match.Groups[1].Value);
int col = Convert.ToInt32(match.Groups[2].Value);
string body = match.Groups[3].Value;
string cursor = (new string(' ', col - 1)) + "^";
int scriptLine = line - offset;
message = $"{path} ({line-offset},{col}){body}\r\n{builder[line-1]}\r\n{cursor}";
}
Console.WriteLine(message);
Environment.Exit(-1);
}
}
/// <summary>
/// Run a C# script.
/// </summary>
/// <param name="code">The source code of the script.</param>
/// <param name="options">The script options.</param>
public static ScriptState Run(string code, ScriptOptions options)
{
return(Run(code, options, globals: null));
}
public ResourcesHelper JavaScript(string script, ScriptOptions options)
{
Writer.Write(N2.Resources.Register.JavaScript(StateCollection, script, options));
return this;
}
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);
}
public SnippetRewriter(Project project)
{
options = ScriptOptions.Default
.AddReferences(project.MetadataReferences)
.AddReferences(new[] { MetadataReference.CreateFromFile(project.OutputFilePath) });
}
static void Main(string[] args)
{
string[] wait = new[] { "o....", ".o...", "..o..", "...o.", "....o" };
Func <Task <ScriptState <object> >, ScriptState> Execute = t =>
{
CancellationTokenSource cts = new CancellationTokenSource();
t.ContinueWith(_ => { cts.Cancel(); });
CancellationToken cancellationToken = cts.Token;
int index = 0;
while (!cancellationToken.IsCancellationRequested)
{
Console.Write("\r{0}", wait[index]);
index = (index + 1) % wait.Length;
try
{
Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).GetAwaiter().GetResult();
}
catch (TaskCanceledException)
{
}
}
Console.Write("\r{0}\r", new string(' ', 20));
return(t.Result);
};
ScriptOptions scriptOptions = ScriptOptions.Default;
scriptOptions = scriptOptions.WithReferences("System");
ScriptState scriptState = Execute(CSharpScript.RunAsync("using System;", scriptOptions));
while (true)
{
Console.Write("? ");
string line = Console.ReadLine();
try
{
if (line.StartsWith("#"))
{
if (line.StartsWith("#reference"))
{
scriptOptions = scriptOptions.WithReferences(line.Substring("#reference".Length).Trim());
}
if (line == "#quit")
{
break;
}
continue;
}
scriptState = Execute(scriptState.ContinueWithAsync(line, scriptOptions));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
continue;
}
if (scriptState.ReturnValue != null)
{
Console.WriteLine(scriptState.ReturnValue);
}
}
}
public ScriptCompilationContext(Script <TReturn> script, SourceText sourceText, InteractiveAssemblyLoader loader, ScriptOptions scriptOptions, RuntimeDependency[] runtimeDependencies, Diagnostic[] diagnostics)
{
Script = script;
SourceText = sourceText;
ScriptOptions = scriptOptions;
Loader = loader;
RuntimeDependencies = runtimeDependencies;
Warnings = diagnostics.Where(x => x.Severity == DiagnosticSeverity.Warning).ToArray();
Errors = diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).ToArray();
}
private StakhanoviseSetupDefaults MergeDefaultsFromConfig(StakhanoviseSetupDefaults targetDefaults,
StakhanoviseSetupDefaultsConfig defaultsConfig,
IConfiguration config)
{
ScriptOptions parseOptions = ConstructParseOptions();
Assembly[] executorAssemblies = ParseExecutorAssembliesFromConfig(defaultsConfig);
if (executorAssemblies != null)
{
targetDefaults.ExecutorAssemblies = executorAssemblies;
}
Func <IQueuedTaskToken, long> calculateDelayTicksTaskAfterFailureFn =
CompileCalculateDelayTicksTaskAfterFailureFnFromConfig(defaultsConfig, parseOptions);
if (calculateDelayTicksTaskAfterFailureFn != null)
{
targetDefaults.CalculateDelayMillisecondsTaskAfterFailure = calculateDelayTicksTaskAfterFailureFn;
}
Func <IQueuedTask, Exception, bool> isTaskErrorRecoverableFn =
CompileIsTaskErrorRecoverableFnFromConfig(defaultsConfig, parseOptions);
if (isTaskErrorRecoverableFn != null)
{
targetDefaults.IsTaskErrorRecoverable = isTaskErrorRecoverableFn;
}
if (!string.IsNullOrWhiteSpace(defaultsConfig.ConnectionStringName))
{
targetDefaults.ConnectionString = config.GetConnectionString(defaultsConfig.ConnectionStringName);
}
QueuedTaskMapping mappingFromConfig =
GetQueudTaskMappingFromDefaultsConfig(defaultsConfig);
targetDefaults.Mapping = MergeMappingFromConfig(targetDefaults.Mapping,
mappingFromConfig);
if (defaultsConfig.WorkerCount > 0)
{
targetDefaults.WorkerCount = defaultsConfig.WorkerCount;
}
if (defaultsConfig.FaultErrorThresholdCount > 0)
{
targetDefaults.FaultErrorThresholdCount = defaultsConfig.FaultErrorThresholdCount;
}
if (defaultsConfig.AppMetricsCollectionIntervalMilliseconds > 0)
{
targetDefaults.AppMetricsCollectionIntervalMilliseconds = defaultsConfig.AppMetricsCollectionIntervalMilliseconds;
}
if (defaultsConfig.AppMetricsMonitoringEnabled.HasValue)
{
targetDefaults.AppMetricsMonitoringEnabled = defaultsConfig.AppMetricsMonitoringEnabled.Value;
}
if (defaultsConfig.SetupBuiltInDbAsssets.HasValue)
{
targetDefaults.SetupBuiltInDbAsssets = defaultsConfig.SetupBuiltInDbAsssets.Value;
}
return(targetDefaults);
}
public ScanScript(ScriptOptions scriptOptions, string sampleName, string ipAddress, string scannerName)
: base(scriptOptions, sampleName)
{
Arguments.Add("IpAddress", ipAddress);
Arguments.Add("ScannerName", scannerName);
}
private Func <IQueuedTask, Exception, bool> CompileIsTaskErrorRecoverableFnFromConfig(StakhanoviseSetupDefaultsConfig defaultsConfig,
ScriptOptions parseOptions)
{
if (!string.IsNullOrEmpty(defaultsConfig.IsTaskErrorRecoverable))
{
return(CSharpScript.EvaluateAsync <Func <IQueuedTask, Exception, bool> >(defaultsConfig.IsTaskErrorRecoverable,
options: parseOptions)
.Result);
}
else
{
return(null);
}
}
internal override Script Create(string code, ScriptOptions options, Type globalsType, Type returnType)
{
return(CSharpScript.Create(code, options).WithGlobalsType(globalsType).WithReturnType(returnType).WithBuilder(this.Builder));
}
protected override Script <T> Create <T>(string code, ScriptOptions options, Type globalsType, InteractiveAssemblyLoader?assemblyLoader) => VisualBasicScript.Create <T>(code, options, globalsType, assemblyLoader);
/// <summary>Register an embedded javascript resource reference in the page header with options.</summary>
/// <param name="page">The page in whose header to register the javascript.</param>
/// <param name="type">The type in whose assembly the javascript is embedded.</param>
/// <param name="resourceName">The name of the embedded resource.</param>
/// <param name="options">Options flag.</param>
public static void JavaScript(this Page page, Type type, string resourceName, ScriptOptions options)
{
JavaScript(page, page.ClientScript.GetWebResourceUrl(type, resourceName), options);
}
internal override Script Create(string code, ScriptOptions options, Type globalsType, Type returnType)
{
return CSharpScript.Create(code, options).WithGlobalsType(globalsType).WithReturnType(returnType).WithBuilder(this.Builder);
}
/// <summary>Registers a script block on a page.</summary>
/// <param name="page">The page onto which to added the script.</param>
/// <param name="script">The script to add.</param>
/// <param name="position">Where to add the script.</param>
/// <param name="options">Script registration options.</param>
public static void JavaScript(this Page page, string script, ScriptPosition position, ScriptOptions options)
{
if (page == null)
{
throw new ArgumentNullException("page");
}
if (position == ScriptPosition.Header)
{
JavaScript(page, script, options);
}
else if (position == ScriptPosition.Bottom)
{
string key = script.GetHashCode().ToString();
if (options.Is(ScriptOptions.None))
{
page.ClientScript.RegisterStartupScript(typeof(Register), key, script);
}
else if (options.Is(ScriptOptions.ScriptTags))
{
page.ClientScript.RegisterStartupScript(typeof(Register), key, script, true);
}
else if (options.Is(ScriptOptions.DocumentReady))
{
page.JQuery();
page.ClientScript.RegisterStartupScript(typeof(Register), key, EmbedDocumentReady(script), true);
}
else if (options.Is(ScriptOptions.Include))
{
page.ClientScript.RegisterClientScriptInclude(key, Url.ResolveTokens(script));
}
else
{
throw new ArgumentException("options");
}
}
else
{
throw new ArgumentException("position");
}
}
private int RunScript(ScriptOptions options, string code, ErrorLogger errorLogger, CancellationToken cancellationToken)
{
var globals = new CommandLineScriptGlobals(_console.Out, _objectFormatter);
globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
var script = Script.CreateInitialScript<int>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
try
{
return script.RunAsync(globals, cancellationToken).Result.ReturnValue;
}
catch (CompilationErrorException e)
{
_compiler.ReportErrors(e.Diagnostics, _console.Out, errorLogger);
return CommonCompiler.Failed;
}
}
private static bool Is(this ScriptOptions options, ScriptOptions expectedOption)
{
return((options & expectedOption) == expectedOption);
}
private static ScriptOptions UpdateOptions(ScriptOptions options, InteractiveScriptGlobals globals)
{
var currentMetadataResolver = (RuntimeMetadataReferenceResolver)options.MetadataResolver;
var currentSourceResolver = (CommonCompiler.LoggingSourceFileResolver)options.SourceResolver;
string newWorkingDirectory = Directory.GetCurrentDirectory();
var newReferenceSearchPaths = ImmutableArray.CreateRange(globals.ReferencePaths);
var newSourceSearchPaths = ImmutableArray.CreateRange(globals.SourcePaths);
// remove references and imports from the options, they have been applied and will be inherited from now on:
return options.
RemoveImportsAndReferences().
WithMetadataResolver(currentMetadataResolver.
WithRelativePathResolver(
currentMetadataResolver.PathResolver.
WithBaseDirectory(newWorkingDirectory).
WithSearchPaths(newReferenceSearchPaths))).
WithSourceResolver(currentSourceResolver.
WithBaseDirectory(newWorkingDirectory).
WithSearchPaths(newSourceSearchPaths));
}
public static string JavaScript(ICollection <string> stateCollection, string script, ScriptOptions options)
{
if (IsRegistered(stateCollection, script))
{
return(null);
}
RegisterResource(stateCollection, script);
if (options == ScriptOptions.Include)
{
return(JavaScript(stateCollection, script));
}
if (options == ScriptOptions.None)
{
return(script);
}
if (options == ScriptOptions.ScriptTags)
{
return(string.Format(scriptFormat, script));
}
if (options == ScriptOptions.DocumentReady)
{
return(string.Format(scriptFormat, EmbedDocumentReady(script)));
}
throw new NotSupportedException(options + " not supported");
}
/// <summary>Register an embedded javascript resource reference in the page header with options.</summary>
/// <param name="page">The page in whose header to register the javascript.</param>
/// <param name="type">The type in whose assembly the javascript is embedded.</param>
/// <param name="resourceName">The name of the embedded resource.</param>
/// <param name="options">Options flag.</param>
public static void JavaScript(this Page page, Type type, string resourceName, ScriptOptions options)
{
JavaScript(page, page.ClientScript.GetWebResourceUrl(type, resourceName), options);
}
public SignalCompilationService(EntityMetadata entityMetadata, ScriptOptions scriptOptions) : base(entityMetadata, scriptOptions)
{
}
public static string JavaScript(ICollection<string> stateCollection, string script, ScriptOptions options)
{
if (IsRegistered(stateCollection, script))
return null;
RegisterResource(stateCollection, script);
if (options == ScriptOptions.Include)
return JavaScript(stateCollection, script);
if (options == ScriptOptions.None)
return script;
if (options == ScriptOptions.ScriptTags)
return string.Format(scriptFormat, script);
if (options == ScriptOptions.DocumentReady)
return string.Format(scriptFormat, EmbedDocumentReady(script));
throw new NotSupportedException(options + " not supported");
}
private static Expression <Func <ICellAccessor, Action> > ConstructVisitNodeAction(ExpressionSyntax traverseAction)
{
/***********************************************
* Syntax: (VISITNODE)
*
* 1. VisitNode(FanoutSearch.Action action, IEnumerable<string> select = null)
* 2. VisitNode(Expression<Func<ICellAccessor, FanoutSearch.Action>> action, IEnumerable<string> select = null)
*
* The select part is handled by the caller.
***********************************************/
var action_expr = TryGet <MemberAccessExpressionSyntax>(traverseAction);
var lambda_expression = TryGet <LambdaExpressionSyntax>(traverseAction);
Expression <Func <ICellAccessor, Action> > ret = null;
if (action_expr != null)
{
// Action enum
var id_expr = Get <IdentifierNameSyntax>(action_expr.Expression);
if (id_expr.ToString() != s_LIKQ_Action)
{
goto throw_badtype;
}
Action result_action;
ThrowIf(!Enum.TryParse(action_expr.Name.ToString(), out result_action), "Invalid traverse action", action_expr);
return(ExpressionBuilder.WrapAction(result_action));
}
else
{
if (lambda_expression == null)
{
goto throw_badtype;
}
// FanoutSearch.Action is ambiguous with with System.Action
var action_visitor = new FanoutSearchActionRewritter();
lambda_expression = action_visitor.Visit(lambda_expression) as LambdaExpressionSyntax;
ScriptOptions scriptOptions = ScriptOptions.Default;
var mscorlib = typeof(System.Object).Assembly;
var systemCore = typeof(System.Linq.Enumerable).Assembly;
var expression = typeof(Expression).Assembly;
var fanout = typeof(FanoutSearchModule).Assembly;
var trinity = typeof(Trinity.Global).Assembly;
scriptOptions = scriptOptions.AddReferences(mscorlib, systemCore, expression, fanout, trinity);
scriptOptions = scriptOptions.AddImports(
"System",
"System.Linq",
"System.Linq.Expressions",
"System.Collections.Generic",
"FanoutSearch",
"FanoutSearch.LIKQ",
"Trinity",
"Trinity.Storage");
try
{
// Allocate a cancellation token source, which signals after our timeout setting (if we do have timeout setting)
CancellationToken cancel_token = default(CancellationToken);
if (FanoutSearchModule._QueryTimeoutEnabled())
{
checked
{
cancel_token = new CancellationTokenSource((int)FanoutSearchModule.GetQueryTimeout()).Token;
}
}
// It is guaranteed that the lambda_expression is really a lambda.
// Evaluating a lambda and expecting an expression tree to be obtained now.
using (var eval_task = CSharpScript.EvaluateAsync <Expression <Func <ICellAccessor, Action> > >(lambda_expression.ToString(), scriptOptions, cancellationToken: cancel_token))
{
eval_task.Wait(cancel_token);
ret = eval_task.Result;
}
}
catch (ArithmeticException) { /* that's a fault not an error */ throw; }
catch { /*swallow roslyn scripting engine exceptions.*/ }
ThrowIf(null == ret, "Invalid lambda expression.", traverseAction);
return(ret);
}
throw_badtype:
ThrowIf(true, "Expecting an argument of type FanoutSearch.Action, or a lambda expression.", traverseAction);
return(null);//not going to happen
}
private void RunInteractiveLoop(ScriptOptions options, string initialScriptCodeOpt, CancellationToken cancellationToken)
{
var globals = new InteractiveScriptGlobals(_console.Out, _objectFormatter);
globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
ScriptState<object> state = null;
if (initialScriptCodeOpt != null)
{
var script = Script.CreateInitialScript<object>(_scriptCompiler, initialScriptCodeOpt, options, globals.GetType(), assemblyLoaderOpt: null);
Compilation compilation;
TryBuildAndRun(script, globals, ref state, out compilation, cancellationToken);
}
while (true)
{
_console.Out.Write("> ");
var input = new StringBuilder();
string line;
bool cancelSubmission = false;
while (true)
{
line = _console.In.ReadLine();
if (line == null)
{
if (input.Length == 0)
{
return;
}
cancelSubmission = true;
break;
}
input.AppendLine(line);
var tree = _scriptCompiler.ParseSubmission(SourceText.From(input.ToString()), cancellationToken);
if (_scriptCompiler.IsCompleteSubmission(tree))
{
break;
}
_console.Out.Write(". ");
}
if (cancelSubmission)
{
continue;
}
string code = input.ToString();
if (IsHelpCommand(code))
{
DisplayHelpText();
continue;
}
Script<object> newScript;
if (state == null)
{
newScript = Script.CreateInitialScript<object>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
}
else
{
newScript = state.Script.ContinueWith(code, options);
}
Compilation newCompilation;
if (!TryBuildAndRun(newScript, globals, ref state, out newCompilation, cancellationToken))
{
continue;
}
bool hasValue;
ITypeSymbol resultType = newCompilation.GetSubmissionResultType(out hasValue);
if (hasValue)
{
if (resultType != null && resultType.SpecialType == SpecialType.System_Void)
{
_console.Out.WriteLine(_objectFormatter.VoidDisplayString);
}
else
{
globals.Print(state.ReturnValue);
}
}
}
}
private void RunScript(ScriptOptions options, string code, string scriptPath, CommandLineHostObject globals, ErrorLogger errorLogger)
{
options = options.WithPath(scriptPath).WithIsInteractive(false);
var script = Script.CreateInitialScript<object>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
try
{
script.RunAsync(globals, globals.CancellationToken).Wait();
}
catch (CompilationErrorException e)
{
_compiler.ReportErrors(e.Diagnostics, _console.Out, errorLogger);
globals.ExitCode = CommonCompiler.Failed;
}
}
