public static Assembly Compile(CodeDomProvider cp, string scriptCode, IList assemblies) { ICodeCompiler ic = cp.CreateCompiler(); CompilerParameters cpar = GetCompilerParameters(assemblies); CompilerResults cr = ic.CompileAssemblyFromSource(cpar, scriptCode); bool errors = false; if (cr.Errors.Count > 0) { StringBuilder sb = new StringBuilder("Error compiling the composition script:\n"); foreach (CompilerError ce in cr.Errors) { if (!ce.IsWarning) { errors = true; sb.Append("\nError number:\t") .Append(ce.ErrorNumber) .Append("\nMessage:\t ") .Append(ce.ErrorText) .Append("\nLine number:\t") .Append(ce.Line); } } if (errors) { throw new PicoCompositionException(sb.ToString()); } } return cr.CompiledAssembly; }
public override Type GetCompiledType () { Type type = CachingCompiler.GetTypeFromCache (parser.PhysicalPath); if (type != null) return type; if (parser.Program.Trim () == "") { type = parser.GetTypeFromBin (parser.ClassName); CachingCompiler.InsertType (type, parser.PhysicalPath); return type; } string lang = parser.Language; CompilationConfiguration config; config = CompilationConfiguration.GetInstance (parser.Context); provider = config.GetProvider (lang); if (provider == null) throw new HttpException ("Configuration error. Language not supported: " + lang, 500); compiler = provider.CreateCompiler (); compilerParameters = CachingCompiler.GetOptions (parser.Assemblies); compilerParameters.IncludeDebugInformation = parser.Debug; compilerParameters.CompilerOptions = config.GetCompilerOptions (lang); compilerParameters.WarningLevel = config.GetWarningLevel (lang); bool keepFiles = (Environment.GetEnvironmentVariable ("MONO_ASPNET_NODELETE") != null); TempFileCollection tempcoll; tempcoll = new TempFileCollection (config.TempDirectory, keepFiles); compilerParameters.TempFiles = tempcoll; if (!Directory.Exists (dynamicBase)) Directory.CreateDirectory (dynamicBase); inputFile = tempcoll.AddExtension (provider.FileExtension); Stream st = File.OpenWrite (inputFile); StreamWriter sw = new StreamWriter (st); sw.WriteLine (parser.Program); sw.Close (); string dllfilename = Path.GetFileName (tempcoll.AddExtension ("dll", true)); compilerParameters.OutputAssembly = Path.Combine (dynamicBase, dllfilename); CompilerResults results = CachingCompiler.Compile (this); CheckCompilerErrors (results); if (results.CompiledAssembly == null) throw new CompilationException (inputFile, results.Errors, "No assembly returned after compilation!?"); results.TempFiles.Delete (); type = results.CompiledAssembly.GetType (parser.ClassName, true); CachingCompiler.InsertType (type, parser.PhysicalPath); return type; }
public Assembly Compile(CodeDomProvider codeDomProvider, object scriptCode, IList assemblies ) { ICodeCompiler codeCompiler = codeDomProvider.CreateCompiler(); CompilerParameters compilerParameters = GetCompilerParameters(assemblies); CompilerResults compilerResults = null; if(scriptCode is string) { compilerResults = codeCompiler.CompileAssemblyFromSource(compilerParameters, scriptCode as string); } else { compilerResults = codeCompiler.CompileAssemblyFromDom(compilerParameters, scriptCode as CodeCompileUnit); } handleErrors(compilerResults); return compilerResults.CompiledAssembly; }
public static CompilerResults CompileScript(string Source, string Reference, CodeDomProvider Provider) { ICodeCompiler compiler = Provider.CreateCompiler(); CompilerParameters parms = new CompilerParameters(); CompilerResults results; // Configure parameters parms.GenerateExecutable = false; parms.GenerateInMemory = true; parms.IncludeDebugInformation = false; if (Reference != null && Reference.Length != 0) parms.ReferencedAssemblies.Add(Reference); parms.ReferencedAssemblies.Add("System.Windows.Forms.dll"); parms.ReferencedAssemblies.Add("System.dll"); // Compile results = compiler.CompileAssemblyFromSource(parms, Source); return results; }
/// <summary>Check code with given CodeDomProvider.</summary> /// <example> /// <code lang="CS" description="The following example gets some code and check it with given CodeDomProvider"> /// string code = "double Calc(double x) /// { /// double gain = 1.5; /// return x*gain; /// } /// " /// String resultString; /// /// CodeExpressionChecker.CheckCode(new CSharpCodeProvider(), code, ref resultString); /// </code> /// </example> public static void CheckCode(CodeDomProvider provider, String sourceCode, ref String errorString) { ICodeCompiler compiler = provider.CreateCompiler(); CompilerParameters cp = new CompilerParameters(new string[]{"mscorlib.dll", typeof(Point2D).Assembly.Location}); cp.GenerateInMemory = true; CompilerResults cr = compiler.CompileAssemblyFromSource(cp, sourceCode); if (cr.NativeCompilerReturnValue != 0) { int i = resultSpace; string outputString = ""; while(i < cr.Output.Count) { outputString += cr.Output[i] + Environment.NewLine; i++; } // Return the results of compilation with error flag and error string errorString = outputString; } else errorString = ""; }
/// <summary> /// This overrides the CodeDomTest Run method that does verification /// on the tree provided in the BuildTree method you provide. /// </summary> /// <param name="provider">Provider to test.</param> /// <returns>True if the tree builds, compiles, searches and passes /// assembly verification. False if any of these fails.</returns> public override bool Run (CodeDomProvider provider) { bool fail = false; // build the tree LogMessageIndent (); LogMessage ("- Generating tree."); CodeCompileUnit cu = new CodeCompileUnit (); LogMessageIndent (); BuildTree (provider, cu); LogMessageUnindent (); // validate tree using 'experimental' subset tester // but only if the test believes its in the subset if ((TestType & TestTypes.Subset) != 0) { SubsetConformance subsConf = new SubsetConformance (); LogMessage ("- Checking tree subset conformance."); if (!subsConf.ValidateCodeCompileUnit (cu)) LogMessage ("Failed subset tester: {0}", subsConf.ToString ()); } // realize source StringWriter sw = new StringWriter (CultureInfo.InvariantCulture); #if WHIDBEY provider.GenerateCodeFromCompileUnit (cu, sw, GetGeneratorOptions (provider)); #else ICodeGenerator generator = provider.CreateGenerator (); generator.GenerateCodeFromCompileUnit (cu, sw, GetGeneratorOptions (provider)); #endif // only continue if the source could be realized into a string. if (!fail) { string source = sw.ToString (); if (saveSourceFileName.Length > 0) { LogMessage ("- Saving source into '" + saveSourceFileName + "'"); // save this source to a file DumpStringToFile (source, saveSourceFileName); } // log the source code //LogMessage (source); // search the source if the test case asks us to if (ShouldSearch) { LogMessageIndent (); Search (provider, source); LogMessageUnindent (); } // continue only if the test case wants to compile or verify if (ShouldCompile || ShouldVerify) { // ask the test case which compiler parameters it would like to use CompilerParameters parms = GetCompilerParameters (provider); #if FSHARP // If the generated code has entrypoint, then F# requires us to generate EXE bool hasEntryPoint = false; foreach(CodeNamespace ns in cu.Namespaces) foreach (CodeTypeDeclaration ty in ns.Types) foreach(CodeTypeMember mem in ty.Members) if (mem is CodeEntryPointMethod) { hasEntryPoint = true; } // If the output file name is specified then it should be EXE if (hasEntryPoint && parms.GenerateExecutable == false) { parms.GenerateExecutable = true; if (saveAssemblyFileName.ToLower().EndsWith(".dll")) saveAssemblyFileName = saveAssemblyFileName.Substring(0, saveAssemblyFileName.Length - 4) + ".exe"; } #endif // add the appropriate compiler parameters if the user asked us // to save assemblies to file if (saveAssemblyFileName.Length > 0) { parms.OutputAssembly = saveAssemblyFileName; LogMessage ("- Compiling to '" + saveAssemblyFileName + "'."); } // always generate in memory for verification purposes parms.GenerateInMemory = true; // compile! #if WHIDBEY CompilerResults results = provider.CompileAssemblyFromDom (parms, cu); #else ICodeCompiler compiler = provider.CreateCompiler (); CompilerResults results = compiler.CompileAssemblyFromDom (parms, cu); #endif if (results.NativeCompilerReturnValue != 0) { // compilation failed fail = true; LogMessage ("- Compilation failed."); // log the compilation failed output foreach (string msg in results.Output) LogMessage (msg); } else if (ShouldVerify) { // compilation suceeded and we are asked to verify the // compiled assembly LogMessage ("- Verifying assembly."); // verify the compiled assembly if it's there if (results.CompiledAssembly != null) { LogMessageIndent (); VerifyAssembly (provider, results.CompiledAssembly); LogMessageUnindent (); } } } } if (fail || !AreAllValidated ()) { // one of the steps above failed or a scenario was not // verified within the test case fail = true; LogMessage ("! Test '" + Name + "' failed."); // output failing scenarios if (!AreAllValidated()) { LogMessage ("! Failing scenarios:"); foreach (Scenario s in GetNotValidated()) { LogMessage ("- " + s.ToString()); } } } else { // test passed LogMessage ("* Test '" + Name + "' passed."); } LogMessageUnindent (); // return true on success, false on failure return !fail; }
public CompilerInfo(CodeDomProvider provider) { Compiler = provider.CreateCompiler(); CodeGen = provider.CreateGenerator(); }
///<remarks>Brendan Ingram has greatly improved this method.</remarks> private static object LoadClass(CodeDomProvider codeProvider, string targetClassName, string source, bool sourceIsString) { CompilerParameters compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = true; compilerParameters.IncludeDebugInformation = true; compilerParameters.TreatWarningsAsErrors = false; // Add the reference to the NxBRE.dll assembly. if ((ReferenceLinkMode == ReferenceLinkModes.NxBRE) || (ReferenceLinkMode == ReferenceLinkModes.Full)) AddReferencedAssembly(compilerParameters, NxbreAssemblyLocation); // Add all implicitly referenced assemblies if ((ReferenceLinkMode == ReferenceLinkModes.CurrentDomain) || (ReferenceLinkMode == ReferenceLinkModes.Full)) foreach(Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) // do not add AssemblyBuilders (bug 1482753), thanks to Bob Brumfield if (!(assembly is AssemblyBuilder)) AddReferencedAssembly(compilerParameters, assembly.Location); ICodeCompiler compiler = codeProvider.CreateCompiler(); CompilerResults cr; if (sourceIsString) cr = compiler.CompileAssemblyFromSource(compilerParameters, source); else cr = compiler.CompileAssemblyFromFile(compilerParameters, source); if (cr.Errors.Count == 0) return cr.CompiledAssembly.CreateInstance(targetClassName); else throw new BREException(GetCompilerErrors(cr)); }
private void CompileAssembly(CodeDomProvider provider, Hashtable typeDecls, string nsName) { nsName = "Microsoft.Xslt.CompiledScripts." + nsName; CodeNamespace msXslt = new CodeNamespace(nsName); // Add all the default namespaces foreach(string ns in _defaultNamespaces) { msXslt.Imports.Add(new CodeNamespaceImport(ns)); } foreach(CodeTypeDeclaration scriptClass in typeDecls.Values) { msXslt.Types.Add(scriptClass); } CodeCompileUnit unit = new CodeCompileUnit(); { unit.Namespaces.Add(msXslt); // This settings have sense for Visual Basic only. // We can consider in future to allow user set them in <xsl:script option="???"> attribute. unit.UserData["AllowLateBound"] = true; // Allow variables to be undeclared unit.UserData["RequireVariableDeclaration"] = false; // Allow variables to be declared untyped } CompilerParameters compilParams = new CompilerParameters(); { compilParams.GenerateInMemory = true; compilParams.ReferencedAssemblies.Add(typeof(XPathNavigator).Module.FullyQualifiedName); compilParams.ReferencedAssemblies.Add("system.dll"); // compilParams.ReferencedAssemblies.Add("microsoft.visualbasic.dll"); This is not requied somehow. } CompilerResults results = provider.CreateCompiler().CompileAssemblyFromDom(compilParams, unit); if (results.Errors.HasErrors) { StringWriter stringWriter = new StringWriter(); foreach (CompilerError e in results.Errors) { stringWriter.WriteLine(e.ToString()); } System.Diagnostics.Debug.WriteLine(stringWriter.ToString()); throw new XsltException(Res.Xslt_ScriptCompileErrors, stringWriter.ToString()); } Assembly assembly = results.CompiledAssembly; foreach(DictionaryEntry entry in typeDecls) { string ns = (string)entry.Key; CodeTypeDeclaration scriptClass = (CodeTypeDeclaration)entry.Value; this.stylesheet.ScriptObjectTypes.Add(ns, assembly.GetType(nsName + "." + scriptClass.Name)); } }
/// <summary> /// Function to compile .Net C#/VB source codes at runtime /// </summary> /// <param name="_CodeProvider">Base class for compiler provider</param> /// <param name="_SourceCode">C# or VB source code as a string</param> /// <param name="_SourceFile">External file containing C# or VB source code</param> /// <param name="_ExeFile">File path to create external executable file</param> /// <param name="_AssemblyName">File path to create external assembly file</param> /// <param name="_ResourceFiles">Required resource files to compile the code</param> /// <param name="_Errors">String variable to store any errors occurred during the process</param> /// <returns>Return TRUE if successfully compiled the code, else return FALSE</returns> private bool CompileCode(System.CodeDom.Compiler.CodeDomProvider _CodeProvider, string _SourceCode, string _SourceFile, string _ExeFile, string _AssemblyName, string[] _ResourceFiles, ref string _Errors) { // set interface for compilation System.CodeDom.Compiler.ICodeCompiler _CodeCompiler = _CodeProvider.CreateCompiler(); // Define parameters to invoke a compiler System.CodeDom.Compiler.CompilerParameters _CompilerParameters = new System.CodeDom.Compiler.CompilerParameters(); if (_ExeFile != null) { // Set the assembly file name to generate. _CompilerParameters.OutputAssembly = _ExeFile; // Generate an executable instead of a class library. _CompilerParameters.GenerateExecutable = true; _CompilerParameters.GenerateInMemory = false; // Esto será lo que haya que cambiar para que se cargue en memoria } else if (_AssemblyName != null) { // Set the assembly file name to generate. _CompilerParameters.OutputAssembly = _AssemblyName; // Generate an executable instead of a class library. _CompilerParameters.GenerateExecutable = false; _CompilerParameters.GenerateInMemory = false; } else { // Generate an executable instead of a class library. _CompilerParameters.GenerateExecutable = false; _CompilerParameters.GenerateInMemory = true; } // Generate debug information. //_CompilerParameters.IncludeDebugInformation = true; // Set the level at which the compiler // should start displaying warnings. _CompilerParameters.WarningLevel = 3; // Set whether to treat all warnings as errors. _CompilerParameters.TreatWarningsAsErrors = false; // Set compiler argument to optimize output. _CompilerParameters.CompilerOptions = "/optimize"; // Set a temporary files collection. // The TempFileCollection stores the temporary files // generated during a build in the current directory, // and does not delete them after compilation. _CompilerParameters.TempFiles = new System.CodeDom.Compiler.TempFileCollection(".", true); if (_ResourceFiles != null && _ResourceFiles.Length > 0) { foreach (string _ResourceFile in _ResourceFiles) { // Set the embedded resource file of the assembly. _CompilerParameters.EmbeddedResources.Add(_ResourceFile); } } try { // Invoke compilation System.CodeDom.Compiler.CompilerResults _CompilerResults = null; if (_SourceFile != null && System.IO.File.Exists(_SourceFile)) { // soruce code in external file _CompilerResults = _CodeCompiler.CompileAssemblyFromFile(_CompilerParameters, _SourceFile); } else { // source code pass as a string _CompilerResults = _CodeCompiler.CompileAssemblyFromSource(_CompilerParameters, _SourceCode); } if (_CompilerResults.Errors.Count > 0) { // Return compilation errors _Errors = ""; foreach (System.CodeDom.Compiler.CompilerError CompErr in _CompilerResults.Errors) { _Errors += "Line number " + CompErr.Line + ", Error Number: " + CompErr.ErrorNumber + ", '" + CompErr.ErrorText + ";\r\n\r\n"; } // Return the results of compilation - Failed return(false); } else { // no compile errors _Errors = null; } } catch (Exception _Exception) { // Error occurred when trying to compile the code _Errors = _Exception.Message; return(false); } // Return the results of compilation - Success return(true); }
public static CompilerResults CompileScript( string sSource, string sReference, string sAssembly, CodeDomProvider pProvider) { ICodeCompiler pCompiler = pProvider.CreateCompiler(); CompilerParameters pParams = new CompilerParameters(); // configure parameters pParams.GenerateExecutable = false; pParams.GenerateInMemory = false; pParams.OutputAssembly = sAssembly + ".dll"; pParams.IncludeDebugInformation = false; if (sReference != null && sReference.Length != 0) { pParams.ReferencedAssemblies.Add(sReference); } pParams.ReferencedAssemblies.Add("System.dll"); pParams.ReferencedAssemblies.Add("System.Drawing.dll"); // compile return pCompiler.CompileAssemblyFromSource(pParams, sSource); }
///<remarks>Brendan Ingram has greatly improved this method.</remarks> private static object LoadClass(CodeDomProvider codeProvider, string targetClassName, string source, bool sourceIsString) { if (compilerParameters == null) { compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = true; compilerParameters.IncludeDebugInformation = true; compilerParameters.TreatWarningsAsErrors = false; // Add the referent to the NxBRE.dll assembly. compilerParameters.ReferencedAssemblies.Add(NxbreAssemblyLocation); // Add all implicitly referenced assemblies foreach(Assembly assy in AppDomain.CurrentDomain.GetAssemblies()) { try { compilerParameters.ReferencedAssemblies.Add(assy.Location); } catch {} } } ICodeCompiler compiler = codeProvider.CreateCompiler(); CompilerResults cr; if (sourceIsString) cr = compiler.CompileAssemblyFromSource(compilerParameters, source); else cr = compiler.CompileAssemblyFromFile(compilerParameters, source); if (cr.Errors.Count == 0) return cr.CompiledAssembly.CreateInstance(targetClassName); else throw new BREException(GetCompilerErrors(cr)); }
public void ToAssemblyFile(CodeCompileUnit compileunit, CodeDomProvider provider, string fileName) { #if NET2 CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.GenerateInMemory = false; cp.OutputAssembly = fileName; CompilerResults cr = provider.CompileAssemblyFromDom(cp, compileunit); #else ICodeCompiler compiler = provider.CreateCompiler(); CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add( "System.dll" ); cp.GenerateInMemory = false; cp.OutputAssembly = fileName; CompilerResults cr = compiler.CompileAssemblyFromDom(cp, compileunit); #endif }
public CompilerResults ToCompilerResults(CodeCompileUnit compileunit, CodeDomProvider provider, IDomainMap domainMap) { #if NET2 CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.GenerateInMemory = true; string code = ToCode(compileunit, provider, domainMap); return provider.CompileAssemblyFromSource(cp, code); #else ICodeCompiler compiler = provider.CreateCompiler(); CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add( "System.dll" ); cp.GenerateInMemory = true; string code = ToCode(compileunit, provider, domainMap); return compiler.CompileAssemblyFromSource(cp, code); #endif }
public virtual Type GetCompiledType () { Type type = CachingCompiler.GetTypeFromCache (parser.InputFile); if (type != null) return type; Init (); string lang = parser.Language; CompilationConfiguration config; config = CompilationConfiguration.GetInstance (parser.Context); provider = config.GetProvider (lang); if (provider == null) throw new HttpException ("Configuration error. Language not supported: " + lang, 500); compiler = provider.CreateCompiler (); CreateMethods (); compilerParameters.IncludeDebugInformation = parser.Debug; compilerParameters.CompilerOptions = config.GetCompilerOptions (lang) + " " + parser.CompilerOptions; compilerParameters.WarningLevel = config.GetWarningLevel (lang); bool keepFiles = (Environment.GetEnvironmentVariable ("MONO_ASPNET_NODELETE") != null); if (!Directory.Exists (dynamicBase)) Directory.CreateDirectory (dynamicBase); TempFileCollection tempcoll = new TempFileCollection (config.TempDirectory, keepFiles); compilerParameters.TempFiles = tempcoll; string dllfilename = Path.GetFileName (tempcoll.AddExtension ("dll", true)); compilerParameters.OutputAssembly = Path.Combine (dynamicBase, dllfilename); CompilerResults results = CachingCompiler.Compile (this); CheckCompilerErrors (results); Assembly assembly = results.CompiledAssembly; if (assembly == null) { if (!File.Exists (compilerParameters.OutputAssembly)) throw new CompilationException (parser.InputFile, results.Errors, "No assembly returned after compilation!?"); assembly = Assembly.LoadFrom (compilerParameters.OutputAssembly); } results.TempFiles.Delete (); return assembly.GetType (mainClassExpr.Type.BaseType, true); }