static string CreateAssembly(string name, string code, bool exe = false) { // Never return or hold the Assembly instance. This will cause // the assembly to be loaded into the current domain and this // interferes with the tests. The Domain can execute fine from a // path, so let's return that. CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateExecutable = exe; var assemblyName = name; var assemblyFullPath = Path.Combine(TestPath, assemblyName); parameters.OutputAssembly = assemblyFullPath; parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); var netstandard = "netstandard.dll"; if (Type.GetType("Mono.Runtime") != null) { netstandard = "Facades/" + netstandard; } parameters.ReferencedAssemblies.Add(netstandard); parameters.ReferencedAssemblies.Add(PythonDllLocation); // Write code to file so it can debugged. var sourcePath = Path.Combine(TestPath, name + "_source.cs"); using (var file = new StreamWriter(sourcePath)) { file.Write(code); } CompilerResults results = provider.CompileAssemblyFromFile(parameters, sourcePath); if (results.NativeCompilerReturnValue != 0) { var stderr = System.Console.Error; stderr.WriteLine($"Error in {name} compiling:\n{code}"); foreach (var error in results.Errors) { stderr.WriteLine(error); } throw new ArgumentException("Error compiling code"); } return(assemblyFullPath); }
protected override CompilerResults DoCompile() { var files = from doc in Documents where doc is CSDocument select doc.LocalPath; var assemblyLocation = GetFreshAssemblyLocation(); var assemblyBaseDir = Path.GetDirectoryName(assemblyLocation); if (!Directory.Exists(assemblyBaseDir)) { Directory.CreateDirectory(assemblyBaseDir); } var compilerParams = new CompilerParameters(); compilerParams.WarningLevel = 4; compilerParams.OutputAssembly = assemblyLocation; compilerParams.GenerateExecutable = false; compilerParams.GenerateInMemory = false; compilerParams.IncludeDebugInformation = true; compilerParams.CompilerOptions += "/unsafe "; switch (BuildConfiguration) { case BuildConfiguration.Release: compilerParams.CompilerOptions += "/optimize "; break; case BuildConfiguration.Debug: break; } foreach (var reference in References) { var location = reference.AssemblyLocation; if (Path.GetExtension(location) != ".dll") { location = string.Format("{0}.dll", location); } compilerParams.ReferencedAssemblies.Add(location); } return(FProvider.CompileAssemblyFromFile(compilerParams, files.ToArray())); }
private IReflectionOptimizer Build(string code) { CodeDomProvider provider = new CSharpCodeProvider(); CompilerResults res; if (FluorineConfiguration.Instance.OptimizerSettings.Debug) { string file = Path.Combine(Path.GetTempPath(), _mappedClass.FullName.Replace('.', '_').Replace("+", "__")) + ".cs"; StreamWriter sw = File.CreateText(file); sw.Write(code); sw.Close(); log.Debug(__Res.GetString(__Res.Optimizer_FileLocation, _mappedClass.FullName, file)); _cp.TempFiles = new TempFileCollection(Path.GetTempPath()); _cp.TempFiles.KeepFiles = true; #if !(NET_1_1) res = provider.CompileAssemblyFromFile(_cp, file); #else ICodeCompiler compiler = provider.CreateCompiler(); res = compiler.CompileAssemblyFromFile(_cp, file); #endif } else { #if !(NET_1_1) res = provider.CompileAssemblyFromSource(_cp, new string[] { code }); #else ICodeCompiler compiler = provider.CreateCompiler(); res = compiler.CompileAssemblyFromSource(_cp, code); #endif } if (res.Errors.HasErrors) { foreach (CompilerError e in res.Errors) { log.Error(__Res.GetString(__Res.Compiler_Error, e.Line, e.Column, e.ErrorText)); } throw new InvalidOperationException(res.Errors[0].ErrorText); } Assembly assembly = res.CompiledAssembly; System.Type[] types = assembly.GetTypes(); IReflectionOptimizer optimizer = (IReflectionOptimizer)assembly.CreateInstance(types[0].FullName, false, BindingFlags.CreateInstance, null, null, null, null); return(optimizer); }
public void CompileArchive(string archiveFilename, bool run1stItem, string iconFilename) { CodeDomProvider csc = new CSharpCodeProvider(); CompilerParameters cp = new CompilerParameters(); cp.GenerateExecutable = true; cp.OutputAssembly = archiveFilename; cp.CompilerOptions = "/target:winexe"; // Custom option to run a file after extraction if (run1stItem) { cp.CompilerOptions += " /define:RUN_1ST_ITEM"; } if (!string.IsNullOrEmpty(iconFilename)) { cp.CompilerOptions += " /win32icon:" + iconFilename; } cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Core.dll"); cp.ReferencedAssemblies.Add("System.Xml.Linq.dll"); cp.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); cp.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); cp.ReferencedAssemblies.Add("System.Data.dll"); cp.ReferencedAssemblies.Add("System.Deployment.dll"); cp.ReferencedAssemblies.Add("System.Drawing.dll"); cp.ReferencedAssemblies.Add("System.Windows.Forms.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); // Add compressed files as resource cp.EmbeddedResources.AddRange(filenames.ToArray()); // Compile standalone executable with input files embedded as resource CompilerResults cr = csc.CompileAssemblyFromFile(cp, sourceNames.ToArray()); // yell if compilation error if (cr.Errors.Count > 0) { string msg = "Errors building " + cr.PathToAssembly; foreach (CompilerError ce in cr.Errors) { msg += Environment.NewLine + ce.ToString(); } throw new ApplicationException(msg); } }
string CompileTest(string testName) { string code = GetResource(testName); string md5 = ToHexadecimal(new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(code))); string path = Path.GetTempPath(); path = Path.Combine(path, "SharpDevelop"); path = Path.Combine(path, "DebuggerTestsX86"); path = Path.Combine(path, testName + "." + md5); Directory.CreateDirectory(path); string codeFilename = Path.Combine(path, testName); string exeFilename = Path.Combine(path, testName.Replace(".cs", ".exe")); if (File.Exists(exeFilename)) { return(exeFilename); } StreamWriter file = new StreamWriter(codeFilename); file.Write(code); file.Close(); CompilerParameters compParams = new CompilerParameters(); compParams.GenerateExecutable = true; compParams.GenerateInMemory = false; compParams.TreatWarningsAsErrors = false; compParams.IncludeDebugInformation = true; compParams.ReferencedAssemblies.Add("System.dll"); compParams.OutputAssembly = exeFilename; compParams.CompilerOptions = "/unsafe /platform:x86"; compParams.ReferencedAssemblies.Add(typeof(TestFixtureAttribute).Assembly.Location); CSharpCodeProvider compiler = new CSharpCodeProvider(); CompilerResults result = compiler.CompileAssemblyFromFile(compParams, codeFilename); if (result.Errors.Count > 0) { throw new System.Exception("There was an error(s) during compilation of test program:\n" + result.Errors[0].ToString()); } return(exeFilename); }
private static Assembly CompileAssemblyFromFile(string path) { if (!File.Exists(path)) { throw new CustomScriptExecutionException(CustomScriptExecutionException.Reason.ScriptFileNotFound); } CodeDomProvider provider = new CSharpCodeProvider(); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateInMemory = true; parameters.CompilerOptions = "/optimize"; parameters.ReferencedAssemblies.Add("mscorlib.dll"); parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("System.Xml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll"); // Reference the AlarmWorkflow.Shared.dll as well. parameters.ReferencedAssemblies.Add(typeof(ExtendedObjectExpressionFormatter <>).Assembly.Location); // Also reference the assembly which contains the object to be formatted. parameters.ReferencedAssemblies.Add(typeof(TInput).Assembly.Location); Stopwatch sw = Stopwatch.StartNew(); CompilerResults results = provider.CompileAssemblyFromFile(parameters, path); sw.Stop(); Logger.Instance.LogFormat(LogType.Info, null, Properties.Resources.CustomScriptCompilationFinished, sw.ElapsedMilliseconds); if (results.Errors.Count > 0) { Logger.Instance.LogFormat(LogType.Warning, null, Properties.Resources.CustomScriptCompilationWithErrorsWarnings, results.Errors.Count, path); foreach (CompilerError item in results.Errors) { Logger.Instance.LogFormat(LogType.Warning, null, "{0}", item); } if (results.Errors.HasErrors) { throw new CustomScriptExecutionException(CustomScriptExecutionException.Reason.CompilationFailed); } } return(results.CompiledAssembly); }
/// <summary> /// 从文件编译 /// </summary> /// <param name="files">要编译的代码文件集合</param> /// <param name="referenceAssemblyNames">引用程序集名称集合</param> /// <param name="outputAssembly">输出dll名称</param> /// <returns>返回异常信息</returns> public static string CompileFromFile(string[] files, string[] referenceAssemblyNames, string outputAssembly) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CompilerParameters compilerParameters = new CompilerParameters(referenceAssemblyNames, outputAssembly); CompilerResults complierResult = codeProvider.CompileAssemblyFromFile(compilerParameters, files); if (complierResult.Errors.HasErrors) { StringBuilder message = new StringBuilder(); foreach (CompilerError err in complierResult.Errors) { message.AppendFormat("(FileName:{0},ErrLine:{1}): error {2}: {3}", err.FileName, err.Line, err.ErrorNumber, err.ErrorText); } return(message.ToString()); } return(string.Empty); }
public static Boolean CompileSourceFiles(ruleSet[] rulesets, List <string> allSourceFiles, out CompilerResults cr, string rulesDir, string execDir, string compiledparamRules) { cr = null; try { CSharpCodeProvider c = new CSharpCodeProvider(); // c.CreateCompiler(); // ICodeCompiler icc = c.CreateCompiler(); CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("system.dll"); cp.ReferencedAssemblies.Add("system.xml.dll"); cp.ReferencedAssemblies.Add("system.data.dll"); cp.ReferencedAssemblies.Add("system.windows.forms.dll"); cp.ReferencedAssemblies.Add(execDir + "GraphSynth.exe"); cp.ReferencedAssemblies.Add(execDir + "Representation.dll"); cp.CompilerOptions = "/t:library"; cp.GenerateInMemory = true; cp.OutputAssembly = rulesDir + compiledparamRules; string[] allSourceFilesArray = allSourceFiles.ToArray(); cr = c.CompileAssemblyFromFile(cp, allSourceFilesArray); //cr = icc.CompileAssemblyFromFileBatch(cp, allSourceFilesArray); if (cr.Errors.Count > 0) { throw new Exception(); } else { return(true); } } catch { MessageBox.Show("Error Compiling C# recognize and apply source files.", "Compilation Error", MessageBoxButtons.OK, MessageBoxIcon.Error); foreach (CompilerError e in cr.Errors) { SearchIO.output(e.ToString(), 1); } return(false); } }
public CompilerResults Compile(string filePath) { var parameters = new CompilerParameters { GenerateInMemory = true, TreatWarningsAsErrors = false, GenerateExecutable = true, CompilerOptions = "/optimize" }; var codeProvider = new CSharpCodeProvider(); var compilerResults = codeProvider.CompileAssemblyFromFile(parameters, new[] { filePath }); compilerResults.PathToAssembly = @"C:\"; return(compilerResults); }
public CompilationResult Compile(BuildFiles buildFiles) { using (var codeDomProvider = new CSharpCodeProvider()) { var fileNames = buildFiles.AllClasses.Select(c => c.FullPath).ToArray(); var references = buildFiles.References .Select(reference => reference.FullPath) .ToArray(); var options = new CompilerParameters(); options.ReferencedAssemblies.AddRange(references); var result = codeDomProvider.CompileAssemblyFromFile(options, fileNames); var errors = result.Errors.Cast <CompilerError>().Select(error => error.ErrorText); return(new CompilationResult(errors, result.PathToAssembly)); } }
public CompilerResults Compile(CompilerParameters parameters, bool isFilePath, string Script) { bool complete = false; bool retried = false; CompilerResults results; do { lock (YPcodeProvider) { if (isFilePath) { results = YPcodeProvider.CompileAssemblyFromFile( parameters, Script); } else { results = YPcodeProvider.CompileAssemblyFromSource( parameters, Script); } } // Deal with an occasional segv in the compiler. // Rarely, if ever, occurs twice in succession. // Line # == 0 and no file name are indications that // this is a native stack trace rather than a normal // error log. if (results.Errors.Count > 0) { if (!retried && (results.Errors[0].FileName == null || results.Errors[0].FileName == String.Empty) && results.Errors[0].Line == 0) { // System.Console.WriteLine("retrying failed compilation"); retried = true; } else { complete = true; } } else { complete = true; } } while (!complete); return(results); }
public Assembly Generate(IAssemblySource assemblySource, CompilerParameters compilerParameters) { var stopwatch = Stopwatch.StartNew(); compilerParameters.ReferencedAssemblies.AddRange(assemblySource.RegisteredReferences.ToArray()); if (compilerParameters.WarningLevel == -1) { compilerParameters.WarningLevel = 4; } string sourceFile = null; CompilerResults results; if (compilerParameters.GenerateInMemory) { using (CSharpCodeProvider codeProvider = new CSharpCodeProvider()) results = codeProvider.CompileAssemblyFromSource(compilerParameters, assemblySource.GeneratedCode); } else { sourceFile = Path.GetFullPath(Path.ChangeExtension(compilerParameters.OutputAssembly, ".cs")); File.WriteAllText(sourceFile, assemblySource.GeneratedCode, Encoding.UTF8); using (CSharpCodeProvider codeProvider = new CSharpCodeProvider()) results = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFile); } _performanceLogger.Write(stopwatch, "CSharpCodeProvider.CompileAssemblyFromSource"); if (results.Errors.HasErrors) { throw new FrameworkException(ReportErrors(results, assemblySource.GeneratedCode, sourceFile)); } try { results.CompiledAssembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { throw new FrameworkException(CsUtility.ReportTypeLoadException(ex, "Error while compiling " + compilerParameters.OutputAssembly + "."), ex); } ReportWarnings(results, sourceFile); return(results.CompiledAssembly); }
/// <summary> /// Compiles a C# script as a string or from a file. If "LoadAssemblies" is true, this call will try /// to manually load each assembly so that it is truly available on execution. /// </summary> public static Assembly Compile(string codeOrFile, bool isCodeOrFile, IEnumerable <string> referencedAssemblies, List <string> outputErrors, bool loadAssemblies) { try { if (loadAssemblies) { foreach (var ra in referencedAssemblies) { try { Assembly.UnsafeLoadFrom(ra); } #pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body catch (Exception) #pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body { } } } var csc = new CSharpCodeProvider(new Dictionary <string, string> { { "CompilerVersion", "v4.0" } }); var parameters = new CompilerParameters(referencedAssemblies.ToArray()) { GenerateInMemory = false, //GenerateExecutable = false, TempFiles = new TempFileCollection(Path.GetTempPath(), true), IncludeDebugInformation = true, }; var results = isCodeOrFile ? csc.CompileAssemblyFromSource(parameters, codeOrFile) : csc.CompileAssemblyFromFile(parameters, codeOrFile); results.Errors.Cast <CompilerError>().ToList().ForEach(error => outputErrors.Add(error.ToString())); if (results.Errors.Count > 0) { return(null); } return(results.CompiledAssembly); } catch (Exception e) { outputErrors.Add(e.Message); return(null); } }
private ILoggerBuilderExtension[] CompileAndEvaluateExtensions(ProjectItem projectItem, IEnumerable <ProjectItem> referenceItems) { LogMessage($"Compiling possible logger builder extension file {projectItem?.Include ?? "in referenced dlls"}"); var extensions = new List <ILoggerBuilderExtension>(); try { var parameters = new CompilerParameters(); foreach (var referenceItem in referenceItems) { parameters.ReferencedAssemblies.Add(referenceItem.Name); } //parameters.ReferencedAssemblies.Add("System.dll"); parameters.GenerateExecutable = false; parameters.GenerateInMemory = true; parameters.IncludeDebugInformation = false; var cSharpCodeProvider = new CSharpCodeProvider(); //var cSharpCodeProvider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider(); var items = projectItem != null ? new string[] { projectItem.Name } : new string[0]; CompilerResults compilerResults; compilerResults = cSharpCodeProvider.CompileAssemblyFromFile(parameters, items); foreach (CompilerError compilerResultsError in compilerResults.Errors) { LogMessage(compilerResultsError.ToString()); } var types = compilerResults.CompiledAssembly.GetTypes(); foreach ( var type in types.Where(t => typeof(ILoggerBuilderExtension).IsAssignableFrom(t))) { var extension = (ILoggerBuilderExtension)Activator.CreateInstance(type); extensions.Add(extension); } } catch (Exception ex) { LogMessage($"Failed to compile/evaluate {projectItem.Include} - {ex.Message}\r\n{ex.StackTrace}"); } return(extensions.ToArray()); }
static void GetSpecializedTotalScore() { string label = Console.ReadLine(); CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerParameters para = new CompilerParameters(); para.ReferencedAssemblies.Add("System.dll"); para.ReferencedAssemblies.Add("System.Core.dll"); para.ReferencedAssemblies.Add("TaicaiLib.dll"); para.GenerateInMemory = true; para.GenerateExecutable = false; CompilerResults results = provider.CompileAssemblyFromFile(para, "total.cs"); if (results.Errors.Count > 0) { Console.WriteLine("Code Errors:"); foreach (CompilerError e in results.Errors) { Console.WriteLine("{0} line {1}: {2}", e.IsWarning ? "Warning" : "Error", e.Line, e.ErrorText); } if (results.Errors.HasErrors) { return; } } Assembly ass = results.CompiledAssembly; object theClass = ass.CreateInstance("Taicai" + label + ".TotalGenerator"); if (theClass == null) { Console.WriteLine("Taicai{0}.TotalGenerator needed", label); return; } Type totalGenerator = theClass.GetType(); var spec = userlist.Select(u => new { user = u, total = (double)totalGenerator.InvokeMember("GetSpecializedTotalScore", BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, null, null, new object[] { u }) }); foreach (var s in spec.OrderByDescending(x => x.total)) { Console.WriteLine(new KeyValuePair <string, double>(s.user.Name, s.total)); } }
/// <summary> /// Compile file /// </summary> /// <param name="filePath">CS file path</param> /// <returns></returns> static private Result <string> CompileCSFile(string filePath) { var result = new Result <string>(null, true); var file = new FileInfo(filePath); if (!file.Exists) { result.Success = false; result.Messages.Add(MessageType.Error, "Input file \"{0}\" does not exist", filePath); } if (result.Success) { try { var outputPath = Path.ChangeExtension(file.FullName, ".dll"); result.Entity = outputPath; var csc = new CSharpCodeProvider(new Dictionary <string, string>() { { "CompilerVersion", "v3.5" } }); var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.dll", "System.Xml.dll", "WindowsBase.dll", "System.Runtime.Serialization.dll" }, outputPath, true); parameters.GenerateExecutable = false; CompilerResults results = csc.CompileAssemblyFromFile(parameters, filePath); if (results.Errors.HasErrors) { result.Success = false; foreach (CompilerError error in results.Errors) { result.Messages.Add(MessageType.Error, error.ToString()); } } } catch (Exception ex) { result.Success = false; result.Messages.Add(MessageType.Error, "Exception", ex.ToString()); } } if (result.Messages.Count > 0) { Debug.WriteLine(result.Messages.ToString()); } return(result); }
private CompilerResults CompileAssemblies(CompilerParameters parameters, List <string> sources) { CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerResults results = provider.CompileAssemblyFromFile(parameters, sources.ToArray()); if (results.Errors.HasErrors) { foreach (var error in results.Errors) { Console.WriteLine(error); } throw new LoadException("Unable to load project. Please make sure it is compilable."); } return(results); }
protected bool Compile(string outFile, string[] sourceFiles, params string[] references) { CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.AddRange(references); cp.GenerateExecutable = false; cp.OutputAssembly = outFile; cp.GenerateInMemory = false; //生成调试文件 cp.IncludeDebugInformation = CompilerConfig.EnableDebug; try { CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFiles); if (cr.Errors.Count > 0) { if (OnCompileFailed != null) { CompileException exp = new CompileException(sourceFiles, cr.PathToAssembly, cr.Errors); OnCompileFailed(exp); } } else { if (OnCompileSuccess != null) { OnCompileSuccess(sourceFiles, outFile); } } return(cr.Errors.Count == 0); } catch (Exception e) { if (OnCompileFailed != null) { CompilerErrorCollection t = new CompilerErrorCollection(); t.Add(new CompilerError() { ErrorText = e.Message }); CompileException exp = new CompileException(sourceFiles, outFile, t); OnCompileFailed(exp); } return(false); } }
public static Dictionary<string, ReflectedScript> Compile(string[] files, string[] references, out string error) { // No Error Default error = null; // Compile CompilerParameters compParams = new CompilerParameters(references, null, false); compParams.CompilerOptions = "/optimize"; compParams.GenerateExecutable = false; compParams.GenerateInMemory = true; compParams.TreatWarningsAsErrors = false; #if DEBUG compParams.IncludeDebugInformation = true; #endif CompilerResults cr = compiler.CompileAssemblyFromFile(compParams, files); // Check For Errors if(cr.Errors.Count > 0) { error = ""; foreach(var e in cr.Errors) error += e + "\n"; return null; } // Dictionaries var res = new Dictionary<string, ReflectedScript>(); // Loop Through All Visible Types Assembly a = cr.CompiledAssembly; Type[] types = a.GetExportedTypes(); foreach(Type t in types) { ZXPProxy.Add(t); ZXParser.AddDynamicType(t.FullName, t); // We Don't Want Abstract Classes Or Interfaces if(t.IsAbstract || t.IsInterface) continue; // Check For The Superclass if(t.IsSubclassOf(typeof(ACScript))) { var rs = new ReflectedScript(t); res.Add(rs.TypeName, rs); } } return res; }
public static bool CompileCSharpCode(string fileName, List <string> neededAssemblies) { CSharpCodeProvider provider = new CSharpCodeProvider(); // Build the parameters for source compilation. CompilerParameters cp = new CompilerParameters(); if (neededAssemblies != null) { foreach (var item in neededAssemblies) { cp.ReferencedAssemblies.Add(item); } } // Set the assembly file name to generate. cp.OutputAssembly = fileName + ".dll"; // Save the assembly as a physical file. cp.GenerateInMemory = false; cp.GenerateExecutable = false; // Invoke compilation. CompilerResults cr = provider.CompileAssemblyFromFile(cp, fileName + ".cs"); if (cr.Errors.Count > 0) { // Display compilation errors. foreach (CompilerError ce in cr.Errors) { MessageBox.Show(ce.ToString()); } } // Return the results of compilation. if (cr.Errors.Count > 0) { return(false); } else { return(true); } }
internal static void testCompileFiles(List<string> files) { if (files.Count == 0) return; Dictionary<string, string> options = new Dictionary<string, string>(); options.Add("CompilerVersion", "v3.5"); CodeDomProvider codeProvider = new CSharpCodeProvider(options); CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo("cs"); CompilerParameters compilerParam = compilerInfo.CreateDefaultCompilerParameters(); compilerParam.TreatWarningsAsErrors = false; compilerParam.IncludeDebugInformation = true; compilerParam.GenerateInMemory = true; foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { compilerParam.ReferencedAssemblies.Add(assembly.Location); } catch { } } CompilerResults result = codeProvider.CompileAssemblyFromFile(compilerParam, files.ToArray()); List<CompilerError> errors = new List<CompilerError>(); foreach (CompilerError error in result.Errors) { errors.Add(error); } var criticalErrors = from err in errors where !err.IsWarning select err; if (criticalErrors.Count() > 0) { StringBuilder sb = new StringBuilder(); sb.AppendLine(criticalErrors.Count() + Local.Text("Web.WAF.Edit.ExplorerCriticalCompileError")); sb.AppendLine("<ol>"); foreach (CompilerError error in criticalErrors) { if (!error.IsWarning) { sb.Append("<li>" + error.ErrorText + ":"); if (error.FileName.Length > WAFContext.PathFromRootToAppFolder.Length) { sb.Append("<div style=\"color:gray\"> -> " + error.FileName.Substring(WAFContext.PathFromRootToAppFolder.Length) + "</div>"); } else { sb.Append("<div style=\"color:gray\"> -> " + error.FileName + "</div>"); } sb.Append("<div style=\"color:gray\"> -> Line " + error.Line + " Col " + error.Column + "</div>"); sb.Append("<br/><br/></li>"); } } sb.AppendLine("</ol>"); throw new Exception(sb.ToString()); } }
/// <summary> /// Build project with includeing <paramref name="referencedAssemblies"/>. /// </summary> /// <param name="referencedAssemblies">Assemblies to include.</param> /// <param name="files">Files to build.</param> /// <returns>Compile result string.</returns> private static string Build(string[] referencedAssemblies, string[] dlls = default(string[]), params string[] files) { CSharpCodeProvider compiler = new CSharpCodeProvider(); CompilerParameters parameters = GetCompilerParameters(referencedAssemblies, dlls); TempFileCollection tfc = new TempFileCollection(Assembly.GetEntryAssembly().Location, false); CompilerResults cr = new CompilerResults(tfc); files = ConcatFiles(files); if (files.Length == 0)//it means that we need to clear all files in the assembly (bc or modules is removed or if it's attribute to clear all files) { File.Delete(parameters.OutputAssembly); return("Assembly is clear."); } cr = compiler.CompileAssemblyFromFile(parameters, files); string compileResults = GetResultString(cr); return(compileResults); }
/// <summary> /// Just compiles source code and returns compilation result /// </summary> /// <param name="filePath"></param> /// <returns></returns> public static (CompilerResults CompilerResult, int CodeLine) Compile(string filePath) { CSharpCodeProvider cProv = new CSharpCodeProvider(); CompilerParameters cParams = new CompilerParameters(); cParams.ReferencedAssemblies.Add("mscorlib.dll"); cParams.ReferencedAssemblies.Add("System.dll"); cParams.ReferencedAssemblies.Add("System.Windows.Forms.dll"); cParams.ReferencedAssemblies.Add("System.Xml.dll"); cParams.GenerateExecutable = false; cParams.GenerateInMemory = true; cParams.IncludeDebugInformation = true; var lines = File.ReadAllLines(filePath).ToList(); var index = lines.FindIndex(line => line.Contains("public void UpdateText()")); return(cProv.CompileAssemblyFromFile(cParams, filePath), index + 2); }
static void loadFile(string fileName) { AppDomain domain = AppDomain.CurrentDomain; Assembly[] assemblies = domain.GetAssemblies(); string[] fileNames = Directory.GetFiles(srcDir, "*.cs", SearchOption.AllDirectories); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters(); parameters.GenerateInMemory = true; /* * IEnumerable<Assembly> filteredAssemblies = assemblies * .Where(a => !a.IsDynamic && !String.IsNullOrEmpty(a.Location)) * .Distinct(); * foreach(Assembly assembly in filteredAssemblies) { * Debug.Log("adding assembly: " + assembly.FullName); * parameters.ReferencedAssemblies.Add(assembly.Location); * } */ parameters.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(Noise)).Location); parameters.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(Mathf)).Location); Debug.Log("compiling files: " + string.Join(";", fileNames) + " " + fileNames.Length); CompilerResults results = codeProvider.CompileAssemblyFromFile(parameters, fileNames); Debug.Log("compiling finsihed"); if (results.Errors.Count > 0) { string error = ""; foreach (CompilerError CompErr in results.Errors) { error = "Line number " + CompErr.Line + ", Error Number: " + CompErr.ErrorNumber + ", '" + CompErr.ErrorText + ";" + Environment.NewLine + Environment.NewLine; } Debug.LogError(error); } currentAssembly = results.CompiledAssembly; listener(results.CompiledAssembly); }
public IsolatedCompiler(CompilingParameters parameters_) { parameters = parameters_; CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CompilerParameters exeparams = new CompilerParameters(); List <CompilerError> resourceErrors = new List <CompilerError>(); exeparams.GenerateExecutable = true; var dir = Directory.CreateDirectory(parameters.filePath); exeparams.OutputAssembly = Path.Combine(parameters.filePath, parameters.fileName); var processes = Process.GetProcessesByName(parameters.fileName.Substring(0, parameters.fileName.Length - 4)); if (processes.Length > 0) { processes.First().Kill(); } foreach (var dep in parameters.assemblyDeps) { File.Copy(Path.Combine(".", dep), Path.Combine(parameters.filePath, dep), true); exeparams.ReferencedAssemblies.Add(dep); } CompilerResults results = codeProvider.CompileAssemblyFromFile(exeparams, parameters.files.ToArray()); foreach (var error in results.Errors) { Debug.WriteLine(error); } if (results.Errors.Count > 0) { var errstr = ""; foreach (var error in results.Errors) { errstr += error + "\n"; } throw new Exception(String.Format("Compiler errors : \n{0}", errstr)); } CopyContentFiles(); CopyDLLs(exeparams, results); Task.Run(() => ZippingUp(exeparams, results)); }
/// <summary> /// Compiles the specified collection of C# Source files and returns the generated assembly. /// </summary> /// <param name="scripts">A collection of C# Source files to compile.</param> /// <returns>The assembly generated by the compiler.</returns> /// <exception cref="ArgumentNullException">The scripts parameter is null.</exception> static Assembly CompileScripts(IEnumerable <string> scripts) { scripts.ThrowIfNull(nameof(scripts)); using (var csProvider = new CSharpCodeProvider()) { var options = new CompilerParameters { GenerateExecutable = false, GenerateInMemory = true }; options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location); var result = csProvider.CompileAssemblyFromFile(options, scripts.ToArray()); if (result.Errors.HasErrors) { Print("Compilation of scenario scripts failed: ", ConsoleColor.Red); foreach (CompilerError error in result.Errors) { var s = string.Format("* {0}, Line {1}: {2}", Path.GetFileName(error.FileName), error.Line, error.ErrorText); Print(s); } return(null); } if (result.Errors.HasWarnings) { Print("Compilation of scenario scripts generated warnings: ", ConsoleColor.Yellow); foreach (CompilerError error in result.Errors) { if (!error.IsWarning) { continue; } var s = string.Format("* {0}, Line {1}: {2}", Path.GetFileName(error.FileName), error.Line, error.ErrorText); Print(s); } Print(""); Print("Continue execution? (Y/N)", ConsoleColor.Yellow); if (char.ToLower(ReadChar('Y', 'y', 'N', 'n')) == 'n') { return(null); } } return(result.CompiledAssembly); } }
public static Assembly compile() { // Shellcode loader would make more sense here, just make sure your code is located within the default constructor. string _testClass = @" using System; using System.Runtime.InteropServices; // public class TestClass // { // " + "[DllImport(\"User32.dll\", CharSet = CharSet.Unicode)]" + // @"public static extern int MessageBox(IntPtr h, string m, string c, int t); // public TestClass(){ // " + "MessageBox((IntPtr)0, \"Test .NET Assembly Constructor Called.\", \"Coolio\", 0);" + // @"} // } // "; CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerParameters parameters = new CompilerParameters(); parameters.ReferencedAssemblies.Add("System.dll"); // CompilerResults results = provider.CompileAssemblyFromSource(parameters, _testClass); CompilerResults results = provider.CompileAssemblyFromFile(parameters, "payload.txt"); if (results.Errors.HasErrors) { StringBuilder sb = new StringBuilder(); foreach (CompilerError error in results.Errors) { sb.AppendLine(String.Format("Error ({0}): {1}: {2}", error.ErrorNumber, error.ErrorText, error.Line)); } throw new InvalidOperationException(sb.ToString()); } Assembly _compiled = results.CompiledAssembly; return(_compiled); }
public static bool CompileAssemblyFromFiles(string outputPath, string outputAssemblyName, string[] files, CodeDomNamespace namesp) { CSharpCodeProvider provider = new CSharpCodeProvider(); // Build the parameters for source compilation. CompilerParameters cp = new CompilerParameters(); // Add an assembly reference. cp.ReferencedAssemblies.AddRange(namesp.GetAssemblyReferences()); // Set the assembly file name to generate. cp.OutputAssembly = Path.Combine(outputPath, $"{outputAssemblyName}.dll"); // Save the assembly as a physical file. cp.GenerateInMemory = false; // Invoke compilation. CompilerResults cr = provider.CompileAssemblyFromFile(cp, files); if (cr.Errors.Count > 0) { // Display compilation errors. Console.WriteLine("Errors building {0} into {1}", cp.OutputAssembly, cr.PathToAssembly); foreach (CompilerError ce in cr.Errors) { Console.WriteLine(" {0}", ce.ToString()); Console.WriteLine(); } } else { Console.WriteLine("Source {0} built into {1} successfully.", cp.OutputAssembly, cr.PathToAssembly); } // Return the results of compilation. if (cr.Errors.Count > 0) { return(false); } return(true); }
public static Assembly CreateFromCSFiles(string pathName, string appName, string dbAssebmly) { CSharpCodeProvider csCompiler = new CSharpCodeProvider(); CompilerParameters compilerParams = new CompilerParameters(); //compilerParams.GenerateInMemory = true; // here you must add all the references you need. // I don't know whether you know all of them, but you have to get them // someway, otherwise it can't work compilerParams.ReferencedAssemblies.Add("System.dll"); //compilerParams.ReferencedAssemblies.Add("System.Collections.dll"); compilerParams.ReferencedAssemblies.Add("System.Linq.dll"); compilerParams.ReferencedAssemblies.Add("System.Web.dll"); compilerParams.ReferencedAssemblies.Add("System.Data.dll"); compilerParams.ReferencedAssemblies.Add("System.Data.Entity.dll"); compilerParams.ReferencedAssemblies.Add("System.Data.Entity.Design.dll"); compilerParams.ReferencedAssemblies.Add(typeof(System.Web.Mvc.ActionResult).Assembly.Location); compilerParams.ReferencedAssemblies.Add(typeof(System.Web.Optimization.Bundle).Assembly.Location); compilerParams.ReferencedAssemblies.Add(typeof(System.Data.Entity.DbContext).Assembly.Location); compilerParams.ReferencedAssemblies.Add(typeof(System.Linq.Enumerable).Assembly.Location); ArrayList files = filePaths(pathName); string[] csPaths = new string[files.Count]; for (int i = 0; i < csPaths.Length; i++) { csPaths[i] = (string)files[i]; } compilerParams.OutputAssembly = pathName + "\\bin\\" + appName + ".dll"; CompilerResults result = csCompiler.CompileAssemblyFromFile(compilerParams, csPaths); if (result.Errors.HasErrors) { return(null); } File.Delete(pathName + "\\Global.asax.cs"); return(result.CompiledAssembly); }
public CompilerResults CreateDLL(bool explicitFiles = false) { if (TestIfCannotOverwriteDll(FinalDllOutputPath)) { Debug.LogError((object)("Cannot build DLL, existing DLL is not overwritable, locked. DLL: " + FinalDllOutputPath)); return(null); } HashSet <string> allSourceDirectories = GetAllSourceDirectories(); if (allSourceDirectories.Count == 0 && (sourceFilePaths == null || sourceFilePaths.Count == 0)) { Debug.LogError((object)("Cannot build DLL, no source directories to compile for DLL:" + FinalDllOutputPath)); return(null); } if (File.Exists(TempDllOutputPath)) { FileUtil.DeleteFileOrDirectory(TempDllOutputPath); } if (!Directory.Exists(TempBuildDir)) { Directory.CreateDirectory(TempBuildDir); } DeleteSuperflousExtensions(FinalDllOutputPath); CompilerParameters standardCompilerParameters = GetStandardCompilerParameters(TempDllOutputPath); AddDllDependenciesToReferencedAssemblies(standardCompilerParameters); Dictionary <string, string> dictionary = new Dictionary <string, string>(); dictionary.Add("CompilerVersion", "v3.5"); CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider(dictionary); CompilerResults compilerResults = (!explicitFiles) ? cSharpCodeProvider.CompileAssemblyFromFile(standardCompilerParameters, allSourceDirectories.ToArray()) : cSharpCodeProvider.CompileAssemblyFromFile(standardCompilerParameters, sourceFilePaths.ToArray()); LogCompileResults(compilerResults); if (!compilerResults.Errors.HasErrors) { string directoryName = Path.GetDirectoryName(FinalDllOutputPath); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } File.Copy(compilerResults.PathToAssembly, FinalDllOutputPath, overwrite: true); } return(compilerResults); }
public static CompilerResults CompileDirectories(DirectoryInfo[] directories, string assemblyFileName, string[] referenceAssemblies, bool executable) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CompilerParameters parameters = GetCompilerParameters(assemblyFileName, referenceAssemblies, executable); List <string> fileNames = new List <string>(); foreach (DirectoryInfo directory in directories) { foreach (FileInfo fileInfo in directory.GetFiles("*.cs", SearchOption.AllDirectories)) { if (!fileNames.Contains(fileInfo.FullName)) { fileNames.Add(fileInfo.FullName); } } } return(codeProvider.CompileAssemblyFromFile(parameters, fileNames.ToArray())); }
static void ExtractAndCompile(string sourceFile) { string assemblyName = Path.ChangeExtension(sourceFile, ".dll"); ExtractResource("RoundtripTests.TestData.source." + sourceFile, sourceFile); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateExecutable = Path.GetExtension(assemblyName) == ".exe"; parameters.IncludeDebugInformation = true; parameters.OutputAssembly = assemblyName; string tempFile = Path.GetRandomFileName(); File.Move(sourceFile, Path.Combine(Path.GetDirectoryName(sourceFile), tempFile)); CompilerResults results; using (CodeDomProvider icc = new CSharpCodeProvider()) { results = icc.CompileAssemblyFromFile(parameters, tempFile); } File.Delete(tempFile); foreach (var s in results.Errors) { Debug.WriteLine(s); } Assert.Equal(0, results.Errors.Count); Assert.True(File.Exists(assemblyName), string.Format("Failed to compile {0} from {1}", assemblyName, sourceFile)); }
public override IEnumerator Execute(UTContext context) { var realIncludes = EvaluateAll (includes, context); var realExcludes = EvaluateAll (excludes, context); var theBaseDirectory = baseDirectory != null ? baseDirectory.EvaluateIn(context) : null; if (string.IsNullOrEmpty(theBaseDirectory)) { theBaseDirectory = Application.dataPath; } if (!Directory.Exists(theBaseDirectory)) { throw new UTFailBuildException("The base directory " + theBaseDirectory + " does not exist or is not a directory", this); } var fileList = UTFileUtils.CalculateFileset (theBaseDirectory, realIncludes, realExcludes, UTFileUtils.FileSelectionMode.Files); if (fileList.Length == 0) { throw new UTFailBuildException ("No files were selected for build. Please check includes and excludes.", this); } var realOutputFile = outputFile.EvaluateIn (context); if (!realOutputFile.EndsWith (".dll")) { if (UTPreferences.DebugMode) { Debug.LogWarning("The output file does not end with .dll. The built DLL will not be picked up by Unity."); } } UTFileUtils.EnsureParentFolderExists (realOutputFile); if (UTPreferences.DebugMode) { foreach (var file in fileList) { Debug.Log ("Compiling " + file); } } else { Debug.Log ("Compiling " + fileList.Length + " files."); } var compiler = new CSharpCodeProvider (); CompilerParameters parameters = new CompilerParameters (); var doIncludeEngineDll = true; if (includeEngineDll != null) { // can happen when we migrate older automation plans which didn't have this setting. doIncludeEngineDll = includeEngineDll.EvaluateIn(context); } if (doIncludeEngineDll) { parameters.ReferencedAssemblies.Add (UnityDll ()); } if (includeEditorDll.EvaluateIn (context)) { parameters.ReferencedAssemblies.Add (UnitEditorDll ()); } var realAssemblies = EvaluateAll (referencedAssemblies, context); foreach (var asm in realAssemblies) { parameters.ReferencedAssemblies.Add (asm); } parameters.GenerateExecutable = false; parameters.OutputAssembly = realOutputFile; var theSymbols = defineSymbols.EvaluateIn(context); if (!string.IsNullOrEmpty(theSymbols)) { parameters.CompilerOptions = "/define:"+theSymbols.Trim(); } var theAdditionalOptions = additionalCompilerOptions.EvaluateIn(context); if (!string.IsNullOrEmpty(theAdditionalOptions)) { parameters.CompilerOptions += " " + theAdditionalOptions.Trim(); } SetPath (); CompilerResults results = compiler.CompileAssemblyFromFile (parameters, fileList); if (UTPreferences.DebugMode) { var output = results.Output; foreach (var line in output) { Debug.Log (line); } } var errors = results.Errors; var hadErrors = false; foreach (CompilerError error in errors) { if (error.IsWarning) { Debug.LogWarning (error.ToString ()); } else { hadErrors = true; Debug.LogError (error.ToString ()); // TODO link errors to file. } } if (hadErrors) { throw new UTFailBuildException ("There were compilation errors.", this); } Debug.Log ("Built " + realOutputFile + " from " + fileList.Length + " source file(s)."); yield return ""; }
public static unsafe int Main(string[] args) { string baseDirectory = AppDomain.CurrentDomain.BaseDirectory; string pluginDirectory; if (baseDirectory.EndsWith("bin")) { // Windows pluginDirectory = Path.GetFullPath(Path.Combine(baseDirectory, "..\\lib\\plugins")); } else { // *nix pluginDirectory = Path.Combine(baseDirectory, "plugins"); } List<string> codeFiles = new List<string>(); List<CodeCompileUnit> codeSnippets = new List<CodeCompileUnit>(); List<Assembly> references = new List<Assembly>(); List<string> imports = new List<string>(); StringBuilder compilerOptions = new StringBuilder(); bool codeOnly = false; string codeFile = string.Empty; string assemblyFile = "out.dll"; int warnLevel = 0; string smokeLib = null; string defaultNamespace = "Qyoto"; string globalClass = "Global"; string destination = string.Empty; string docs = string.Empty; List<Assembly> plugins = new List<Assembly>(); foreach (string arg in args) { if (arg == "-help" || arg == "--help" || arg == "-h") { PrintHelp(); return 0; } if (arg == "-verbose") { Debug.Listeners.Add(new ConsoleTraceListener(true)); continue; } if (arg == "-code-only") { codeOnly = true; continue; } if (arg.StartsWith("-code-file:")) { codeFile = arg.Substring(11); continue; } if (arg.StartsWith("-out:")) { assemblyFile = arg.Substring(5); continue; } if (arg.StartsWith("-warn:")) { warnLevel = int.Parse(arg.Substring(6)); continue; } if (arg.StartsWith("-r:")) { references.Add(Assembly.LoadFrom(arg.Substring(3))); continue; } if (arg.StartsWith("-reference:")) { references.Add(Assembly.LoadFrom(arg.Substring(11))); continue; } if (arg.StartsWith("-global-class:")) { globalClass = arg.Substring(14); continue; } if (arg.StartsWith("-namespace:")) { defaultNamespace = arg.Substring(11); continue; } if (arg.StartsWith("-dest:")) { destination = arg.Substring("-dest:".Length); continue; } if (arg.StartsWith("-import:")) { imports.AddRange(arg.Substring(8).Split(',')); continue; } if (arg.StartsWith("-docs:")) { docs = arg.Substring("-docs:".Length); continue; } if (arg.StartsWith("-plugins:")) { foreach (string str in arg.Substring(9).Split(',')) { Assembly a; try { a = Assembly.LoadFrom(str); } catch (FileNotFoundException) { a = Assembly.LoadFrom(Path.Combine(pluginDirectory, str)); } plugins.Add(a); } continue; } if (arg.StartsWith("-")) { compilerOptions.Append(" /"); compilerOptions.Append(arg.Substring(1)); continue; } if (smokeLib == null) { smokeLib = arg; continue; } codeFiles.Add(arg); FileStream fs = new FileStream(arg, FileMode.Open); StreamReader sr = new StreamReader(fs); codeSnippets.Add(new CodeSnippetCompileUnit(sr.ReadToEnd())); sr.Close(); fs.Close(); } if (!string.IsNullOrEmpty(docs)) { compilerOptions.Append(" /doc:" + Path.ChangeExtension(Path.GetFileName(assemblyFile), ".xml")); } compilerOptions.Append(" -debug"); if (smokeLib == null) { PrintHelp(); return 1; } Smoke* smoke = InitSmoke(smokeLib); if (smoke == (Smoke*) 0) { return SmokeLoadingFailure; } List<ICustomTranslator> customTranslators = (from plugin in plugins from type in plugin.GetTypes() from iface in type.GetInterfaces() where iface == typeof(ICustomTranslator) select (ICustomTranslator) Activator.CreateInstance(type)).ToList(); GeneratorData data = new GeneratorData(smoke, defaultNamespace, imports, references, destination, docs); data.GlobalSpaceClassName = globalClass; Translator translator = new Translator(data, customTranslators); foreach (IHookProvider provider in from type in plugins.SelectMany(plugin => plugin.GetTypes()) where type.GetInterfaces().Any(iface => iface == typeof(IHookProvider)) select (IHookProvider) Activator.CreateInstance(type)) { provider.Translator = translator; provider.Data = data; provider.RegisterHooks(); } ClassesGenerator classgen = new ClassesGenerator(data, translator); Console.Error.WriteLine("Generating CodeCompileUnit..."); classgen.Run(); DestroySmoke((IntPtr) smoke); Dictionary<string, string> providerOptions = new Dictionary<string, string>(); providerOptions.Add("CompilerVersion", "v4.0"); CodeDomProvider csharp = new CSharpCodeProvider(providerOptions); if (codeFile != string.Empty) { FileStream fs = new FileStream(codeFile, FileMode.Create); StreamWriter sw = new StreamWriter(fs); Console.Error.WriteLine("Generating code..."); CodeGeneratorOptions cgo = new CodeGeneratorOptions(); csharp.GenerateCodeFromCompileUnit(data.CompileUnit, sw, cgo); sw.Close(); fs.Close(); codeFiles.Add(codeFile); } if (codeOnly) { if (codeFile == string.Empty) { Console.Error.WriteLine("Missing output filename. Use the -code-file:<file> option."); return MissingOptionError; } return NoError; } codeSnippets.Add(data.CompileUnit); Console.Error.WriteLine("Compiling assembly..."); CompilerParameters cp = new CompilerParameters(); cp.GenerateExecutable = false; cp.TreatWarningsAsErrors = false; cp.OutputAssembly = assemblyFile; cp.GenerateInMemory = false; cp.WarningLevel = warnLevel; cp.CompilerOptions = compilerOptions.ToString(); cp.ReferencedAssemblies.Add(typeof(Regex).Assembly.Location); cp.ReferencedAssemblies.Add(typeof(ExtensionAttribute).Assembly.Location); foreach (Assembly assembly in references) { cp.ReferencedAssemblies.Add(assembly.Location); } CompilerResults cr; if(codeFile == null) { cr = csharp.CompileAssemblyFromDom(cp, codeSnippets.ToArray()); } else { cr = csharp.CompileAssemblyFromFile(cp, codeFiles.ToArray()); } bool errorsOccured = false; foreach (CompilerError error in cr.Errors) { if (!error.IsWarning) errorsOccured = true; Console.Error.WriteLine(error); } if (errorsOccured) { Console.Error.WriteLine("Errors occured. No assembly was generated."); return CompilationError; } Console.Error.WriteLine("Done."); return NoError; }