public static byte[] Compile(CompilationRequest request) { if (request.Language == Models.Grunts.ImplantLanguage.CSharp) { return(CompileCSharp((CsharpCompilationRequest)request)); } return(null); }
public CompilationResult Compile(CompilationRequest request) { if (request.NeedTypeReloading || _typeCache == null) { _typeCache = _platform.ProvideTypes(); } var files = request.Sources.OfType <FileSource>() .Select((fs, index) => new InputFile(index, fs.Path, AmmyLanguage.Instance)) .ToArray(); if (files.Length > 0) { var cts = new CancellationTokenSource(); var references = request.ReferenceAssemblyPaths.Select(path => new FileLibReference(path)); var project = new FsProject <Start>(new FsSolution <Start>(), request.ProjectDir, files, references) { Data = request.Data }; var projectSupport = files.Select(f => f.Ast) .OfType <IProjectSupport>() .FirstOrDefault(); if (projectSupport == null) { throw new Exception("IProjectSupport not found"); } if (!(projectSupport is Start)) { throw new Exception("IProjectSupport should have AST type Start"); } var start = (Start)projectSupport; start.Platform = _platform; var data = projectSupport.RefreshReferences(cts.Token, project); var fileEvals = files.Select(fs => fs.GetEvalPropertiesData()) .ToImmutableArray(); projectSupport.RefreshProject(cts.Token, fileEvals, request.Data ?? data); var compilerMessages = fileEvals.SelectMany(f => f.GetCompilerMessage()) .Select(ToBackendCompilerMessage) .ToArray(); var hasError = compilerMessages.FirstOrDefault(msg => msg.Type == CompilerMessageType.Error) != null; var outputFiles = files.SelectMany(ToOutputFile).ToArray(); return(new CompilationResult("", !hasError, compilerMessages, outputFiles)); } return(new CompilationResult("", true, new CompilerMessage[0], new OutputFile[0])); }
private static string ToJson(CompilationRequest request) { string RequestFormat = @"{{ ""source"": ""{0}"", ""frameworkVersion"": {1}, ""outputKind"": {2} }}"; return(String.Format(RequestFormat, JavaScriptStringEncode(request.Source), request.TargetDotNetVersion.ToString("D"), request.OutputKind.ToString("D"))); }
public static byte[] Compile(CompilationRequest request) { switch (request.Language) { case Models.Grunts.ImplantLanguage.CSharp: return(CompileCSharp(request)); default: return(CompileCSharp(request)); } }
/// <summary> /// Add a contact to publication /// </summary> /// <param name="publicationID">ID of publication</param> /// <param name="contactID">ID of contact</param> /// <param name="token">token</param> public CompilationRequest addContactToPublication(int publicationID, int contactID, string token) { CompilationRequest cr = new CompilationRequest() { contactID = contactID, publicationID = publicationID, token = token }; return(AddEntity(cr)); }
/// <summary> /// Add a public publication /// </summary> /// <param name="publicationID">ID of publication</param> public CompilationRequest addPublicPublication(int publicationID) { CompilationRequest cr = new CompilationRequest() { //public contact contactID = 1, publicationID = publicationID, token = null }; return(AddEntity(cr)); }
public CompilationResult Compile([FromBody] CompilationRequest request) { CompilationResult result = new CompilationResult(); LexicalAnalyzer analyzer = new LexicalAnalyzer(LexicalLanguage.GetLanguage(), request.Input); BottomUpParser parser = new BottomUpParser(analyzer); parser.Parse(); result.IL = parser.GetILAsString(); result.Assembly = new CodeGenerator().GenerateAsString(parser.GetIL()); return(result); }
public byte[] Compile(CompilationRequest compilationRequest) { this.SetHeaders(); try { return(Convert.FromBase64String(client.UploadString(this.SharpShellURI, ToJson(compilationRequest)))); } catch (WebException e) { using (var reader = new StreamReader(e.Response.GetResponseStream())) { throw new CompilationException("CompilationException: " + reader.ReadToEnd()); } } }
public ASTResult AST([FromBody] CompilationRequest request) { ASTResult result = new ASTResult(); LexicalAnalyzer analyzer = new LexicalAnalyzer(LexicalLanguage.GetLanguage(), request.Input); BottomUpParser parser = new BottomUpParser(analyzer); parser.Parse(); result.AST += "digraph C {\r\n"; result.AST += parser.TopLevelAST.ToDot(); result.AST += "}"; return(result); }
public static byte[] Compile(CompilationRequest request) { var sourceSyntaxTrees = Directory.GetFiles(request.SourceDirectory, "*.cs", SearchOption.AllDirectories) .Select(f => new SourceSyntaxTree { FileName = f, SyntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(f), new CSharpParseOptions()) }) .ToList(); var compilationTrees = sourceSyntaxTrees.Select(s => s.SyntaxTree).ToList(); var options = new CSharpCompilationOptions(outputKind: request.OutputKind, optimizationLevel: OptimizationLevel.Release, platform: request.Platform); var compilation = CSharpCompilation.Create( request.AssemblyName, compilationTrees, request.References.Where(r => r.Framework == request.TargetDotNetVersion).Where(r => r.Enabled).Select(r => { return(MetadataReference.CreateFromFile(request.ReferenceDirectory + Path.DirectorySeparatorChar + r.File)); }).ToList(), options ); EmitResult emitResult; byte[] ILbytes = null; using (var ms = new MemoryStream()) { emitResult = compilation.Emit(ms); if (emitResult.Success) { ms.Flush(); ms.Seek(0, SeekOrigin.Begin); ILbytes = ms.ToArray(); } else { var sb = new StringBuilder(); foreach (var d in emitResult.Diagnostics) { sb.AppendLine(d.ToString()); } throw new CompilerException("CompilationErrors: " + Environment.NewLine + sb); } } return(ILbytes); }
/// <summary> /// Add a new Result /// </summary> /// <param name="compilationRequestID">The ID of compilation request</param> /// <param name="xmlResult">The xml</param> /// <returns>Result Object</returns> public Object addResult(int compilationRequestID, XElement xmlResult) { CompilationRequest cr = context.CompilationRequest.FirstOrDefault(f => f.compilReqID == compilationRequestID); Publication p = cr.Publication; cr.compiled = true; Result r = new Result(); if (p.anonymResult) { r.publicationID = p.publicationID; r.xmlResult = xmlResult; return(AddEntity(r)); } else { r.compilReqID = compilationRequestID; r.xmlResult = xmlResult; return(AddEntity(r)); } }
static async Task Main(string[] args) { Microsoft.Build.Locator.MSBuildLocator.RegisterDefaults(); ApplicationLogging.SetLoggerFactory(LoggerFactory.Create(l => l.SetMinimumLevel(LogLevel.Information) .AddZLoggerConsole(options => options.PrefixFormatter = (buf, info) => ZString.Utf8Format(buf, "[{0}] [{1:D2}:{2:D2}:{3:D2}] ", GetLogLevelString(info.LogLevel), info.Timestamp.LocalDateTime.Hour, info.Timestamp.LocalDateTime.Minute, info.Timestamp.LocalDateTime.Second)))); var settings = new H5DotJson_AssemblySettings(); var request = new CompilationRequest("App", settings) .NoPackageResources() .NoHTML() .WithPackageReference("h5", NuGetVersion.Parse("0.0.8537")) .WithPackageReference("h5.Core", NuGetVersion.Parse("0.0.8533")) .WithSourceFile("App.cs", @" using System; using H5; namespace Test { internal static class App { private static int HelloWorld; private static void Main() { Console.WriteLine(nameof(HelloWorld)); } } } "); var compiledJavascript = await CompilationProcessor.CompileAsync(request); foreach (var(file, code) in compiledJavascript.Output) { Logger.ZLogInformation("File: {0}\n\n----------------------------\n\n{1}\n\n----------------------------\n\n", file, code); } await Task.Delay(1000); //Awaits to print all log messages }
public void getResultsByPublicationIDTest() { XElement xe = XElement.Parse("<catalog><book id=\"bk101\"><author>Gambardella, Matthew</author><title>XML Developer's Guide</title><genre>Computer</genre>text1</book><!--Comment1--><book id=\"bk102\"><!--Comment2--><author>Ralls, Kim</author><title>Midnight Rain</title><genre>Fantasy</genre></book></catalog>"); List <Result> listResultToRemove = new List <Result>(); CompilationRequest s = storageManager.getEntityByID <CompilationRequest>(11); if (s != null) { for (int i = 0; i < 10; i++) { Result r = (Result)storageManager.addResult(11, xe); listResultToRemove.Add(r); } } List <Result> lr = storageManager.getResultsByPublicationID(s.publicationID.Value); if (listResultToRemove.Count > 0) { storageManager.removeEntity <Result>(listResultToRemove); } }
public static byte[] Compile(CompilationRequest request) { // Gather SyntaxTrees for compilation List <SourceSyntaxTree> sourceSyntaxTrees = new List <SourceSyntaxTree>(); List <SyntaxTree> compilationTrees = new List <SyntaxTree>(); if (request.SourceDirectories != null) { foreach (var sourceDirectory in request.SourceDirectories) { sourceSyntaxTrees.AddRange(Directory.GetFiles(sourceDirectory, "*.cs", SearchOption.AllDirectories) .Select(F => new SourceSyntaxTree { FileName = F, SyntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(F), new CSharpParseOptions()) }) .ToList()); compilationTrees.AddRange(sourceSyntaxTrees.Select(S => S.SyntaxTree).ToList()); } } SyntaxTree sourceTree = CSharpSyntaxTree.ParseText(request.Source, new CSharpParseOptions()); compilationTrees.Add(sourceTree); List <PortableExecutableReference> references = request.References.Where(R => R.Framework == request.TargetDotNetVersion).Where(R => R.Enabled).Select(R => { switch (R.Framework) { case Common.DotNetVersion.Net35: return(MetadataReference.CreateFromFile(R.File)); case Common.DotNetVersion.Net40: return(MetadataReference.CreateFromFile(R.File)); case Common.DotNetVersion.NetCore21: return(MetadataReference.CreateFromFile(R.File)); default: return(null); } }).ToList(); // Use specified OutputKind and Platform CSharpCompilationOptions options = new CSharpCompilationOptions(outputKind: request.OutputKind, optimizationLevel: OptimizationLevel.Release, platform: request.Platform, allowUnsafe: request.UnsafeCompile); // Compile to obtain SemanticModel CSharpCompilation compilation = CSharpCompilation.Create( request.AssemblyName == null ? Path.GetRandomFileName() : request.AssemblyName, compilationTrees, references, options ); // Perform source code optimization, removing unused types if (request.Optimize) { // Find all Types used by the generated compilation List <ITypeSymbol> usedTypes = new List <ITypeSymbol>(); GetUsedTypesRecursively(compilation, sourceTree, ref usedTypes, ref sourceSyntaxTrees); usedTypes = usedTypes.Distinct().ToList(); List <string> usedTypeNames = usedTypes.Select(T => GetFullyQualifiedTypeName(T)).ToList(); // Filter SyntaxTrees to trees that define a used Type, otherwise the tree is not needed in this compilation compilationTrees = sourceSyntaxTrees.Where(SST => SyntaxTreeDefinesUsedType(compilation, SST.SyntaxTree, usedTypeNames)) .Select(SST => SST.SyntaxTree) .ToList(); // Removed unused Using statements from the additional entrypoint source List <string> usedNamespaceNames = GetUsedTypes(compilation, sourceTree) .Select(T => GetFullyQualifiedContainingNamespaceName(T)).Distinct().ToList(); List <SyntaxNode> unusedUsingDirectives = sourceTree.GetRoot().DescendantNodes().Where(N => { return(N.Kind() == SyntaxKind.UsingDirective && !((UsingDirectiveSyntax)N).Name.ToFullString().StartsWith("System.") && !usedNamespaceNames.Contains(((UsingDirectiveSyntax)N).Name.ToFullString())); }).ToList(); sourceTree = sourceTree.GetRoot().RemoveNodes(unusedUsingDirectives, SyntaxRemoveOptions.KeepNoTrivia).SyntaxTree; // Console.WriteLine("source: " + sourceTree.ToString()); // Compile again, with unused SyntaxTrees and unused using statements removed compilationTrees.Add(sourceTree); compilation = CSharpCompilation.Create( request.AssemblyName == null ? Path.GetRandomFileName() : request.AssemblyName, compilationTrees, request.References.Where(R => R.Framework == request.TargetDotNetVersion).Where(R => R.Enabled).Select(R => { switch (request.TargetDotNetVersion) { case Common.DotNetVersion.Net35: return(MetadataReference.CreateFromFile(R.File)); case Common.DotNetVersion.Net40: return(MetadataReference.CreateFromFile(R.File)); case Common.DotNetVersion.NetCore21: return(MetadataReference.CreateFromFile(R.File)); default: return(null); } }).ToList(), options ); } // Emit compilation EmitResult emitResult; byte[] ILbytes = null; using (var ms = new MemoryStream()) { emitResult = compilation.Emit( ms, manifestResources: request.EmbeddedResources.Where(ER => { return(request.Platform == Platform.AnyCpu || ER.Platform == Platform.AnyCpu || ER.Platform == request.Platform); }).Where(ER => ER.Enabled).Select(ER => { return(new ResourceDescription(ER.Name, () => File.OpenRead(ER.File), true)); }).ToList() ); if (emitResult.Success) { ms.Flush(); ms.Seek(0, SeekOrigin.Begin); ILbytes = ms.ToArray(); } else { StringBuilder sb = new StringBuilder(); foreach (Diagnostic d in emitResult.Diagnostics) { sb.AppendLine(d.ToString()); } throw new CompilerException("CompilationErrors: " + Environment.NewLine + sb); } } if (request.Confuse) { return(Confuse(ILbytes)); } return(ILbytes); }
/// <summary> /// Make the workflow pointed by this WorkflowReference computable /// </summary> /// <param name="ftype">The <see cref="Security.FormType"/>of the computable workflow</param> /// <param name="serviceId"> The serviceId allowed to fill this workflow</param> /// <param name="publicationDescription"> The workflowdescription of the publication, empty string for empty description</param> /// <param name="expireDate"> The expire date gg/mm/aaaa</param> /// <param name="communicationUri"> The uri used by communication package</param> /// <returns>A <see cref="Security.ComputableWorkflowReference"/> pointing the newly created <see cref="Core.WF.IComputableWorkflow"/>; <value>null</value> if an error happens</returns> public ComputableWorkflowReference MakeComputable(FormType ftype, int serviceId, string publicationDescription, string expireDate, string communicationUri) { if (publicationDescription == null) { return(null); } if (!complete) { fillReference(); } bool publicp = ((ftype == FormType.PUBLIC_BY_SERVICE) || (ftype == FormType.PUBLIC_WITH_REPLICATION) || (ftype == FormType.PUBLIC_WITHOUT_REPLICATION)); bool anonym = ((ftype == FormType.PRIVATE_ANONYM) || (ftype == FormType.PUBLIC_BY_SERVICE) || (ftype == FormType.PUBLIC_WITH_REPLICATION) || (ftype == FormType.PUBLIC_WITHOUT_REPLICATION)); bool resultReplicated = (ftype == FormType.PUBLIC_WITH_REPLICATION); if (ftype == FormType.PUBLIC_BY_SERVICE && (serviceId == 1)) { // Not allowed, we need a valid serviceId return(null); } if (wf_cache == null) { if (!_RetrieveWf()) { return(null); } } IFormatProvider provider = CultureInfo.InvariantCulture; DateTime date; if (!DateTime.TryParse(expireDate, provider, DateTimeStyles.AdjustToUniversal, out date)) { provider = CultureInfo.GetCultureInfo("it-IT"); if (!DateTime.TryParse(expireDate, provider, DateTimeStyles.AdjustToUniversal, out date)) { date = DateTime.Now.AddMonths(1); } } Publication pub = sto.publish(modelId, DateTime.Now, date, "", wf_cache.Save(), anonym, publicp, resultReplicated, serviceId, communicationUri, "Inutile", publicationDescription); if (pub == null) { return(null); } // Make it public int creqid = -1; if (publicp) { CompilationRequest creq = null; if (resultReplicated) { creq = sto.addPublicPublication(pub.publicationID); if (creq == null) { return(null); } creqid = creq.compilReqID; } Storage.User user = sto.getEntityByID <Storage.User>(userId); //Genero email per creatore try { System.Net.Mail.MailAddress userMail = new System.Net.Mail.MailAddress(user.mail); MailForPublicForm mail = new MailForPublicForm(userMail, pub, creq); LoaMailSender sender = new LoaMailSender(); sender.SendMail(mail); } catch { //non dovrebbe mai arrivare qui visto che la mail dell'utente e' controllata in fase di registrazione return(null); } } if (!String.IsNullOrEmpty(communicationUri)) { CommunicationService.Instance.Setup(pub); } return(new ComputableWorkflowReference(userId, pub.publicationID, pub.namePublication, pub.description, themeId, creqid, !publicp, false, date)); }
public async Task <IActionResult> ChangeTaskWithFile(IFormFile file, string framework) { if (file != null) { var isAlive = await CheckIfAlive(_config.CompilerServicesOrchestrator); if (isAlive) { var req = new CompilationRequest { File = await file.GetBytes(), Framework = framework }; string url = _config.CompilerServicesOrchestrator.GetFullTaskLinkFrom(_config.FrontEnd); using var httpClient = new HttpClient(); using var form = JsonContent.Create(req); HttpResponseMessage response = await httpClient.PostAsync(url, form); string apiResponse = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { CompilationResponse compResponse = JsonConvert.DeserializeObject <CompilationResponse>(apiResponse); if (compResponse.OK) { string dirPath = "c:/TemporaryTaskDownloads"; dirPath += "/" + Guid.NewGuid().ToString(); while (Directory.Exists(dirPath)) { dirPath += "/" + Guid.NewGuid().ToString(); } var dir = Directory.CreateDirectory(dirPath); string fullPath = dirPath + "/" + file.Name; System.IO.File.WriteAllBytes(fullPath, compResponse.File); ZipFile.ExtractToDirectory(fullPath, dirPath, true); var pathToDll = FindAssemblyFile(dir, ".dll"); if (pathToDll == null) { pathToDll = FindAssemblyFile(dir, ".exe"); } List <ClassDefinition> result = null; if (pathToDll != null) { result = ConvertProject(pathToDll); } dir.Delete(true); if (result != null) { var response1 = new { status = "success", data = result }; return(Json(response1)); } else { var response2 = new { status = "error", data = "No dll or exe file found!" }; return(Json(response2)); } } var response3 = new { status = "error", data = "Compilation container returned error with message: " + compResponse.Message }; return(Json(response3)); } var response4 = new { status = "error", data = "Compilation container returned " + response.StatusCode + " !" }; return(Json(response4)); } var response5 = new { status = "error", data = "Compilation serviec is dead!" }; return(Json(response5)); } var response6 = new { status = "error", data = "No file uploaded!" }; return(Json(response6)); }