/// <inheritdoc /> public IEnumerable <CompilerReference> GetReferences( TypeContext context, IEnumerable <CompilerReference> includeAssemblies) { IEnumerable <string> loadedAssemblies = new UseCurrentAssembliesReferenceResolver() .GetReferences(context, includeAssemblies) .Select(r => r.GetFile()) .ToArray(); // All assemblies which can be used inside the templates need to be listed here. yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "System.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "System.Core.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "netstandard.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "Microsoft.CSharp.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "Newtonsoft.Json.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "Cake.Core.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "Cake.Issues.dll"))); yield return(CompilerReference.From(this.FindLoaded(loadedAssemblies, "Cake.Issues.Reporting.Generic.dll"))); yield return(CompilerReference.From(typeof(RazorEngine.Engine).Assembly)); }
public static Grammar LoadGrammar(string pathGrammarFile, bool verbose = false, params Type[] types) { var assemblies = new Assembly[types.Length]; for (int i = 0; i < types.Length; ++i) { assemblies[i] = types[i].GetTypeInfo().Assembly; } var compilationResult = DSLCompiler.Compile(new CompilerOptions() { InputGrammarText = File.ReadAllText(pathGrammarFile), References = CompilerReference.FromAssemblyFiles(assemblies) }); if (verbose) { if (compilationResult.HasErrors) { Console.WriteLine("Compilation HasErrors! Trace: "); compilationResult.TraceDiagnostics(); Console.WriteLine("------------------------------------------"); } else { Console.WriteLine("No Errors in Compilation. Trace: "); compilationResult.TraceDiagnostics(); Console.WriteLine("------------------------------------------"); } } return(compilationResult.HasErrors ? null : compilationResult.Value); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies) { // TypeContext gives you some context for the compilation (which templates, which namespaces and types) // You must make sure to include all libraries that are required! // Mono compiler does add more standard references than csc! // If you want mono compatibility include ALL references here, including mscorlib! // If you include mscorlib here the compiler is called with /nostdlib. IEnumerable <string> loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()) .GetReferences(context, includeAssemblies) .Select(r => r.GetFile()) .ToArray(); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "mscorlib.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.Core.dll"))); //yield return CompilerReference.From(FindLoaded(loadedAssemblies, "Coralcode.Framework.dll")); ; yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "RazorEngine.dll"))); yield return(CompilerReference.From(typeof(MyIReferenceResolver).Assembly)); // Assembly // There are several ways to load an assembly: //yield return CompilerReference.From("Path-to-my-custom-assembly"); // file path (string) //byte[] assemblyInByteArray = --- Load your assembly ---; //yield return CompilerReference.From(assemblyInByteArray); // byte array (roslyn only) //string assemblyFile = --- Get the path to the assembly ---; //yield return CompilerReference.From(File.OpenRead(assemblyFile)); // stream (roslyn only) }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies) { IEnumerable <string> loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()) .GetReferences(context, includeAssemblies) .Select(r => r.GetFile()) .ToArray(); // If more assembly references are required for RazorEngine then add references here also // so RazorEngine will load the assemblies for its compiler yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "mscorlib.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.Core.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.Web.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.Web.Mvc.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "System.Web.Razor.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "RazorEngine.dll"))); yield return(CompilerReference.From(FindLoaded(loadedAssemblies, "CSJSHandler.dll"))); }
public static void Setup() { _grammar = LoadGrammar("TreeLang.grammar", CompilerReference.FromAssemblyFiles( typeof(Microsoft.ProgramSynthesis.Utils.Record).GetTypeInfo().Assembly, typeof(Semantics).GetTypeInfo().Assembly, typeof(SyntaxNode).GetTypeInfo().Assembly)); if (_grammar == null) { Log.Error("Failed to compile TreeLang.grammar."); return; } InputSymbol = _grammar.InputSymbol; _scorer = new RankingScore(_grammar); _engine = new SynthesisEngine(_grammar, new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new PremStrategy(_grammar), }, UseThreads = false }); Log.Debug("Transformer: synthesis engine is setup."); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context = null, IEnumerable <CompilerReference> includeAssemblies = null) { return((from a in CompilerServicesUtility.GetLoadedAssemblies().Where(delegate(Assembly a) { if (!a.IsDynamic) { try { // Call to .Location property throws an exception on some assemblies, something weird with file://?/C:/... if (File.Exists(a.Location)) { return !a.Location.Contains("CompiledRazorTemplates.Dynamic"); } } catch { return false; } } return false; }) group a by a.GetName().Name into grp select grp.First((Assembly y) => y.GetName().Version == grp.Max((Assembly x) => x.GetName().Version)) into a select CompilerReference.From(a)).Concat(includeAssemblies ?? Enumerable.Empty <CompilerReference>())); }
/// <summary> /// Returns a set of assemblies that must be referenced by the compiled template. /// </summary> /// <returns>The set of assemblies.</returns> public override IEnumerable <CompilerReference> IncludeReferences() { return(new[] { CompilerReference.From(typeof(Binder).Assembly) }); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { var newReference = new[] { CompilerReference.From(SystemRuntime), }; var assemblies = includeAssemblies?.Concat(newReference) ?? newReference; return(Resolver.GetReferences(context, assemblies)); }
private static Result <Grammar> CompileGrammar() { return(DSLCompiler.Compile(new CompilerOptions { InputGrammarText = File.ReadAllText(GrammarPath), References = CompilerReference.FromAssemblyFiles(typeof(Semantics).GetTypeInfo().Assembly) })); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { // We need to return this standard set or even simple views blow up on // a missing reference to System.Linq. var loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()).GetReferences(null); foreach (var reference in loadedAssemblies) { yield return(reference); } yield return(CompilerReference.From("test/TestHelper.dll")); }
private LanguageGrammar() { var options = new CompilerOptions { InputGrammarText = GrammarContent, References = CompilerReference.FromAssemblyFiles( typeof(Semantics).GetTypeInfo().Assembly, typeof(Microsoft.ProgramSynthesis.Wrangling.Tree.Node).GetTypeInfo().Assembly) }; Result <Grammar> compile = DSLCompiler.Compile(options); Grammar = compile.Value; }
static Grammar getGrammar() { var g = DSLCompiler.Compile(new CompilerOptions { InputGrammarText = File.ReadAllText("SExp.grammar"), References = CompilerReference.FromAssemblyFiles( typeof(SExpProgram).GetTypeInfo().Assembly, typeof(Semantics.SExp).GetTypeInfo().Assembly, typeof(Semantics.Semantics).GetTypeInfo().Assembly, typeof(Learning.RankingScore).GetTypeInfo().Assembly) }); return(g.Value); }
static HuberReferenceResolver() { //加载本地所有类库,@using 使用 compilerReference = new List <CompilerReference>(); IEnumerable <string> loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()) .GetReferences(null, null) .Select(r => r.GetFile()) .ToArray(); foreach (var l in loadedAssemblies) { compilerReference.Add(CompilerReference.From(l)); } }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies) { // TypeContext gives you some context for the compilation (which templates, which namespaces and types) // My templates need some special reference to compile. return(new[] { //CompilerReference.From("Path-to-my-custom-assembly"), // file path (string) CompilerReference.From(typeof(SystemConfig).Assembly), CompilerReference.From(typeof(Config).Assembly), CompilerReference.From(typeof(MongoConnectionConfig).Assembly) // Assembly //CompilerReference.From(assemblyInByteArray), // byte array (roslyn only) //CompilerReference.From(File.OpenRead(assembly)), // stream (roslyn only) }); }
public IEnumerable <CompilerReference> GetReferences( TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { yield return(CompilerReference.From(this.GetType().Assembly)); var refs = new UseCurrentAssembliesReferenceResolver() .GetReferences(context, includeAssemblies) .Where(f => !f.GetFile().EndsWith(".winmd")); foreach (var r in refs) { yield return(r); } }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { var results = new UseCurrentAssembliesReferenceResolver() .GetReferences(context, includeAssemblies) .ToList(); //添加DataTable的引用 results.Add(CompilerReference.From(typeof(DataTable).Assembly)); if (_assembliesToLoad != null) { foreach (var item in _assembliesToLoad) { results.Add(CompilerReference.From(item)); } } return(results); }
private static void LoadAndTestTextExtraction() { var grammar = LoadGrammar("ProseSample.TextExtraction.grammar", CompilerReference.FromAssemblyFiles(typeof(Substring).GetTypeInfo().Assembly, typeof(TextExtraction.Semantics).GetTypeInfo().Assembly, typeof(Substrings.Language).GetTypeInfo().Assembly)); if (grammar == null) { WriteColored(ConsoleColor.Magenta, "Compilation of ProseSample.TextExtraction.grammar failed: skipping tests"); return; } TestExtractionBenchmark(grammar, "areas"); TestExtractionBenchmark(grammar, "popl13-erc"); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { // If you include mscorlib here the compiler is called with /nostdlib. IEnumerable <string> loadedAssemblies = new UseCurrentAssembliesReferenceResolver() .GetReferences(context, includeAssemblies) .Select(r => r.GetFile()) .ToArray(); foreach (var assm in loadedAssemblies) { yield return(CompilerReference.From(assm)); } // Pre-load template models Assembly.Load(typeof(ATS.eFP.Entities.Workorder.Workorder).Assembly.GetName()); Assembly.Load(typeof(ATS.eFP.Entities.Product.Product).Assembly.GetName()); Assembly.Load(typeof(ATS.eFP.WebJob.Email.Application.Models.WorkorderNotificationWrapper).Assembly.GetName()); }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { var allAssembly = CompilerServicesUtility .GetLoadedAssemblies(); var AssemblyToReference = allAssembly .Where(a => !a.IsDynamic && File.Exists(a.Location) && !a.Location.Contains("CompiledRazorTemplates.Dynamic") && a.FullName.IndexOf("System.Web.Helpers") < 0) //(CompilerServiceBase.DynamicTemplateNamespace)) .GroupBy(a => a.GetName().Name).Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version))) // only select distinct assemblies based on FullName to avoid loading duplicate assemblies .Select(a => CompilerReference.From(a)) .Concat(includeAssemblies ?? Enumerable.Empty <CompilerReference>()); yield return(CompilerReference.From(HostingEnvironment.ApplicationPhysicalPath + @"Modules\Laser.Orchard.StartupConfig\bin\System.Web.Helpers.dll")); foreach (var assembly in AssemblyToReference) { yield return(assembly); } }
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null) { // We need to return this standard set or even simple views blow up on // a missing reference to System.Linq. var loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()).GetReferences(null); foreach (var reference in loadedAssemblies) { yield return(reference); } var testHelper = Path.Combine( Path.GetDirectoryName(typeof(ReferenceResolverConfigCreator).Assembly.Location), "test", "TestHelper.dll"); yield return(CompilerReference.From(testHelper)); }
public TransformationsController() { const string grammarFileName = @"Prose/Transformations.grammar"; var reader = new StreamReader(PathToFiles + grammarFileName); var grammar = reader.ReadToEnd(); _grammar = DSLCompiler.Compile( new CompilerOptions() { InputGrammarText = grammar, References = CompilerReference.FromAssemblyFiles( typeof(List <int>).GetTypeInfo().Assembly, typeof(Semantics).GetTypeInfo().Assembly, typeof(Node).GetTypeInfo().Assembly) } ); }
private static void LoadAndTestSubstrings() { var grammar = LoadGrammar("ProseSample.Substrings.grammar", CompilerReference.FromAssemblyFiles(typeof(StringRegion).GetTypeInfo().Assembly, typeof(Substrings.Semantics).GetTypeInfo().Assembly, typeof(Record).GetTypeInfo().Assembly)); if (grammar == null) { return; } StringRegion prose = new StringRegion("Microsoft Program Synthesis using Examples SDK", Token.Tokens); StringRegion sdk = prose.Slice(prose.End - 3, prose.End); Spec spec = ShouldConvert.Given(grammar).To(prose, sdk); Learn(grammar, spec, new Substrings.RankingScore(grammar), new Substrings.WitnessFunctions(grammar)); TestFlashFillBenchmark(grammar, "emails"); }
private Assembly AssemblyResolve(object sender, ResolveEventArgs args) { return(CompilerReference.Resolve(args.Name, _references.GetCurrentReferences())); }
public override IEnumerable <CompilerReference> IncludeReferences() { // Ensure the Microsoft.CSharp assembly is referenced to support dynamic typing. return(new[] { CompilerReference.From(typeof(Microsoft.CSharp.RuntimeBinder.Binder).Assembly) }); }