static void DisplayCompilerInfoForLanguage(string language) { CodeDomProvider provider; // Check for a provider corresponding to the input language. if (CodeDomProvider.IsDefinedLanguage(language)) { provider = CodeDomProvider.CreateProvider(language); // Display information about this language provider. Console.WriteLine("Language provider: {0}", provider.ToString()); Console.WriteLine(); Console.WriteLine(" Default file extension: {0}", provider.FileExtension); Console.WriteLine(); // Get the compiler settings for this language. CompilerInfo langCompilerInfo = CodeDomProvider.GetCompilerInfo(language); CompilerParameters langCompilerConfig = langCompilerInfo.CreateDefaultCompilerParameters(); Console.WriteLine(" Compiler options: {0}", langCompilerConfig.CompilerOptions); Console.WriteLine(" Compiler warning level: {0}", langCompilerConfig.WarningLevel); } else { // Tell the user that the language provider was not found. Console.WriteLine("There is no provider configured for input language \"{0}\".", language); } }
private async void GenerateTypeFile(string filePath, CodeCompileUnit targetUnit) { await Task.Run(() => { if (!CodeDomProvider.IsDefinedLanguage(LocalizationEditorData.CodeDomProviderLanguage)) { throw new Exception($"{LocalizationEditorData.CodeDomProviderLanguage} is not a valid language!"); } var codeDomProvider = CodeDomProvider.CreateProvider(LocalizationEditorData.CodeDomProviderLanguage); var codeGeneratorOptions = new CodeGeneratorOptions { BracingStyle = LocalizationEditorData.CodeGeneratorOptionsBracingStyle, BlankLinesBetweenMembers = false }; using (var streamWriter = new StreamWriter(filePath)) { codeDomProvider.GenerateCodeFromCompileUnit(targetUnit, streamWriter, codeGeneratorOptions); } codeDomProvider.Dispose(); }); }
internal CompilerType GetCompilerInfoFromLanguage(string language) { CompilerType compilerTypeInternal; this.EnsureCompilerCacheInit(); object obj2 = this._compilerLanguages[language]; Compiler compiler = obj2 as Compiler; if (compiler != null) { compilerTypeInternal = compiler.CompilerTypeInternal; this._compilerLanguages[language] = compilerTypeInternal; } else { compilerTypeInternal = obj2 as CompilerType; } if ((compilerTypeInternal == null) && CodeDomProvider.IsDefinedLanguage(language)) { CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(language); compilerTypeInternal = new CompilerType(compilerInfo.CodeDomProviderType, compilerInfo.CreateDefaultCompilerParameters()); this._compilerLanguages[language] = compilerTypeInternal; } if (compilerTypeInternal == null) { throw new HttpException(System.Web.SR.GetString("Invalid_lang", new object[] { language })); } CompilationUtil.CheckCompilerOptionsAllowed(compilerTypeInternal.CompilerParameters.CompilerOptions, true, null, 0); compilerTypeInternal = compilerTypeInternal.Clone(); compilerTypeInternal.CompilerParameters.IncludeDebugInformation = this.Debug; return(compilerTypeInternal); }
public override bool Execute() { if (CodeDomProvider.IsDefinedLanguage(this.CodeLanguage)) { using (var codeDomProvider = CodeDomProvider.CreateProvider(this.CodeLanguage)) { this.generatedFile = new CodeCompileUnit(); this.generatedFile.AssemblyCustomAttributes.AddRange(this.CreateAssemblyAttributes().ToArray()); var ns = new CodeNamespace(); this.generatedFile.Namespaces.Add(ns); ns.Types.Add(this.CreateThisAssemblyClass()); Directory.CreateDirectory(Path.GetDirectoryName(this.OutputFile)); using (var file = File.OpenWrite(this.OutputFile)) { using (var fileWriter = new StreamWriter(file, new UTF8Encoding(true), 4096, leaveOpen: true)) { codeDomProvider.GenerateCodeFromCompileUnit(this.generatedFile, fileWriter, codeGeneratorOptions); } // truncate to new size. file.SetLength(file.Position); } } } else { this.Log.LogError("CodeDomProvider not available for language: {0}. No version info will be embedded into assembly.", this.CodeLanguage); } return(!this.Log.HasLoggedErrors); }
static void Main() { CodeDomProvider provider = null; String exeName = "HelloWorld.exe"; Console.WriteLine("Enter the source language for Hello World (cs, vb, etc):"); String inputLang = Console.ReadLine(); Console.WriteLine(); if (CodeDomProvider.IsDefinedLanguage(inputLang)) { provider = CodeDomProvider.CreateProvider(inputLang); } if (provider == null) { Console.WriteLine("There is no CodeDomProvider for the input language."); } else { CodeCompileUnit helloWorld = BuildHelloWorldGraph(); String sourceFile = GenerateCode(provider, helloWorld); Console.WriteLine("HelloWorld source code generated."); if (CompileCode(provider, sourceFile, exeName)) { Console.WriteLine("Starting HelloWorld executable."); Process.Start(exeName); } } }
private void SupportedLanguages() { CompilerInfo[] aCompilerInfo = CodeDomProvider.GetAllCompilerInfo(); foreach (CompilerInfo oCompilerInfo in aCompilerInfo) { foreach (string szLanguage in oCompilerInfo.GetLanguages()) { MessageBox.Show(szLanguage); } } if (!CodeDomProvider.IsDefinedLanguage("GW-BASIC")) { MessageBox.Show("GW-BASIC Not supported"); } if (!CodeDomProvider.IsDefinedLanguage("CSharp")) { MessageBox.Show("CSharp Not supported"); } if (!CodeDomProvider.IsDefinedExtension(".BAS")) { MessageBox.Show(".BAS Not supported"); } if (!CodeDomProvider.IsDefinedExtension(".cs")) { MessageBox.Show(".cs Not supported"); } }
private Boolean __CreateProvider(ProgrammingLanguages programmingLanguage, ref CodeDomProvider provider) { Boolean hasTheProvider = new Boolean(); String language = programmingLanguage.ToString(); switch (programmingLanguage) { case ProgrammingLanguages.CSharp: hasTheProvider = CodeDomProvider.IsDefinedLanguage(language); break; case ProgrammingLanguages.VisualBasic: hasTheProvider = CodeDomProvider.IsDefinedLanguage(language); break; default: /* C# Programming Language. */ language = "C#"; hasTheProvider = !hasTheProvider; break; } ; provider = CodeDomProvider.CreateProvider(language); return(hasTheProvider); }
private void Initialize(string language) { if (!CodeDomProvider.IsDefinedLanguage(language)) { throw new InvalidOperationException(Resources.IdentifierValidatorUnknownLanguage); } provider = CodeDomProvider.CreateProvider(language); }
public static void CompileSourceFiles(string language, string assemblyPath, string[] sourceFiles, string[] managedPlugins) { if (!CodeDomProvider.IsDefinedLanguage(language)) { throw new NotSupportedException(string.Format("Unable to compile source files because the language \"{0}\" is not supported!", language)); } using (var provider = CodeDomProvider.CreateProvider(language)) { var compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; #if RELEASE compilerParameters.GenerateInMemory = true; compilerParameters.IncludeDebugInformation = false; compilerParameters.CompilerOptions = "/optimize"; #else // Necessary for stack trace line numbers etc. IncludeDebugInformation can be false as long as /debug is in the CompilerOptions compilerParameters.IncludeDebugInformation = false; compilerParameters.CompilerOptions = "/optimize /debug:portable"; compilerParameters.GenerateInMemory = false; #endif if (!compilerParameters.GenerateInMemory) { Directory.CreateDirectory(Path.GetDirectoryName(assemblyPath)); compilerParameters.OutputAssembly = Path.Combine(assemblyPath); } AddReferencedAssembliesForSourceFiles(managedPlugins, ref compilerParameters); var results = provider.CompileAssemblyFromFile(compilerParameters, sourceFiles); if (!results.Errors.HasErrors) { return; } string compilationError = string.Format("Compilation failed; {0} errors: ", results.Errors.Count); foreach (CompilerError error in results.Errors) { compilationError += Environment.NewLine; if (!error.ErrorText.Contains("(Location of the symbol related to previous error)")) { compilationError += string.Format("{0}({1},{2}): {3} {4}: {5}", error.FileName, error.Line, error.Column, error.IsWarning ? "warning" : "error", error.ErrorNumber, error.ErrorText); } else { compilationError += " " + error.ErrorText; } } throw new CompilationFailedException(compilationError); } }
public static CodeDomProvider GenerateCodeDomProvider(ProjectLanguage projectLanguage) { if (projectLanguage == null) { throw new ArgumentNullException("projectLanguage"); } if (!CodeDomProvider.IsDefinedLanguage(projectLanguage.ToString())) { throw new InvalidOperationException("The project language is not supported."); } return(CodeDomProvider.CreateProvider(projectLanguage.ToString())); }
/* * Return a CompilerType that a language maps to. */ internal CompilerType GetCompilerInfoFromLanguage(string language) { EnsureCompilerCacheInit(); // First, try the cache (i.e. old <compilers> section) CompilerType compilerType; object obj = _compilerLanguages[language]; Compiler compiler = obj as Compiler; if (compiler != null) { compilerType = compiler.CompilerTypeInternal; _compilerLanguages[language] = compilerType; } else { compilerType = obj as CompilerType; } if (compilerType == null) { // Try the <codedom> section if (CodeDomProvider.IsDefinedLanguage(language)) { CompilerInfo ci = CodeDomProvider.GetCompilerInfo(language); compilerType = new CompilerType(ci.CodeDomProviderType, ci.CreateDefaultCompilerParameters()); // Cache it _compilerLanguages[language] = compilerType; } } if (compilerType == null) { // Unsupported language: throw an exception throw new HttpException(SR.GetString(SR.Invalid_lang, language)); } // Only allow the use of compilerOptions when we have UnmanagedCode access (ASURT 73678) CompilationUtil.CheckCompilerOptionsAllowed(compilerType.CompilerParameters.CompilerOptions, true /*config*/, null, 0); // Clone it so the original is not modified compilerType = compilerType.Clone(); // Set the value of the debug flag in the copy compilerType.CompilerParameters.IncludeDebugInformation = Debug; return(compilerType); }
public static CodeDomProvider GenerateCodeDomProvider(ProjectLanguage projectLanguage) { if (projectLanguage == null) { throw new ArgumentNullException("projectLanguage"); } if (!CodeDomProvider.IsDefinedLanguage(projectLanguage.ToString())) { throw new InvalidOperationException(Resources.ScaffoldLanguageNotSupported); } return(CodeDomProvider.CreateProvider(projectLanguage.ToString())); }
static void DisplayCompilerInfoUsingExtension(string fileExtension) { // <Snippet5> if (fileExtension[0] != '.') { fileExtension = "." + fileExtension; } // Get the language associated with the file extension. if (CodeDomProvider.IsDefinedExtension(fileExtension)) { CodeDomProvider provider; String language = CodeDomProvider.GetLanguageFromExtension(fileExtension); Console.WriteLine("The language \"{0}\" is associated with file extension \"{1}\"", language, fileExtension); Console.WriteLine(); // Next, check for a corresponding language provider. if (CodeDomProvider.IsDefinedLanguage(language)) { provider = CodeDomProvider.CreateProvider(language); // Display information about this language provider. Console.WriteLine("Language provider: {0}", provider.ToString()); Console.WriteLine(); // Get the compiler settings for this language. CompilerInfo langCompilerInfo = CodeDomProvider.GetCompilerInfo(language); CompilerParameters langCompilerConfig = langCompilerInfo.CreateDefaultCompilerParameters(); Console.WriteLine(" Compiler options: {0}", langCompilerConfig.CompilerOptions); Console.WriteLine(" Compiler warning level: {0}", langCompilerConfig.WarningLevel); } } else { // Tell the user that the language provider was not found. Console.WriteLine("There is no language provider associated with input file extension \"{0}\".", fileExtension); } // </Snippet5> }
private static void CreateCodeProvider(string language, ref CodeDomProvider codeProvider, ref string fileExtension) { if (CodeDomProvider.IsDefinedLanguage(language)) { try { codeProvider = CodeDomProvider.CreateProvider(language); } catch (Exception ex) { throw new ArgumentException("Invalid language of " + language, ex); } } else { Type type = Type.GetType(language, false, true); if (type == null) { throw new ArgumentException("Invalid language of " + language); } object obj2 = Activator.CreateInstance(type); codeProvider = obj2 as CodeDomProvider; if (codeProvider == null) { throw new ArgumentException("Invalid language of " + language); } } if (codeProvider != null) { fileExtension = codeProvider.FileExtension; if (fileExtension == null) { fileExtension = string.Empty; return; } if ((fileExtension.Length > 0) && (fileExtension[0] != '.')) { fileExtension = "." + fileExtension; return; } } else { fileExtension = ".src"; } }
public override bool Execute() { // attempt to use local codegen string fileContent = this.BuildCode(); if (fileContent != null) { Directory.CreateDirectory(Path.GetDirectoryName(this.OutputFile)); Utilities.FileOperationWithRetry(() => File.WriteAllText(this.OutputFile, fileContent)); } else if (CodeDomProvider.IsDefinedLanguage(this.CodeLanguage)) { using (var codeDomProvider = CodeDomProvider.CreateProvider(this.CodeLanguage)) { this.generatedFile = new CodeCompileUnit(); this.generatedFile.AssemblyCustomAttributes.AddRange(this.CreateAssemblyAttributes().ToArray()); var ns = new CodeNamespace(); this.generatedFile.Namespaces.Add(ns); if (this.EmitThisAssemblyClass) { ns.Types.Add(this.CreateThisAssemblyClass()); } Directory.CreateDirectory(Path.GetDirectoryName(this.OutputFile)); FileStream file = null; Utilities.FileOperationWithRetry(() => file = File.OpenWrite(this.OutputFile)); using (file) { using (var fileWriter = new StreamWriter(file, new UTF8Encoding(true), 4096, leaveOpen: true)) { codeDomProvider.GenerateCodeFromCompileUnit(this.generatedFile, fileWriter, codeGeneratorOptions); } // truncate to new size. file.SetLength(file.Position); } } } else { this.Log.LogError("CodeDomProvider not available for language: {0}. No version info will be embedded into assembly.", this.CodeLanguage); } return(!this.Log.HasLoggedErrors); }
static void Main() { CodeDomProvider provider = null; String exeName = "DocProp.exe"; Console.WriteLine("Enter the source language for DocumentProperties class (cs, vb, etc):"); String inputLang = Console.ReadLine(); Console.WriteLine(); if (CodeDomProvider.IsDefinedLanguage(inputLang)) { provider = CodeDomProvider.CreateProvider(inputLang); } if (provider == null) { Console.WriteLine("There is no CodeDomProvider for the input language."); } else { CodeCompileUnit docPropertyUnit = DocumentPropertyGraphBase(); DocumentPropertyGraphExpand(ref docPropertyUnit); String sourceFile = GenerateCode(provider, docPropertyUnit); if (!String.IsNullOrEmpty(sourceFile)) { Console.WriteLine("Document property class code generated."); if (CompileCode(provider, sourceFile, exeName)) { Console.WriteLine("Starting DocProp executable."); Process.Start(exeName); } } else { Console.WriteLine("Could not generate source file."); Console.WriteLine( "Target language code generator might not support partial type declarations."); } } }
public AppResourcesAssemblyBuilder(string canonicAssemblyName, string baseAssemblyPath, AppResourcesCompiler appres) { this.appResourcesCompiler = appres; this.baseAssemblyPath = baseAssemblyPath; this.baseAssemblyDirectory = Path.GetDirectoryName(baseAssemblyPath); this.canonicAssemblyName = canonicAssemblyName; config = WebConfigurationManager.GetWebApplicationSection("system.web/compilation") as CompilationSection; if (config == null || !CodeDomProvider.IsDefinedLanguage(config.DefaultLanguage)) { throw new ApplicationException("Could not get the default compiler."); } ci = CodeDomProvider.GetCompilerInfo(config.DefaultLanguage); if (ci == null || !ci.IsCodeDomProviderTypeValid) { throw new ApplicationException("Failed to obtain the default compiler information."); } }
public List <string> Compile() { string language = "CSharp"; if (CodeDomProvider.IsDefinedLanguage(language)) { CSharpCodeProvider codeProvider = (CSharpCodeProvider)CodeDomProvider.CreateProvider(language); rtbCompileResult.Text = ""; System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters(); parameters.GenerateExecutable = false; parameters.GenerateInMemory = true; foreach (string assemblyName in lbReferences.Items) { parameters.ReferencedAssemblies.Add(assemblyName); } List <string> errors = new List <string>(); CompilerResults results = null; try { results = codeProvider.CompileAssemblyFromSource(parameters, CSharpCodeInformation.CompleteCode); } catch (Exception ex) { errors.Add(ex.ToString()); } if (results != null) { foreach (CompilerError CompErr in results.Errors) { errors.Add("Line number " + CompErr.Line + ", Error Number: " + CompErr.ErrorNumber + ", '" + CompErr.ErrorText + ";"); } } return(errors); } return(new List <string>()); }
public void Defaults() { cdp = new CodeDomProviderTest(); // execute ctor not a full trust Assert.AreEqual(String.Empty, cdp.FileExtension, "FileExtension"); Assert.AreEqual(LanguageOptions.None, cdp.LanguageOptions, "LanguageOptions"); Assert.IsNull(cdp.CreateCompiler(), "CreateCompiler"); Assert.IsNull(cdp.CreateGenerator(), "CreateGenerator"); Assert.IsNull(cdp.CreateGenerator(String.Empty), "CreateGenerator(string)"); Assert.IsNull(cdp.CreateGenerator(writer), "CreateGenerator(TextWriter)"); Assert.IsNull(cdp.CreateParser(), "CreateParser()"); Assert.IsNotNull(cdp.GetConverter(typeof(string)), "GetConverter"); Assert.IsNotNull(CodeDomProvider.GetAllCompilerInfo(), "GetAllCompilerInfo"); // mono returns null (missing config?) CodeDomProvider.GetCompilerInfo("cs"); CodeDomProvider.GetLanguageFromExtension("cs"); Assert.IsFalse(CodeDomProvider.IsDefinedExtension(String.Empty), "String.Empty"); Assert.IsFalse(CodeDomProvider.IsDefinedLanguage(String.Empty), "String.Empty"); }
private Assembly BuildAssembly(string code) { CodeDomProvider provider; if (CodeDomProvider.IsDefinedLanguage(language)) { provider = CodeDomProvider.CreateProvider(language); var options = new Dictionary <string, string> { { "CompilerVersion", "v" + netVersion } }; CSharpCodeProvider codeProvider = new CSharpCodeProvider(options); CompilerParameters compilerparams = new CompilerParameters(); compilerparams.GenerateExecutable = false; compilerparams.GenerateInMemory = true; foreach (var Ref in Refs) { compilerparams.ReferencedAssemblies.Add(Ref); } CompilerResults results = provider.CompileAssemblyFromSource(compilerparams, code); if (results.Errors.HasErrors) { StringBuilder errors = new StringBuilder("xCracker Compiler Errors :\r\n"); foreach (CompilerError error in results.Errors) { errors.AppendFormat("Line {0},{1}\t: {2}\n", error.Line, error.Column, error.ErrorText); } throw new Exception(errors.ToString()); } else { return(results.CompiledAssembly); } } else { throw new Exception("Something went wrong with the compiler (Unknown Language Provided?)"); } }
private Assembly compile(string language, string code, bool inMemory, string outFileName) { if (CodeDomProvider.IsDefinedLanguage(language)) { using (CodeDomProvider provider = CodeDomProvider.CreateProvider(language)) { CompilerInfo langCompilerInfo = CodeDomProvider.GetCompilerInfo(language); CompilerParameters langCompilerConfig = langCompilerInfo.CreateDefaultCompilerParameters(); Assembly self = Assembly.GetExecutingAssembly(); string dir = Path.GetDirectoryName(self.Location); langCompilerConfig.GenerateInMemory = inMemory; if (!inMemory) { langCompilerConfig.OutputAssembly = outFileName; } langCompilerConfig.GenerateExecutable = false; langCompilerConfig.ReferencedAssemblies.Clear(); langCompilerConfig.ReferencedAssemblies.Add("System.dll"); langCompilerConfig.ReferencedAssemblies.Add("System.Data.dll"); langCompilerConfig.ReferencedAssemblies.Add("System.Xml.dll"); langCompilerConfig.ReferencedAssemblies.Add(Path.Combine(dir, "SQL8r.Logic.dll")); CompilerResults res = provider.CompileAssemblyFromSource(langCompilerConfig, code); if (res.Errors.HasErrors) { throw new SQL8rException(res.Errors[0].ErrorText); } else { Assembly a = res.CompiledAssembly; return(a); } } } throw new SQL8rException("language not known"); }
/// <summary> /// Compile the specified 'code' into an executable assembly. If 'assemblyFileName' /// is null then compile to an in-memory assembly. /// </summary> public static Assembly CompileTextToAssembly(string code, string assemblyFileName) { // See if we've already compiled this code. If so then return the assembly. if (AssemblyCache.ContainsKey(code)) { return(AssemblyCache[code]); } lock (AssemblyCache) { if (AssemblyCache.ContainsKey(code)) { return(AssemblyCache[code]); } bool VB = code.IndexOf("Imports System") != -1; string Language; if (VB) { Language = CodeDomProvider.GetLanguageFromExtension(".vb"); } else { Language = CodeDomProvider.GetLanguageFromExtension(".cs"); } if (Language != null && CodeDomProvider.IsDefinedLanguage(Language)) { CodeDomProvider Provider = CodeDomProvider.CreateProvider(Language); if (Provider != null) { CompilerParameters Params = new CompilerParameters(); string[] source = new string[1]; if (assemblyFileName == null) { Params.GenerateInMemory = true; source[0] = code; } else { Params.GenerateInMemory = false; Params.OutputAssembly = assemblyFileName; string sourceFileName; if (VB) { sourceFileName = Path.ChangeExtension(assemblyFileName, ".vb"); } else { sourceFileName = Path.ChangeExtension(assemblyFileName, ".cs"); } File.WriteAllText(sourceFileName, code); source[0] = sourceFileName; } Params.TreatWarningsAsErrors = false; Params.IncludeDebugInformation = true; Params.WarningLevel = 2; Params.ReferencedAssemblies.Add("System.dll"); Params.ReferencedAssemblies.Add("System.Xml.dll"); Params.ReferencedAssemblies.Add("System.Windows.Forms.dll"); Params.ReferencedAssemblies.Add("System.Data.dll"); Params.ReferencedAssemblies.Add("System.Core.dll"); //Params.ReferencedAssemblies.Add("APSIM.Shared.dll"); Params.ReferencedAssemblies.Add(System.IO.Path.Combine(Assembly.GetExecutingAssembly().Location)); if (Assembly.GetCallingAssembly() != Assembly.GetExecutingAssembly()) { Params.ReferencedAssemblies.Add(System.IO.Path.Combine(Assembly.GetCallingAssembly().Location)); } Params.TempFiles = new TempFileCollection(Path.GetTempPath()); // ensure that any temp files are in a writeable area Params.TempFiles.KeepFiles = false; CompilerResults results; if (assemblyFileName == null) { results = Provider.CompileAssemblyFromSource(Params, source); } else { results = Provider.CompileAssemblyFromFile(Params, source); } string Errors = ""; foreach (CompilerError err in results.Errors) { if (Errors != "") { Errors += "\r\n"; } Errors += err.ErrorText + ". Line number: " + err.Line.ToString(); } if (Errors != "") { throw new Exception(Errors); } AssemblyCache.Add(code, results.CompiledAssembly); return(results.CompiledAssembly); } } throw new Exception("Cannot compile manager script to an assembly"); } }
public void IsDefinedLanguage_NullLanguage_ThrowsArgumentNullException() { AssertExtensions.Throws <ArgumentNullException>("language", () => CodeDomProvider.IsDefinedLanguage(null)); }
public static object InvokeWebService(string url, string classname, string methodname, object[] args) { string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling"; if ((classname == null) || (classname == "")) { classname = ServiceTest.GetWsClassName(url); } try { //获取WSDL WebClient wc = new WebClient(); Stream stream = wc.OpenRead(url + "?WSDL"); ServiceDescription sd = ServiceDescription.Read(stream); ServiceDescriptionImporter sdi = new ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, "", ""); CodeNamespace cn = new CodeNamespace(@namespace); //生成客户端代理类代码 CodeCompileUnit ccu = new CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); #region csw 注释,因CreateCompiler已过期弃用 //CSharpCodeProvider csc = new CSharpCodeProvider(); //ICodeCompiler icc = csc.CreateCompiler(); //设定编译参数 //CompilerParameters cplist = new CompilerParameters(); //cplist.GenerateExecutable = false; //cplist.GenerateInMemory = true; //cplist.ReferencedAssemblies.Add("System.dll"); //cplist.ReferencedAssemblies.Add("System.XML.dll"); //cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); //cplist.ReferencedAssemblies.Add("System.Data.dll"); //编译代理类 //CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); #endregion #region csw修改,因CreateCompiler已过期弃用 if (!CodeDomProvider.IsDefinedLanguage("CSharp")) { return("编译失败"); } CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); //设定编译参数 CompilerParameters cplist = new CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); CompilerResults cr = provider.CompileAssemblyFromDom(cplist, ccu); #endregion if (true == cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } //生成代理实例,并调用方法 System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(@namespace + "." + classname, true, true); object obj = Activator.CreateInstance(t); System.Reflection.MethodInfo mi = t.GetMethod(methodname); return(mi.Invoke(obj, args)); } catch (Exception ex) { throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace)); } }
public Assembly Compile(bool debug, string languageOrExtension, params string[] sourceCode) { CodeDomProvider provider; CompilerParameters parameters; CompilerResults results; string language = languageOrExtension; if (!CodeDomProvider.IsDefinedLanguage(languageOrExtension) && CodeDomProvider.IsDefinedExtension(languageOrExtension)) { language = CodeDomProvider.GetLanguageFromExtension(languageOrExtension); } if (ConfigurationManager.GetSection("system.codedom") != null) { CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(language); provider = compilerInfo.CreateProvider(); parameters = compilerInfo.CreateDefaultCompilerParameters(); } else { if ((!language.Equals("c#", StringComparison.OrdinalIgnoreCase) && !language.Equals("cs", StringComparison.OrdinalIgnoreCase)) && !language.Equals("csharp", StringComparison.OrdinalIgnoreCase)) { throw new CompilerException(string.Format("When running the {0} in an AppDomain without a system.codedom config section only the csharp language is supported. This happens if you are precompiling your views.", typeof(BatchCompiler).FullName)); } string compilerVersion = GetCompilerVersion(); Dictionary <string, string> dictionary2 = new Dictionary <string, string>(); dictionary2.Add("CompilerVersion", compilerVersion); Dictionary <string, string> providerOptions = dictionary2; provider = new CSharpCodeProvider(providerOptions); parameters = new CompilerParameters(); } parameters.TreatWarningsAsErrors = false; string fileExtension = provider.FileExtension; foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { if (!assembly.IsDynamic()) { parameters.ReferencedAssemblies.Add(assembly.Location); } } string tempDir = AppDomain.CurrentDomain.SetupInformation.DynamicBase ?? Path.GetTempPath(); parameters.TempFiles = new TempFileCollection(tempDir); if (debug) { parameters.IncludeDebugInformation = true; string str5 = Path.Combine(tempDir, Guid.NewGuid().ToString("n")); List <string> list = new List <string>(); int num = 0; foreach (string str6 in sourceCode) { num++; string path = string.Concat(new object[] { str5, "-", num, ".", fileExtension }); using (FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write)) { using (StreamWriter writer = new StreamWriter(stream)) { writer.Write(str6); } } list.Add(path); } if (!string.IsNullOrEmpty(this.OutputAssembly)) { parameters.OutputAssembly = Path.Combine(tempDir, this.OutputAssembly); } else { parameters.OutputAssembly = str5 + ".dll"; } results = provider.CompileAssemblyFromFile(parameters, list.ToArray()); } else { if (!string.IsNullOrEmpty(this.OutputAssembly)) { parameters.OutputAssembly = Path.Combine(tempDir, this.OutputAssembly); } else { parameters.GenerateInMemory = true; } results = provider.CompileAssemblyFromSource(parameters, sourceCode); } if (!results.Errors.HasErrors) { return(results.CompiledAssembly); } StringBuilder builder = new StringBuilder(); builder.AppendLine("Dynamic view compilation failed."); foreach (CompilerError error in results.Errors) { builder.AppendFormat("{4}({0},{1}): {2} {3}: ", new object[] { error.Line, error.Column, error.IsWarning ? "warning" : "error", error.ErrorNumber, error.FileName }); builder.AppendLine(error.ErrorText); } builder.AppendLine(); foreach (string str8 in sourceCode) { using (StringReader reader = new StringReader(str8)) { int num2 = 1; while (true) { string str9 = reader.ReadLine(); if (str9 != null) { builder.Append(num2).Append(' ').AppendLine(str9); num2++; } } } } throw new BatchCompilerException(builder.ToString(), results); }
/// <summary> /// Generate a C# program from the Dafny program and, if "invokeCsCompiler" is "true", invoke /// the C# compiler to compile it. /// </summary> public static bool CompileDafnyProgram(Dafny.Program dafnyProgram, string dafnyProgramName, ReadOnlyCollection <string> otherFileNames, bool invokeCsCompiler, TextWriter outputWriter = null) { Contract.Requires(dafnyProgram != null); if (outputWriter == null) { outputWriter = Console.Out; } // Compile the Dafny program into a string that contains the C# program StringWriter sw = new StringWriter(); var oldErrorCount = dafnyProgram.reporter.Count(ErrorLevel.Error); Dafny.Compiler compiler = new Dafny.Compiler(dafnyProgram.reporter); var hasMain = compiler.HasMain(dafnyProgram); compiler.Compile(dafnyProgram, sw); var csharpProgram = sw.ToString(); bool completeProgram = dafnyProgram.reporter.Count(ErrorLevel.Error) == oldErrorCount; // blurt out the code to a file, if requested, or if other files were specified for the C# command line. string targetFilename = null; if (DafnyOptions.O.SpillTargetCode > 0 || otherFileNames.Count > 0) { targetFilename = WriteDafnyProgramToFile(dafnyProgramName, csharpProgram, completeProgram, outputWriter); } // compile the program into an assembly if (!completeProgram || !invokeCsCompiler) { // don't compile return(false); } else if (!CodeDomProvider.IsDefinedLanguage("CSharp")) { outputWriter.WriteLine("Error: cannot compile, because there is no provider configured for input language CSharp"); return(false); } else { var provider = CodeDomProvider.CreateProvider("CSharp", new Dictionary <string, string> { { "CompilerVersion", "v4.0" } }); var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateExecutable = hasMain; if (DafnyOptions.O.RunAfterCompile) { cp.GenerateInMemory = true; } else if (hasMain) { cp.OutputAssembly = Path.ChangeExtension(dafnyProgramName, "exe"); cp.GenerateInMemory = false; } else { cp.OutputAssembly = Path.ChangeExtension(dafnyProgramName, "dll"); cp.GenerateInMemory = false; } cp.CompilerOptions = "/debug /nowarn:0164 /nowarn:0219 /nowarn:1717 /nowarn:0162"; // warning CS0164 complains about unreferenced labels, CS0219 is about unused variables, CS1717 is about assignments of a variable to itself, CS0162 is about unreachable code cp.ReferencedAssemblies.Add("System.Numerics.dll"); cp.ReferencedAssemblies.Add("System.Core.dll"); cp.ReferencedAssemblies.Add("System.dll"); var libPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar; if (DafnyOptions.O.UseRuntimeLib) { cp.ReferencedAssemblies.Add(libPath + "DafnyRuntime.dll"); } var immutableDllFileName = "System.Collections.Immutable.dll"; var immutableDllPath = libPath + immutableDllFileName; if (DafnyOptions.O.Optimize) { cp.CompilerOptions += " /optimize /define:DAFNY_USE_SYSTEM_COLLECTIONS_IMMUTABLE"; cp.ReferencedAssemblies.Add(immutableDllPath); cp.ReferencedAssemblies.Add("System.Runtime.dll"); } int numOtherSourceFiles = 0; if (otherFileNames.Count > 0) { foreach (var file in otherFileNames) { string extension = Path.GetExtension(file); if (extension != null) { extension = extension.ToLower(); } if (extension == ".cs") { numOtherSourceFiles++; } else if (extension == ".dll") { cp.ReferencedAssemblies.Add(file); } } } CompilerResults cr; if (numOtherSourceFiles > 0) { string[] sourceFiles = new string[numOtherSourceFiles + 1]; sourceFiles[0] = targetFilename; int index = 1; foreach (var file in otherFileNames) { string extension = Path.GetExtension(file); if (extension != null) { extension = extension.ToLower(); } if (extension == ".cs") { sourceFiles[index++] = file; } } cr = provider.CompileAssemblyFromFile(cp, sourceFiles); } else { cr = provider.CompileAssemblyFromSource(cp, csharpProgram); } if (DafnyOptions.O.RunAfterCompile && !hasMain) { // do no more return(cr.Errors.Count == 0 ? true : false); } var assemblyName = Path.GetFileName(cr.PathToAssembly); if (DafnyOptions.O.RunAfterCompile && cr.Errors.Count == 0) { outputWriter.WriteLine("Program compiled successfully"); outputWriter.WriteLine("Running..."); outputWriter.WriteLine(); var entry = cr.CompiledAssembly.EntryPoint; try { object[] parameters = entry.GetParameters().Length == 0 ? new object[] { } : new object[] { new string[0] }; entry.Invoke(null, parameters); } catch (System.Reflection.TargetInvocationException e) { outputWriter.WriteLine("Error: Execution resulted in exception: {0}", e.Message); outputWriter.WriteLine(e.InnerException.ToString()); } catch (Exception e) { outputWriter.WriteLine("Error: Execution resulted in exception: {0}", e.Message); outputWriter.WriteLine(e.ToString()); } } else if (cr.Errors.Count == 0) { outputWriter.WriteLine("Compiled assembly into {0}", assemblyName); if (DafnyOptions.O.Optimize) { var outputDir = Path.GetDirectoryName(dafnyProgramName); if (string.IsNullOrWhiteSpace(outputDir)) { outputDir = "."; } var destPath = outputDir + Path.DirectorySeparatorChar + immutableDllFileName; File.Copy(immutableDllPath, destPath, true); outputWriter.WriteLine("Copied /optimize dependency {0} to {1}", immutableDllFileName, outputDir); } } else { outputWriter.WriteLine("Errors compiling program into {0}", assemblyName); foreach (var ce in cr.Errors) { outputWriter.WriteLine(ce.ToString()); outputWriter.WriteLine(); } return(false); } return(true); } }
public object Run(string in_lang, string in_source) { string tempPath = System.IO.Path.GetTempPath() + "DotNET-Script-Tmp"; try { if (!CodeDomProvider.IsDefinedLanguage(in_lang)) { // No provider defined for this language string sMsg = "No compiler is defined for " + in_lang; Console.WriteLine(sMsg); return(null); } CodeDomProvider compiler = CodeDomProvider.CreateProvider(in_lang); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateExecutable = false; parameters.GenerateInMemory = true; parameters.OutputAssembly = tempPath; parameters.MainClass = "Script.Main"; parameters.IncludeDebugInformation = false; parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("System.Data.dll"); parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); parameters.ReferencedAssemblies.Add("System.Xaml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll"); parameters.GenerateInMemory = true; string dotNetSDKPath = AppDomain.CurrentDomain.BaseDirectory; parameters.ReferencedAssemblies.Add(dotNetSDKPath + "openmayacs.dll"); CompilerResults results = compiler.CompileAssemblyFromSource(parameters, in_source); if (results.Errors.Count > 0) { string sErrors = "Search Condition is invalid:\n"; foreach (CompilerError err in results.Errors) { sErrors += err.ToString() + "\n"; } MessageBox.Show(sErrors, "DAG Explorer", MessageBoxButton.OK, MessageBoxImage.Error); } else { object o = results.CompiledAssembly.CreateInstance("Script"); Type type = o.GetType(); MethodInfo m = type.GetMethod("Main"); Object Result = m.Invoke(o, null); return(Result); } } catch (Exception e) { Console.WriteLine(e.ToString()); // Done with the temp assembly if (File.Exists(tempPath)) { File.Delete(tempPath); } } return(null); }
// Build and add the assembly to the BuildManager's // CodeAssemblies collection public void Build(string[] binAssemblies) { Type compilerProvider = null; CompilerInfo compilerInfo = null, cit; string extension, language, cpfile = null; List <string> knownfiles = new List <string>(); List <string> unknownfiles = new List <string>(); // First make sure all the files are in the same // language bool known = false; foreach (string f in files) { known = true; language = null; extension = Path.GetExtension(f); if (String.IsNullOrEmpty(extension) || !CodeDomProvider.IsDefinedExtension(extension)) { known = false; } if (known) { language = CodeDomProvider.GetLanguageFromExtension(extension); if (!CodeDomProvider.IsDefinedLanguage(language)) { known = false; } } if (!known || language == null) { unknownfiles.Add(f); continue; } cit = CodeDomProvider.GetCompilerInfo(language); if (cit == null || !cit.IsCodeDomProviderTypeValid) { continue; } if (compilerProvider == null) { cpfile = f; compilerProvider = cit.CodeDomProviderType; compilerInfo = cit; } else if (compilerProvider != cit.CodeDomProviderType) { throw new HttpException( String.Format( "Files {0} and {1} are in different languages - they cannot be compiled into the same assembly", Path.GetFileName(cpfile), Path.GetFileName(f))); } knownfiles.Add(f); } CodeDomProvider provider = null; CompilationSection compilationSection = WebConfigurationManager.GetWebApplicationSection("system.web/compilation") as CompilationSection; if (compilerInfo == null) { if (!CodeDomProvider.IsDefinedLanguage(compilationSection.DefaultLanguage)) { throw new HttpException("Failed to retrieve default source language"); } compilerInfo = CodeDomProvider.GetCompilerInfo(compilationSection.DefaultLanguage); if (compilerInfo == null || !compilerInfo.IsCodeDomProviderTypeValid) { throw new HttpException("Internal error while initializing application"); } } provider = compilerInfo.CreateProvider(); if (provider == null) { throw new HttpException("A code provider error occurred while initializing application."); } AssemblyBuilder abuilder = new AssemblyBuilder(provider); foreach (string file in knownfiles) { abuilder.AddCodeFile(file); } foreach (CodeCompileUnit unit in units) { abuilder.AddCodeCompileUnit(unit); } BuildProvider bprovider; CompilerParameters parameters = compilerInfo.CreateDefaultCompilerParameters(); parameters.IncludeDebugInformation = compilationSection.Debug; if (binAssemblies != null && binAssemblies.Length > 0) { StringCollection parmRefAsm = parameters.ReferencedAssemblies; foreach (string binAsm in binAssemblies) { if (parmRefAsm.Contains(binAsm)) { continue; } parmRefAsm.Add(binAsm); } } if (compilationSection != null) { foreach (AssemblyInfo ai in compilationSection.Assemblies) { if (ai.Assembly != "*") { try { parameters.ReferencedAssemblies.Add( AssemblyPathResolver.GetAssemblyPath(ai.Assembly)); } catch (Exception ex) { throw new HttpException( String.Format("Could not find assembly {0}.", ai.Assembly), ex); } } } BuildProviderCollection buildProviders = compilationSection.BuildProviders; foreach (string file in unknownfiles) { bprovider = GetBuildProviderFor(file, buildProviders); if (bprovider == null) { continue; } bprovider.GenerateCode(abuilder); } } if (knownfiles.Count == 0 && unknownfiles.Count == 0 && units.Count == 0) { return; } outputAssemblyName = (string)FileUtils.CreateTemporaryFile( AppDomain.CurrentDomain.SetupInformation.DynamicBase, name, "dll", OnCreateTemporaryAssemblyFile); parameters.OutputAssembly = outputAssemblyName; foreach (Assembly a in BuildManager.TopLevelAssemblies) { parameters.ReferencedAssemblies.Add(a.Location); } CompilerResults results = abuilder.BuildAssembly(parameters); if (results == null) { return; } if (results.NativeCompilerReturnValue == 0) { BuildManager.CodeAssemblies.Add(results.CompiledAssembly); BuildManager.TopLevelAssemblies.Add(results.CompiledAssembly); HttpRuntime.WritePreservationFile(results.CompiledAssembly, name); } else { if (HttpContext.Current.IsCustomErrorEnabled) { throw new HttpException("An error occurred while initializing application."); } throw new CompilationException(null, results.Errors, null); } }
public void IsDefinedLanguage_ReturnsExpected(string language, bool expected) { Assert.Equal(expected, CodeDomProvider.IsDefinedLanguage(language)); }
public bool Execute() { try { if (this.ApplicationMarkup == null || this.ApplicationMarkup.Count == 0) { return(true); } if (!CodeDomProvider.IsDefinedLanguage(this.Language)) { throw FxTrace.Exception.Argument("Language", SR.UnrecognizedLanguage(this.Language)); } if (this.SupportExtensions) { this.xamlBuildTypeGenerationExtensions = XamlBuildTaskServices.GetXamlBuildTaskExtensions <IXamlBuildTypeGenerationExtension>( this.XamlBuildTaskTypeGenerationExtensionNames, this.BuildLogger, this.MSBuildProjectDirectory); } AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(XamlBuildTaskServices.ReflectionOnlyAssemblyResolve); bool retVal = true; // We load the assemblies for the real builds // For intellisense builds, we load them the first time only if (!IsInProcessXamlMarkupCompile || this.LoadedAssemblyList == null) { if (this.References != null) { try { this.LoadedAssemblyList = XamlBuildTaskServices.Load(this.References, IsInProcessXamlMarkupCompile); } catch (FileNotFoundException e) { XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.FileName, 0, 0); retVal = false; } } } CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider(this.Language); ProcessHelperClassGeneration(codeDomProvider); foreach (ITaskItem app in ApplicationMarkup) { string inputMarkupFile = app.ItemSpec; try { retVal &= ProcessMarkupItem(app, codeDomProvider); } catch (LoggableException e) { if (Fx.IsFatal(e)) { throw; } XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.Source, e.LineNumber, e.LinePosition); retVal = false; } catch (FileLoadException e) { if (Fx.IsFatal(e)) { throw; } XamlBuildTaskServices.LogException(this.BuildLogger, SR.AssemblyCannotBeResolved(XamlBuildTaskServices.FileNotLoaded), inputMarkupFile, 0, 0); retVal = false; } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, inputMarkupFile, 0, 0); retVal = false; } } // Add the files generated from extensions if (this.SupportExtensions) { if (retVal) { foreach (string fileName in this.BuildContextForExtensions.GeneratedFiles) { this.GeneratedCodeFiles.Add(fileName); } foreach (string fileName in this.BuildContextForExtensions.GeneratedResourceFiles) { this.GeneratedResources.Add(fileName); } } } return(retVal); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } // Log unknown errors that do not originate from the task. // Assumes that all known errors are logged when the exception is thrown. if (!(e is LoggableException)) { XamlBuildTaskServices.LogException(this.BuildLogger, e.Message); } return(false); } }