/// <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) });
}
