private void CompileTestCodeDom(string code)
{
try
{
OutputClass selectedItem = (OutputClass)this.cbCodeDom.SelectedItem;
CodeDomProvider codeDomProvider = selectedItem.CodeDomProvider;
CSharpSnippet snippet = new CSharpSnippet("\r\n public string GenerateCode()\r\n {\r\n " + code + "\r\n\r\n CodeGeneratorOptions codegenopt = new CodeGeneratorOptions();\r\n codegenopt.BlankLinesBetweenMembers = true;\r\n\r\n using (System.IO.StringWriter sw = new System.IO.StringWriter())\r\n {\r\n " + codeDomProvider.GetType().Name + " provider = new " + codeDomProvider.GetType().Name + "();\r\n\r\n provider.GenerateCodeFromCompileUnit(_compileunit1, sw, codegenopt);\r\n\r\n return sw.ToString();\r\n }\r\n } \r\n");
snippet.Namespaces.Add("System.CodeDom");
snippet.Namespaces.Add("System.CodeDom.Compiler");
snippet.Namespaces.Add(codeDomProvider.GetType().Namespace);
Assembly assembly = codeDomProvider.GetType().Assembly;
if (!assembly.GlobalAssemblyCache)
{
snippet.ReferencedAssemblies.Add(assembly.Location);
}
object[] args = new object[0];
object obj2 = snippet.Execute("GenerateCode", args);
if (obj2 != null)
{
this.scintillaTestCodeDom.Text = obj2.ToString();
}
}
catch (Exception exception)
{
new ExceptionDialog(exception, "Error Generating CodeDom").ShowDialog();
}
}
private static int GetGeneratedColumnOffset(CodeDomProvider codeDomProvider)
{
object obj2 = null;
if (_generatedColumnOffsetDictionary == null)
{
_generatedColumnOffsetDictionary = new ListDictionary();
}
else
{
obj2 = _generatedColumnOffsetDictionary[codeDomProvider.GetType()];
}
if (obj2 != null)
{
return((int)obj2);
}
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace namespace2 = new CodeNamespace("ASP");
compileUnit.Namespaces.Add(namespace2);
CodeTypeDeclaration declaration = new CodeTypeDeclaration("ColumnOffsetCalculator")
{
IsClass = true
};
namespace2.Types.Add(declaration);
CodeMemberMethod method = new CodeMemberMethod {
ReturnType = new CodeTypeReference(typeof(void)),
Name = "GenerateMethod"
};
declaration.Members.Add(method);
CodeStatement statement = new CodeAssignStatement(new CodeVariableReferenceExpression("__o"), new CodeSnippetExpression("__dummyVar"));
method.Statements.Add(statement);
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb, CultureInfo.InvariantCulture);
codeDomProvider.GenerateCodeFromCompileUnit(compileUnit, writer, null);
StringReader reader = new StringReader(sb.ToString());
string str = null;
int num = 4;
while ((str = reader.ReadLine()) != null)
{
int index = 0;
index = str.TrimStart(new char[0]).IndexOf("__dummyVar", StringComparison.Ordinal);
if (index != -1)
{
num = (index - "__o".Length) + 1;
}
}
_generatedColumnOffsetDictionary[codeDomProvider.GetType()] = num;
return(num);
}
public void Roundtrip_Extension()
{
CodeDomProvider provider = GetProvider();
string ext = provider.FileExtension;
CodeDomProvider provider2 = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(ext));
Assert.Equal(provider.GetType(), provider2.GetType());
}
/// <summary>
/// Fixes the compiler path to get it run.
/// </summary>
private static void FixCompilerPath(CodeDomProvider provider)
{
FieldInfo memberInfo = provider.GetType().GetField("_compilerSettings", BindingFlags.Instance | BindingFlags.NonPublic);
if (memberInfo != null)
{
object settings = memberInfo.GetValue(provider);
FieldInfo path = settings.GetType().GetField("_compilerFullPath", BindingFlags.Instance | BindingFlags.NonPublic);
path?.SetValue(settings, @"D:\bin\roslyn\csc.exe");
}
}
// TODO: Move compilation stuff elsewhere.
// TODO: Consider IronPython support: http://www.ironpython.info/index.php/Using_Compiled_Python_Classes_from_.NET/CSharp_IP_2.6
internal List <ExportedAssembly> GetAssemblies(string pathResolveRoot, DnaLibrary dnaLibrary)
{
List <ExportedAssembly> list = new List <ExportedAssembly>();
// Dynamically compile this project to an in-memory assembly
CodeDomProvider provider = GetProvider();
if (provider == null)
{
return(list);
}
CompilerParameters cp = new CompilerParameters();
bool isFsharp = false;
// TODO: Debug build ?
// cp.IncludeDebugInformation = true;
cp.GenerateExecutable = false;
//cp.OutputAssembly = Name; // TODO: Keep track of built assembly for the project
cp.GenerateInMemory = true;
cp.TreatWarningsAsErrors = false;
// This is attempt to fix the bug reported on the group, where the add-in compilation fails if the add-in is put into c:\
// It is caused by a quirk of the 'Path.GetDirectoryName' function when dealing with the path "c:\test.abc"
// - it leaves the last DirectorySeparator in the path in this special case.
// Thanks to Nemo for the great fix.
//local variable to hold the quoted/unquoted version of the executing dirction
string ProcessedExecutingDirectory = DnaLibrary.ExecutingDirectory;
if (ProcessedExecutingDirectory.IndexOf(' ') != -1)
{
ProcessedExecutingDirectory = "\"" + ProcessedExecutingDirectory + "\"";
}
//set compiler command line vars as needed
if (provider is Microsoft.VisualBasic.VBCodeProvider)
{
cp.CompilerOptions = " /libPath:" + ProcessedExecutingDirectory;
if (DefaultImports)
{
string importsList = "Microsoft.VisualBasic,System,System.Collections,System.Collections.Generic,System.Data,System.Diagnostics,ExcelDna.Integration";
if (Environment.Version.Major >= 4)
{
importsList += ",System.Linq,System.Xml.Linq";
}
cp.CompilerOptions += " /imports:" + importsList;
}
}
else if (provider is Microsoft.CSharp.CSharpCodeProvider)
{
cp.CompilerOptions = " /lib:" + ProcessedExecutingDirectory;
}
else if (provider.GetType().FullName.ToLower().IndexOf(".jscript.") != -1)
{
cp.CompilerOptions = " /lib:" + ProcessedExecutingDirectory;
}
else if (provider.GetType().FullName == "Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider")
{
isFsharp = true;
cp.CompilerOptions = " --nologo -I " + ProcessedExecutingDirectory; // In F# 2.0, the --nologo is redundant - I leave it because it does no harm.
// FSharp 2.0 compiler will target .NET 4 unless we do something to ensure .NET 2.0.
// It seems adding an explicit reference to the .NET 2.0 version of mscorlib.dll is good enough.
if (Environment.Version.Major < 4)
{
// Explicitly add a reference to the mscorlib version from the currently running .NET version
string libPath = Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), "mscorlib.dll");
cp.ReferencedAssemblies.Add(libPath);
}
}
// TODO: Consider what to do if we can't resolve some of the Reference paths -- do we try to compile anyway, throw an exception, ...what?
List <string> refPaths = GetReferencePaths(pathResolveRoot, provider);
cp.ReferencedAssemblies.AddRange(refPaths.ToArray());
List <string> sources = GetSources(pathResolveRoot);
CompilerResults cr;
try
{
cr = provider.CompileAssemblyFromSource(cp, sources.ToArray());
}
catch (Win32Exception wex)
{
if (isFsharp)
{
Logger.DnaCompilation.Error("There was an error in loading the add-in " + DnaLibrary.CurrentLibraryName + " (" + DnaLibrary.XllPath + "):");
string fsBinPath = Environment.GetEnvironmentVariable("FSHARP_BIN");
string msg;
if (fsBinPath == null)
{
msg = " Calling the F# compiler failed (\"" + wex.Message + "\").\r\n" +
" Please check that the F# compiler is correctly installed.\r\n" +
" This error can sometimes be fixed by creating an FSHARP_BIN environment variable.\r\n" +
" Create an environment variable FSHARP_BIN with the full path to the directory containing \r\n" +
" the F# compiler fsc.exe - for example \r\n" +
" \"" + @"C:\Program Files (x86)\Microsoft SDKs\F#\3.0\Framework\v4.0\""";
}
else
{
msg = " Calling the F# compiler failed (\"" + wex.Message + "\").\r\n" +
" Please check that the F# compiler is correctly installed, and that the FSHARP_BIN environment variable is correct\r\n" +
" (it currently points to " + fsBinPath + ").";
}
Logger.DnaCompilation.Error(msg);
return(list);
}
throw;
}
foreach (string path in tempAssemblyPaths)
{
File.Delete(path);
}
tempAssemblyPaths.Clear();
if (cr.Errors.HasErrors)
{
Logger.DnaCompilation.Error("There was an error in loading the add-in " + DnaLibrary.CurrentLibraryName + " (" + DnaLibrary.XllPath + "):");
Logger.DnaCompilation.Error("There were errors when compiling project: " + Name);
foreach (CompilerError err in cr.Errors)
{
Logger.DnaCompilation.Error(" " + err.ToString());
}
return(list);
}
// Success !!
// Now add all the references
// TODO: How to remove again??
foreach (Reference r in References)
{
AssemblyReference.AddAssembly(r.Path);
}
// TODO: Create TypeLib for execution-time compiled assemblies.
list.Add(new ExportedAssembly(cr.CompiledAssembly, ExplicitExports, ExplicitRegistration, ComServer, true, null, dnaLibrary));
return(list);
}
private static Assembly CompileCode(CodeDomProvider prov, bool v35, WXMLCodeDomGeneratorSettings settings,
WXMLModel model, params CodeCompileUnit[] units)
{
WormCodeDomGenerator gen = new WormCodeDomGenerator(model, settings);
CompilerResults result;
CompilerParameters prms = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false,
TreatWarningsAsErrors = false/*,
* OutputAssembly = "testAssembly.dll"*/
};
prms.ReferencedAssemblies.Add("System.dll");
prms.ReferencedAssemblies.Add("System.Data.dll");
prms.ReferencedAssemblies.Add("System.XML.dll");
if (v35)
{
prms.ReferencedAssemblies.Add("System.Core.dll");
}
if ((settings.GenerateMode.HasValue ? settings.GenerateMode.Value : model.GenerateMode) != GenerateModeEnum.EntityOnly)
{
//prms.ReferencedAssemblies.Add("CoreFramework.dll");
prms.ReferencedAssemblies.Add("Worm.Orm.dll");
if (model.LinqSettings != null && model.LinqSettings.Enable)
{
prms.ReferencedAssemblies.Add("Worm.Linq.dll");
}
}
prms.TempFiles.KeepFiles = true;
CodeCompileUnit singleUnit = new CodeCompileUnit();
if (settings.SingleFile.HasValue ? settings.SingleFile.Value : model.GenerateSingleFile)
{
singleUnit = gen.GetFullSingleUnit(typeof(Microsoft.VisualBasic.VBCodeProvider).IsAssignableFrom(prov.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
singleUnit.Namespaces.Add(new CodeNamespace("System"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq.Expressions"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Collections.Generic"));
var l = new List <CodeCompileUnit>();
l.Add(singleUnit);
if (units != null)
{
l.AddRange(units);
foreach (var item in units)
{
singleUnit.Namespaces.AddRange(item.Namespaces);
}
}
result = prov.CompileAssemblyFromDom(prms, l.ToArray());
}
else
{
Dictionary <string, CodeCompileFileUnit> dic =
gen.GetCompileUnits(typeof(Microsoft.VisualBasic.VBCodeProvider).IsAssignableFrom(prov.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
foreach (CodeCompileFileUnit unit in dic.Values)
{
singleUnit.Namespaces.AddRange(unit.Namespaces);
}
var l = new List <CodeCompileUnit>(dic.Values.OfType <CodeCompileUnit>());
if (units != null)
{
l.AddRange(units);
foreach (var item in units)
{
singleUnit.Namespaces.AddRange(item.Namespaces);
}
}
singleUnit.Namespaces.Add(new CodeNamespace("System"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq.Expressions"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Collections.Generic"));
result = prov.CompileAssemblyFromDom(prms, l.ToArray());
}
prov.GenerateCodeFromCompileUnit(singleUnit, Console.Out, new CodeGeneratorOptions());
if (result.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError str in result.Errors)
{
sb.AppendLine(str.ToString());
}
Assert.Fail(sb.ToString());
}
return(result.CompiledAssembly);
}
internal static int GetGeneratedColumnOffset(CodeDomProvider codeDomProvider)
{
object o = null;
if (_generatedColumnOffsetDictionary == null)
{
_generatedColumnOffsetDictionary = new ListDictionary();
}
else
{
o = _generatedColumnOffsetDictionary[codeDomProvider.GetType()];
}
if (o == null)
{
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cnamespace = new CodeNamespace("ASP");
ccu.Namespaces.Add(cnamespace);
CodeTypeDeclaration type = new CodeTypeDeclaration("ColumnOffsetCalculator");
type.IsClass = true;
cnamespace.Types.Add(type);
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = new CodeTypeReference(typeof(void));
method.Name = "GenerateMethod";
type.Members.Add(method);
CodeStatement simpleAssignment = new CodeAssignStatement(
new CodeVariableReferenceExpression(BaseTemplateCodeDomTreeGenerator.tempObjectVariable),
new CodeSnippetExpression(_dummyVariable));
method.Statements.Add(simpleAssignment);
StringBuilder sb = new StringBuilder();
StringWriter w = new StringWriter(sb, CultureInfo.InvariantCulture);
codeDomProvider.GenerateCodeFromCompileUnit(ccu, w, null);
StringReader reader = new StringReader(sb.ToString());
String line = null;
int offset = _defaultColumnOffset;
while ((line = reader.ReadLine()) != null)
{
int index = 0;
line = line.TrimStart();
if ((index = line.IndexOf(_dummyVariable, StringComparison.Ordinal)) != -1)
{
offset = index - BaseTemplateCodeDomTreeGenerator.tempObjectVariable.Length + 1;
}
}
// Save the offset per type.
_generatedColumnOffsetDictionary[codeDomProvider.GetType()] = offset;
return(offset);
}
return((int)o);
}
private static void GenerateMultipleFilesOutput(string outputFolder, WXMLModel model,
CodeDomProvider codeDomProvider, bool separateFolder,
IEnumerable <string> skipEntities, IEnumerable <string> processEntities, bool testRun,
WormCodeDomGenerator gen)
{
List <string> errorList = new List <string>();
int totalEntities = 0;
int totalFiles = 0;
foreach (EntityDefinition entity in model.OwnEntities)
{
//bool skip = false;
//if (processEntities.Length != 0)
//{
// skip = true;
// foreach (string processEntityId in processEntities)
// {
// if (processEntityId == entity.Identifier)
// {
// skip = false;
// break;
// }
// }
//}
//foreach (string skipEntityId in skipEntities)
//{
// if (skipEntityId == entity.Identifier)
// {
// skip = true;
// break;
// }
//}
if (skipEntities.Contains(entity.Identifier))
{
continue;
}
if (processEntities.Count() > 0 && !processEntities.Contains(entity.Identifier))
{
continue;
}
string privateFolder;
if (separateFolder)
{
privateFolder = outputFolder + Path.DirectorySeparatorChar.ToString() + entity.Name + Path.DirectorySeparatorChar;
}
else
{
privateFolder = outputFolder + Path.DirectorySeparatorChar.ToString();
}
var units = gen.GetEntityCompileUnits(entity.Identifier, typeof(VBCodeProvider).IsAssignableFrom(codeDomProvider.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
Console.Write(".");
if (!Directory.Exists(privateFolder))
{
Directory.CreateDirectory(privateFolder);
}
foreach (var unit in units)
{
Console.Write(".");
try
{
GenerateCode(codeDomProvider, unit, Path.GetFullPath(privateFolder + Path.DirectorySeparatorChar.ToString() + unit.Filename), testRun);
Console.Write(".");
totalFiles++;
}
catch (Exception exc)
{
Console.Write(".");
errorList.Add(
string.Format("Entity: {0}; file: {1}; message: {2}", entity.Identifier, unit.Filename, exc.Message));
}
}
totalEntities++;
}
try
{
var ctx = gen.GetLinqContextCompliteUnit(typeof(VBCodeProvider).IsAssignableFrom(codeDomProvider.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
if (ctx != null)
{
GenerateCode(codeDomProvider, ctx,
Path.GetFullPath(
outputFolder +
Path.DirectorySeparatorChar.ToString() +
ctx.Filename
), testRun);
Console.Write(".");
totalFiles++;
}
}
catch (Exception exc)
{
Console.Write(".");
errorList.Add(
string.Format("Linq context file failed to generate: {0}", exc.Message));
}
Console.WriteLine();
Console.WriteLine("Result:");
Console.WriteLine("\t {0} entities processed", totalEntities);
Console.WriteLine("\t {0} files generated", totalFiles);
Console.WriteLine("\t {0} errors encountered", errorList.Count);
if (errorList.Count != 0)
{
Console.WriteLine("Errors:");
foreach (string s in errorList)
{
Console.WriteLine("\t" + s);
for (int i = 0; i < Console.WindowWidth; i++)
{
Console.Write("-");
}
Console.WriteLine();
}
}
}
/// <include file='doc\BaseCompiler.uex' path='docs/doc[@for="BaseCompiler.GetCompiledType"]/*' />
/// <devdoc>
///
/// </devdoc>
protected Type GetCompiledType()
{
// Instantiate an ICompiler based on the language
CodeDomProvider codeProvider = (CodeDomProvider)HttpRuntime.CreatePublicInstance(
CompilerInfo.CompilerType);
ICodeCompiler compiler = codeProvider.CreateCompiler();
_generator = codeProvider.CreateGenerator();
_stringResourceBuilder = new StringResourceBuilder();
// Build the data tree that needs to be compiled
BuildSourceDataTree();
// Create the resource file if needed
if (_stringResourceBuilder.HasStrings)
{
string resFileName = _compilParams.TempFiles.AddExtension("res");
_stringResourceBuilder.CreateResourceFile(resFileName);
CompilParams.Win32Resource = resFileName;
}
// Compile into an assembly
CompilerResults results;
try {
results = codeProvider.CreateCompiler().CompileAssemblyFromDom(_compilParams, _sourceData);
}
catch (Exception e) {
throw new HttpUnhandledException(HttpRuntime.FormatResourceString(SR.CompilationUnhandledException, codeProvider.GetType().FullName), e);
}
string fullTypeName = _sourceDataNamespace.Name + "." + _sourceDataClass.Name;
ThrowIfCompilerErrors(results, codeProvider, _sourceData, null, null);
// After the compilation, update the list of assembly dependencies to be what
// the assembly actually needs.
Parser.AssemblyDependencies = Util.GetReferencedAssembliesHashtable(
results.CompiledAssembly);
// Get the type from the assembly
return(results.CompiledAssembly.GetType(fullTypeName, true /*throwOnFail*/));
}
private void WriteAssembly(string sourceFilePath)
{
// Create the provider.
CodeDomProvider provider = CreateCodeProvider();
// Create the assembly.
// ICodeCompiler compiler = provider.CreateCompiler();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = false;
parameters.OutputAssembly = m_assemblyInfo.Name;
// Add all the referenced assemblies to the compiler options (since we're not passing m_unit to the compiler).
foreach (string reference in m_unit.ReferencedAssemblies)
{
parameters.ReferencedAssemblies.Add(reference);
}
// The IncludeDebugInformation flag does more than it says - it also disables optimization and defines
// the "DEBUG" compile time constant. Only do this in the Debug build. In Release build manually
// add the "/debug+" compiler argument (the same for both csc.exe and vbc.exe), so that a PDB file
// is generated, but optimization is still enabled.
#if DEBUG
parameters.IncludeDebugInformation = true;
#else
Trace.Assert(provider is Microsoft.CSharp.CSharpCodeProvider || provider is Microsoft.VisualBasic.VBCodeProvider,
"Unexpected type of code provider: " + provider.GetType().FullName);
parameters.IncludeDebugInformation = false;
parameters.CompilerOptions = "/debug+";
#endif
string tempPath = Path.Combine(Path.GetDirectoryName(m_assemblyInfo.Name), "Source");
// Make sure the path is there.
bool createDir = !Directory.Exists(tempPath);
if (createDir)
{
Directory.CreateDirectory(tempPath);
}
parameters.TempFiles = new System.CodeDom.Compiler.TempFileCollection(tempPath, true);
parameters.TempFiles.KeepFiles = false;
try
{
CompilerResults results = provider.CompileAssemblyFromFile(parameters, sourceFilePath);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder(System.Environment.NewLine);
foreach (CompilerError error in results.Errors)
{
sb.Append(error.ErrorText);
sb.Append(System.Environment.NewLine);
}
throw new System.ApplicationException("An attempt to compile the '" + m_assemblyInfo.Name
+ "' assembly has failed with the following errors: " + sb.ToString());
}
}
finally
{
// Delete the temporary directory, if we created it.
DirectoryInfo dirInfo = new DirectoryInfo(tempPath);
if (createDir && dirInfo.GetFiles().Length == 0 && dirInfo.GetDirectories().Length == 0)
{
dirInfo.Delete();
}
}
}
// TODO: Move compilation stuff elsewhere.
public List <Assembly> GetAssemblies()
{
List <Assembly> list = new List <Assembly>();
// Dynamically compile this project to an in-memory assembly
CodeDomProvider provider = GetProvider();
if (provider == null)
{
return(list);
}
CompilerParameters cp = new CompilerParameters();
// TODO: Debug build ?
// cp.IncludeDebugInformation = true;
cp.GenerateExecutable = false;
//cp.OutputAssembly = Name; // TODO: Keep track of built assembly for the project
cp.GenerateInMemory = true;
cp.TreatWarningsAsErrors = false;
if (provider is Microsoft.VisualBasic.VBCodeProvider)
{
cp.CompilerOptions = " /libPath:\"" + DnaLibrary.ExecutingDirectory + "\" ";
if (DefaultImports)
{
string importsList = "Microsoft.VisualBasic,System,System.Collections,System.Collections.Generic,System.Data,System.Diagnostics,ExcelDna.Integration";
cp.CompilerOptions += " /imports:" + importsList;
}
}
else if (provider is Microsoft.CSharp.CSharpCodeProvider)
{
cp.CompilerOptions = " /lib:\"" + DnaLibrary.ExecutingDirectory + "\" ";
}
else if (provider.GetType().FullName == "Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider")
{
cp.CompilerOptions = " --nologo -I " + DnaLibrary.ExecutingDirectory;
}
List <string> references = GetReferences().ConvertAll <string>(delegate(Reference item) { return(item.AssemblyPath); });
cp.ReferencedAssemblies.AddRange(references.ToArray());
List <string> sources = GetSourceItems().ConvertAll <string>(delegate(SourceItem item) { return(item.Code); });
CompilerResults cr = provider.CompileAssemblyFromSource(cp, sources.ToArray());
// TODO: URGENT: Revisit...
if (tempIntegrationAssemblyPath != null)
{
File.Delete(tempIntegrationAssemblyPath);
tempIntegrationAssemblyPath = null;
}
if (cr.Errors.HasErrors)
{
ExcelDna.Logging.LogDisplay.WriteLine("There were errors when compiling project: " + Name);
foreach (CompilerError err in cr.Errors)
{
ExcelDna.Logging.LogDisplay.WriteLine(err.ToString());
}
return(list);
}
// Success !!
// Now add all the references
// TODO: How to remove again??
foreach (Reference r in References)
{
AssemblyReference.AddAssembly(r.AssemblyPath);
}
list.Add(cr.CompiledAssembly);
return(list);
}
private SourceCompilerCachedEntry CompileAndCache()
{
BaseCompiler.GenerateCompilerParameters(_compilParams);
// Get the set of config assemblies for our context
IDictionary configAssemblies = CompilationConfiguration.GetAssembliesFromContext(_context);
if (_assemblies == null)
{
_assemblies = new Hashtable();
}
// Add all the assemblies from the config object to the hashtable
// This guarantees uniqueness
if (configAssemblies != null)
{
foreach (Assembly asm in configAssemblies.Values)
{
_assemblies[asm] = null;
}
}
// And the assembly of the application object (global.asax)
_assemblies[HttpApplicationFactory.ApplicationType.Assembly] = null;
// Now add all the passed in assemblies to the compilParams
foreach (Assembly asm in _assemblies.Keys)
{
_compilParams.ReferencedAssemblies.Add(Util.GetAssemblyCodeBase(asm));
}
// Instantiate the Compiler
CodeDomProvider codeProvider = (CodeDomProvider)HttpRuntime.CreatePublicInstance(_compilerType);
ICodeCompiler compiler = codeProvider.CreateCompiler();
CompilerResults results;
// Compile the source file or string into an assembly
try {
_utcStart = DateTime.UtcNow;
// If we have a source file, read it as a string and compile it. This way,
// the compiler never needs to read the original file, avoiding permission
// issues (see ASURT 112718)
if (_sourceString == null)
{
_sourceString = Util.StringFromFile(_physicalPath, _context);
// Put in some context so that the file can be debugged.
_linePragma = new CodeLinePragma(_physicalPath, 1);
}
CodeSnippetCompileUnit snippetCompileUnit = new CodeSnippetCompileUnit(_sourceString);
snippetCompileUnit.LinePragma = _linePragma;
results = compiler.CompileAssemblyFromDom(_compilParams, snippetCompileUnit);
}
catch (Exception e) {
throw new HttpUnhandledException(HttpRuntime.FormatResourceString(SR.CompilationUnhandledException, codeProvider.GetType().FullName), e);
}
BaseCompiler.ThrowIfCompilerErrors(results, codeProvider,
null, _physicalPath, _sourceString);
SourceCompilerCachedEntry scce = new SourceCompilerCachedEntry();
// Load the assembly
scce._assembly = results.CompiledAssembly;
// If we have a type name, load the type from the assembly
if (_typeName != null)
{
scce._type = scce._assembly.GetType(_typeName);
// If the type could not be loaded, delete the assembly and rethrow
if (scce._type == null)
{
PreservedAssemblyEntry.RemoveOutOfDateAssembly(scce._assembly.GetName().Name);
// Remember why we failed
_typeNotFoundInAssembly = true;
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Could_not_create_type, _typeName));
}
}
CacheEntryToDisk(scce);
CacheEntryToMemory(scce);
return(scce);
}
