public Tuple<StringCollection, Assembly> Compile(string[] dllFiles, string[] sourceFiles, string outputAssemblyPath)
{
var providerOptions = new Dictionary<string,
string> { {
"CompilerVersion",
"v4.0"
}
};
CodeDomProvider codeProvider = new CSharpCodeProvider(providerOptions);
var compilerParameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = true
};
compilerParameters.ReferencedAssemblies.AddRange(dllFiles);
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
compilerParameters.ReferencedAssemblies.Add("System.ComponentModel.dll");
compilerParameters.ReferencedAssemblies.Add("System.Xml.Serialization.dll");
var result = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFiles);
return new Tuple<StringCollection,
Assembly>(result.Output, result.Errors.Count > 0 ? null : result.CompiledAssembly);
}
public void CompileSiteModels()
{
DirectoryInfo di = new DirectoryInfo(SysPath.SiteModelsDirectory);
FileInfo[] fiar = di.GetFiles("*.cs");
String[] fisar = new String[fiar.Length];
for (int i = 0; i < fiar.Length; i++)
{
fisar[i] = fiar[i].FullName;
}
CompilerParameters parameters = new CompilerParameters(new String[] { "System.dll", "NStag.dll", "nhibernate.dll" });
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.OutputAssembly = this.DomainName;
parameters.CompilerOptions = String.Concat("/lib:", SysPath.GetLibDirectory());
CSharpCodeProvider cprovider = new CSharpCodeProvider();
CompilerResults results = cprovider.CompileAssemblyFromFile(parameters, cspath);
if (results.Errors.HasErrors)
{
throw new Exception(results.Errors[0].ErrorText);
}
}
public CompilerResults CompileCDir(string path, string dllName)
{
// ArrayList refs = new ArrayList();
//refs.Add("System");
//refs.Add("System.Collections.Generic");
//refs.Add("System.Text");
string Output = dllName;
CSharpCodeProvider provider = new CSharpCodeProvider();
string[] files = GetScripts(path, "*.cs");
// CodeDomProvider dom = CodeDomProvider.CreateProvider("CSharp");
// string[] refers = (string[])refs.ToArray(typeof(string));
CompilerParameters param = new CompilerParameters(null,Output,false);
//System.CodeDom.Compiler.CompilerParameters param = new CompilerParameters();
param.GenerateExecutable = false;
//param.OutputAssembly = Output;
//CompilerResults results = dom.CompileAssemblyFromSource(param, sources);
CompilerResults results = provider.CompileAssemblyFromFile(param, files);
if (results.Errors.Count > 0)
{
foreach (CompilerError Comperr in results.Errors)
{
errors = errors + "Line " + Comperr.Line + ": " + Comperr.ErrorText + "\n";
}
return results;
}
return results;
}
/// <summary>
/// Compiles the source files found within the scriptRepository directory matching the ICompiler.ScriptExtension
/// The Compiler defaults to the C# 4.0 compiler if none other is supplied via the ICompiler.CompilerOptions argument.
/// </summary>
/// <param name="param">Compiler Parameters that can be supplied to customize the compilation of the source.</param>
/// <returns>Returns true if the compilation was completed without error.</returns>
public Boolean Compile(CompilerParameters param, String scriptRepository)
{
// Make sure we have a compiler version supplied.
if (!CompilerOptions.ContainsKey("CompilerVersion"))
CompilerOptions.Add("CompilerVersion", "v4.0");
// Instance a reference to the C# code provider, this is what will perform the compiling.
CSharpCodeProvider provider = new CSharpCodeProvider(CompilerOptions);
// Create an array of script files found within the ScriptRepository matching the ScriptExtension properties.
if (!Directory.Exists(scriptRepository))
Directory.CreateDirectory(scriptRepository);
String[] scripts = Directory.GetFiles(scriptRepository, "*" + this.ScriptExtension, SearchOption.AllDirectories);
if (scripts.Length > 0)
{
// Compile the scripts and provide the Results property with a reference to the compilation results.
Results = provider.CompileAssemblyFromFile(param, scripts);
// if the compiler has errors, return false.
if (Results.Errors.HasErrors)
return false;
else
return true;
}
else
{
Results = new CompilerResults(new TempFileCollection());
return false;
}
}
static Assembly current_TypeResolve(object sender, ResolveEventArgs args)
{
string[] items = args.Name.Split('.');
string path = Environment.CurrentDirectory + "\\code\\";
for (int i = 0; i < items.Length - 1; i++)
{
path += items[i] + "\\";
}
path += items[items.Length - 1] + ".cs";
Console.WriteLine(path);
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters prams = new CompilerParameters();
prams.GenerateExecutable = false;
prams.GenerateInMemory = true;
CompilerResults results = provider.CompileAssemblyFromFile(prams, path);
if (results.Errors.Count > 0)
{
foreach (CompilerError item in results.Errors)
{
Console.WriteLine("[RUNTIME - Compiler Error] : " + item.Line.ToString() + " : " + item.ErrorNumber + " " + item.ErrorText);
}
return null;
}
else
{
return results.CompiledAssembly;
}
}
public static CompilerResults Compile(this DirectoryInfo[] compileTargets, string fileName, string[] referenceAssemblies, bool executable)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = executable;
parameters.OutputAssembly = fileName;
List<string> compilerOptions = new List<string>();
foreach (string referenceAssembly in referenceAssemblies)
{
compilerOptions.Add("/reference:" + referenceAssembly);
}
parameters.CompilerOptions = compilerOptions.ToArray().ToDelimited(" ");
List<string> fileNames = new List<string>();
foreach (DirectoryInfo targetDirectory in compileTargets)
{
foreach (FileInfo fileInfo in FsUtil.GetFilesWithExtension(targetDirectory.FullName, ".cs"))
{
fileNames.Add(fileInfo.FullName);
}
}
return codeProvider.CompileAssemblyFromFile(parameters, fileNames.ToArray());//.CompileAssemblyFromFileBatch(parameters, fileNames.ToArray());
}
internal static object CreateObject(string code, params string[] referencedAssemblies)
{
string tempsPath = AppDomain.CurrentDomain.BaseDirectory + "Temps\\";
if (!Directory.Exists(tempsPath))
Directory.CreateDirectory(tempsPath);
string codeFile = tempsPath + "__temp.cs";
string assemblyFile = tempsPath + "__temp.dll";
File.Delete(codeFile);
File.Delete(assemblyFile);
FileStream fs = File.Open(codeFile, FileMode.CreateNew);
StreamWriter sw = new StreamWriter(fs);
sw.Write(code);
sw.Close();
sw.Dispose();
fs.Close();
fs.Dispose();
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.OutputAssembly = assemblyFile;
if (referencedAssemblies != null && referencedAssemblies.Length > 0)
parameters.ReferencedAssemblies.AddRange(referencedAssemblies);
CompilerResults results = provider.CompileAssemblyFromFile(parameters, codeFile);
if (results.Errors.HasErrors || results.Errors.HasWarnings)
return null;
else
return results.CompiledAssembly.CreateInstance("__temp.__temp");
}
private Assembly BuildParser(string code)
{
var source = Path.Combine(Path.GetDirectoryName(typeof(Grammar).Assembly.Location), "TestGrammarParser.cs");
var output = Path.Combine(Path.GetDirectoryName(typeof(Grammar).Assembly.Location), "TestGrammarParser.dll");
File.WriteAllText(source, code);
File.Delete(output);
var cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add(typeof(Grammar).Assembly.Location);
cp.OutputAssembly = output;
cp.IncludeDebugInformation = true;
cp.GenerateInMemory = false;
cp.TreatWarningsAsErrors = false;
var csp = new CSharpCodeProvider();
var cr = csp.CompileAssemblyFromFile(cp, source);
if (cr.Errors.Count > 0)
{
throw new Exception(cr.Errors[0].ErrorText);
}
else
{
return Assembly.LoadFile(output);
}
}
public void Compile(string[] sources)
{
var compilerParams = new CompilerParameters
{
CompilerOptions = "/target:library /optimize",
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = true
};
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerParams.ReferencedAssemblies.Add("System.Core.dll");
compilerParams.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
foreach (var library in Directory.GetFiles(_libraryLocation, "*.dll"))
{
compilerParams.ReferencedAssemblies.Add(library);
}
CodeDomProvider codeProvider = new CSharpCodeProvider();
CompilerResults results = codeProvider.CompileAssemblyFromFile(compilerParams, sources);
if(results.Errors.Count > 0)
{
Console.WriteLine("Error found while recompiling your files:");
foreach (string line in results.Output)
{
Console.WriteLine(line);
}
}
}
public Type Compile()
{
var implicitClassSource = LinqQueryToImplicitClass();
var tempFileName = Path.GetTempFileName()+".cs";
File.WriteAllText(tempFileName, implicitClassSource);
var provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
var results = provider.CompileAssemblyFromFile(new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = false,
IncludeDebugInformation = true,
ReferencedAssemblies =
{
typeof(AbstractViewGenerator).Assembly.Location,
typeof(NameValueCollection).Assembly.Location,
typeof(object).Assembly.Location,
typeof(System.Linq.Enumerable).Assembly.Location,
rootQueryType.Assembly.Location
},
}, tempFileName);
if (results.Errors.HasErrors)
{
var sb = new StringBuilder().AppendLine();
foreach (CompilerError error in results.Errors)
{
sb.AppendLine(error.ToString());
}
throw new InvalidOperationException(sb.ToString());
}
PathToAssembly = results.PathToAssembly;
return results.CompiledAssembly.GetType(Name);
}
public static void Compile(string finalOutputAssembly, string[] sources, string[] referencedAssemblies, string compilerVersion, string compilerOptions = null)
{
//string finalOutputAssembly = "test";
//string[] sources = new string[] { };
//string[] referencedAssemblies = new string[] { };
//string compilerOptions = null;
Dictionary<string, string> providerOption = new Dictionary<string, string>();
//"v4.0"
providerOption.Add("CompilerVersion", compilerVersion);
CSharpCodeProvider provider = new CSharpCodeProvider(providerOption);
CompilerParameters options = new CompilerParameters();
options.CompilerOptions = compilerOptions;
options.GenerateInMemory = false;
options.OutputAssembly = finalOutputAssembly;
options.GenerateExecutable = true;
options.IncludeDebugInformation = true;
// WarningLevel : from http://msdn.microsoft.com/en-us/library/13b90fz7.aspx
// 0 Turns off emission of all warning messages.
// 1 Displays severe warning messages.
// 2 Displays level 1 warnings plus certain, less-severe warnings, such as warnings about hiding class members.
// 3 Displays level 2 warnings plus certain, less-severe warnings, such as warnings about expressions that always evaluate to true or false.
// 4 (the default) Displays all level 3 warnings plus informational warnings.
options.WarningLevel = 4;
foreach (string referencedAssembly in referencedAssemblies)
options.ReferencedAssemblies.Add(referencedAssembly);
CompilerResults results = provider.CompileAssemblyFromFile(options, sources);
}
/// <summary>
/// Creates data model object
/// </summary>
/// <param name="modelName">a name of model in configuration</param>
/// <param name="uid">Data base unique Id</param>
/// <returns>Data nmodel object</returns>
public static IModel CreateModel(String modelName, Object uid)
{
String cspath = SysPath.GetModelSourceFile(modelName);
CompilerParameters parameters = new CompilerParameters(new String[] { "System.dll", "NStag.dll", "nhibernate.dll" });
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.CompilerOptions = String.Concat("/lib:", SysPath.GetLibDirectory());
CSharpCodeProvider cprovider = new CSharpCodeProvider();
CompilerResults results = cprovider.CompileAssemblyFromFile(parameters, cspath);
if (results.Errors.HasErrors)
{
throw new Exception(results.Errors[0].ErrorText);
}
Type[] types = results.CompiledAssembly.GetExportedTypes();
foreach (Type t in types)
{
Type[] interfaces = t.GetInterfaces();
foreach (Type i in interfaces)
{
if (i == typeof(IModel))
{
//OrmHelper.GetCurrentSession().SessionFactory.
return (IModel)OrmHelper.GetCurrentSession().Get(t, uid);
}
}
}
return null;
}
public bool CompileC(string[] sources, string dllName)
{
string Output = dllName;
CSharpCodeProvider provider = new CSharpCodeProvider();
// CodeDomProvider dom = CodeDomProvider.CreateProvider("CSharp");
System.CodeDom.Compiler.CompilerParameters param = new CompilerParameters();
param.GenerateExecutable = false;
param.OutputAssembly = Output;
//CompilerResults results = dom.CompileAssemblyFromSource(param, sources);
CompilerResults results = provider.CompileAssemblyFromFile(param, sources);
if (results.Errors.Count > 0)
{
foreach(CompilerError Comperr in results.Errors)
{
errors = errors + "Line " + Comperr.Line + ": " + Comperr.ErrorText + "\n";
}
return false;
}
return true;
}
public string Compile(string sourcePath, IEnumerable<string> referencedLibraries = null)
{
using(var provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } }))
{
var outputFileName = TemporaryFilesManager.Instance.GetTemporaryFile();
var parameters = new CompilerParameters { GenerateInMemory = false, GenerateExecutable = false, OutputAssembly = outputFileName };
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(Machine)).Location); // Core
parameters.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(Serializer)).Location); // Migrant
if(referencedLibraries != null)
{
foreach(var lib in referencedLibraries)
{
parameters.ReferencedAssemblies.Add(lib);
}
}
var result = provider.CompileAssemblyFromFile(parameters, new[] { sourcePath });
if(result.Errors.HasErrors)
{
var errors = result.Errors.Cast<object>().Aggregate(string.Empty,
(current, error) => current + ("\n" + error));
throw new RecoverableException(string.Format("There were compilation errors:\n{0}", errors));
}
return outputFileName;
}
}
internal static void MainThreadEntry(object state)
{
var args = (string[])state;
if (args.Length < 2)
throw new Exception("Dunno what to run.");
var appDirectory = Path.GetFullPath(args[1]);
var appFile = Path.Combine(appDirectory, "App.cs");
var appConfigFile = Path.Combine(appDirectory, "BlazeApp.json.config");
if (!File.Exists(appConfigFile))
throw new Exception("App configuration file was not found.");
if (!File.Exists(appFile))
throw new Exception("No app entry found.");
var appConfigFileContent = File.ReadAllText(appConfigFile);
var appConfig = JsonConvert.DeserializeObject<AppConfiguration>(appConfigFileContent);
var tempAssemblyPath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
var codeProvider = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", appConfig.CompilerVersion } });
var compilerParameters = new CompilerParameters(appConfig.References, tempAssemblyPath, false)
{
GenerateInMemory = true
};
var compilerResult = codeProvider.CompileAssemblyFromFile(compilerParameters, new[] { appFile });
if (compilerResult.Errors.Count > 0)
throw new Exception("There were errors during compilation.");
// TODO: Invoke compiled entry method -- http://stackoverflow.com/questions/14479074/c-sharp-reflection-load-assembly-and-invoke-a-method-if-it-exists
}
public static void CompileIntoAssembly(string outputPath, IEnumerable<string> references, List<string> files)
{
CodeDomProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters()
{
GenerateExecutable = false,
OutputAssembly = outputPath,
IncludeDebugInformation = true,
CompilerOptions = "/unsafe"
};
foreach (var @ref in references)
cp.ReferencedAssemblies.Add(@ref);
CompilerResults cr = provider.CompileAssemblyFromFile(cp, files.ToArray());
if (cr.Errors.HasErrors)
{
var message = new StringBuilder();
message.Append("Error compiling generated files.\n");
foreach(var error in cr.Errors)
message.AppendFormat(" {0}\n",error.ToString());
throw new Exception(message.ToString());
}
}
/// <summary>Verifies that the specified files compile without errors.</summary>
/// <param name="files">The files to compile.</param>
/// <param name="references">Te assemblies to reference during compilation.</param>
public static void CompilesWithoutErrors(IEnumerable<FileInfo> files, params Assembly[] references)
{
if (files == null || !files.Any())
{
throw new AssertionException("No files specified.");
}
using (var provider = new CSharpCodeProvider())
{
var parameters = new CompilerParameters();
foreach (var reference in references)
{
parameters.ReferencedAssemblies.Add(reference.Location);
}
var selected = files.Select(file => file.FullName).ToArray();
var results = provider.CompileAssemblyFromFile(parameters, selected);
foreach (var error in results.Errors.OfType<CompilerError>())
{
Console.WriteLine("{0}{1}{2:0000}: {3}",
Path.GetFileName(error.FileName),
Environment.NewLine,
error.Line,
error.ErrorText);
}
var errorCount = results.Errors.OfType<CompilerError>().Count(e => !e.IsWarning);
var warnCount = results.Errors.OfType<CompilerError>().Count(e => e.IsWarning);
Assert.IsFalse(results.Errors.HasErrors, "With {0} error(s). See console output for details.", errorCount);
Assert.IsFalse(results.Errors.HasWarnings, "With {0} warning(s). See console output for details.", warnCount);
}
}
protected override Type CompileMigration(MigrationReference migrationReference)
{
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
if (!String.IsNullOrEmpty(_configuration.CompilerVersion))
{
providerOptions["CompilerVersion"] = _configuration.CompilerVersion;
}
CodeDomProvider provider = new CSharpCodeProvider(providerOptions);
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.OutputAssembly = Path.Combine(_workingDirectoryManager.WorkingDirectory,
Path.GetFileNameWithoutExtension(migrationReference.Path) + ".dll");
parameters.ReferencedAssemblies.Add(typeof (IDatabaseMigration).Assembly.Location);
parameters.ReferencedAssemblies.Add(typeof (SqlMoney).Assembly.Location);
parameters.IncludeDebugInformation = true;
foreach (string reference in _configuration.References)
{
parameters.ReferencedAssemblies.Add(reference);
}
_log.InfoFormat("Compiling {0}", migrationReference);
CompilerResults cr = provider.CompileAssemblyFromFile(parameters, GetFiles(migrationReference.Path).ToArray());
if (cr.Errors.Count > 0)
{
foreach (CompilerError error in cr.Errors)
{
_log.ErrorFormat("{0}", error);
}
throw new InvalidOperationException();
}
if (cr.CompiledAssembly == null)
{
throw new InvalidOperationException();
}
return MigrationHelpers.LookupMigration(cr.CompiledAssembly, migrationReference);
}
public static Assembly BuildAssemblyFromHbm(string assemblyName,params string[] mappings)
{
//uses hbm2net to create classes files.
FileInfo configFile = new FileInfo(Path.GetTempFileName());
List<string> hbms = new List<string>();
// the mapping file needs to be written to the same
// directory as the config file for this test
foreach (var hbm in mappings)
{
FileInfo mappingFile = new FileInfo(Path.Combine(configFile.DirectoryName, hbm));
if (mappingFile.Exists)
mappingFile.Delete();
ResourceHelper.WriteToFileFromResource(mappingFile, hbm);
hbms.Add(mappingFile.FullName);
}
TestHelper.CreateConfigFile(configFile, T4DefaultTemplate, T4Renderer, "unused", "clazz.GeneratedName+\".generated.cs\"");
List<string> args = new List<string>();
args.Add("--config=" + configFile.FullName);
args.AddRange(hbms);
FileObserver fo = new FileObserver();
CodeGenerator.Generate(args.ToArray(), fo);
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters options = new CompilerParameters();
options.GenerateInMemory = true;
options.ReferencedAssemblies.Add(typeof(ISet).Assembly.Location);
options.OutputAssembly = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assemblyName + ".dll");
options.GenerateInMemory = false;
CompilerResults res = provider.CompileAssemblyFromFile(options, fo.Files);
foreach (var e in res.Errors)
Console.WriteLine("Compiler Error:" + e);
Assert.AreEqual(0, res.Errors.Count);
return res.CompiledAssembly;
}
static void Main(string[] args)
{
try
{
var arguments = Args.Parse<Arguments>(args);
var param = new CompilerParameters
{
GenerateExecutable = false,
IncludeDebugInformation = false,
GenerateInMemory = true
};
param.ReferencedAssemblies.Add("System.dll");
param.ReferencedAssemblies.Add("System.Xml.dll");
param.ReferencedAssemblies.Add("System.Data.dll");
param.ReferencedAssemblies.Add("System.Core.dll");
param.ReferencedAssemblies.Add("System.Xml.Linq.dll");
//new Dictionary<String, String> {{"CompilerVersion", "v3.5"}}
var codeProvider = new CSharpCodeProvider();
var results = codeProvider.CompileAssemblyFromFile(param, arguments.ClassFile);
if (results.Errors.HasErrors)
{
foreach (var error in results.Errors)
{
Console.WriteLine(error);
}
}
else
{
object o = results.CompiledAssembly.CreateInstance(arguments.TypeName);
if (o == null)
{
Console.WriteLine("Unable to instantiate type " + arguments.TypeName);
}
else
{
var fixture = new Fixture();
var createMethod = typeof (SpecimenFactory).
GetMethod("Create", new[] {typeof (ISpecimenBuilder)}).
MakeGenericMethod(o.GetType());
var populated = createMethod.Invoke(null, new object[] {fixture});
var serializer = new XmlSerializer(populated.GetType());
var writer = new StreamWriter(arguments.TypeName + ".xml");
serializer.Serialize(writer, populated);
}
}
}
catch (ArgException e)
{
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate<Arguments>());
}
}
public static CompilerResults CompileFromCSharpSourceFile(String sourceFile, CompilerParameters cParams)
{
using (CodeDomProvider provider = new CSharpCodeProvider())
{
CompilerResults res = provider.CompileAssemblyFromFile(cParams, sourceFile);
return res;
}
}
/// <summary>
/// Complie
/// <param name="log">log</param>
/// </summary>
public bool Complie(ref string log)
{
var files = DirectoryHelper.GetAllFiles(new DirectoryInfo(path), "*.cs");
bool result;
if (files.Count == 0)
{
result = true;
}
else
{
if (File.Exists(target))
{
File.Delete(target);
}
CompilerResults res = null;
CodeDomProvider compiler = new CSharpCodeProvider();
CompilerParameters param = new CompilerParameters(@using, target, false);
param.GenerateExecutable = false;
param.GenerateInMemory = false;
param.WarningLevel = 2;
param.CompilerOptions = "/lib:.";
string[] filepaths = new string[files.Count];
for (int i = 0; i < files.Count; i++)
{
filepaths[i] = ((FileInfo)files[i]).FullName;
}
res = compiler.CompileAssemblyFromFile(param, filepaths);
if (res.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError err in res.Errors)
{
if (!err.IsWarning)
{
StringBuilder builder = new StringBuilder();
builder.Append(" ");
builder.Append(err.FileName);
builder.Append(" Line:");
builder.Append(err.Line);
builder.Append(" Col:");
builder.Append(err.Column);
sb.Append("Script compilation failed because: "+err.ErrorText+builder.ToString());
sb.Append("\r\n");
}
}
log = sb.ToString();
error = log;
result = false;
return result;
}
result = true;
}
log = "Success!";
return result;
}
private static bool CompileConfiguration()
{
var compiler = new CSharpCodeProvider();
var parameters = new CompilerParameters(
assemblyNames: new[] { "mscorlib.dll", "System.Core.dll", "SimpleBootstrap.exe" },
outputName: ConfigurationAssembly(),
includeDebugInformation: true);
var results = compiler.CompileAssemblyFromFile(parameters, new[] { ConfigurationSource() });
results.Errors.Cast<CompilerError>().ToList().ForEach(Console.WriteLine);
return results.Errors.Count == 0;
}
public CompilerResults Compile(string[] files, string assemblyName, bool generateExecutable, bool generateInMemory)
{
CSharpCodeProvider provider = new CSharpCodeProvider ();
CompilerParameters cp = new CompilerParameters ();
cp.GenerateExecutable = generateExecutable;
cp.GenerateInMemory = generateInMemory;
cp.OutputAssembly = assemblyName;
cp.ReferencedAssemblies.Add ("System.dll");
CompilerResults cr = provider.CompileAssemblyFromFile (cp, files);
//cr.PathToAssembly = Path.Combine (AppDomain.CurrentDomain.BaseDirectory, "test.dll");
return cr;
}
protected static string CompileApp(string appName, params string[] files)
{
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string destinationDirectory = Path.Combine(directory, IntPtr.Size.ToString());
string destination = Path.Combine(destinationDirectory, appName + ".exe");
string pdbPath = Path.Combine(destinationDirectory, appName + ".pdb");
string[] fullPathFiles = files.Select(f => Path.Combine(directory, "CLR", "Apps", f)).ToArray();
Directory.CreateDirectory(destinationDirectory);
// Check if we need to compile at all
if (File.Exists(destination) && File.Exists(pdbPath))
{
bool upToDate = true;
foreach (var file in fullPathFiles)
{
if (File.GetLastWriteTimeUtc(file) > File.GetLastWriteTimeUtc(destination))
{
upToDate = false;
break;
}
}
if (upToDate)
{
return destination;
}
}
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("system.dll");
cp.GenerateInMemory = false;
cp.GenerateExecutable = true;
cp.CompilerOptions = IntPtr.Size == 4 ? "/platform:x86" : "/platform:x64";
cp.IncludeDebugInformation = true;
cp.OutputAssembly = destination;
CompilerResults cr = provider.CompileAssemblyFromFile(cp, fullPathFiles);
if (cr.Errors.Count > 0 && System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
Assert.AreEqual(0, cr.Errors.Count);
return cr.PathToAssembly;
}
private String GenerateDll()
{
String csName = "ConfigCommon.cs";
if (!File.Exists(csName))
{
return(String.Empty);
}
String dllName = csName.Substring(0, csName.LastIndexOf(".")) + ".dll";
CodeDomProvider codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.OutputAssembly = dllName;
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("protobuf-net.dll");
try
{
CompilerResults results = codeDomProvider.CompileAssemblyFromFile(parameters, csName);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
}
return(String.Empty);
}
}
catch (System.Exception)
{
return(String.Empty);
}
return(dllName);
}
internal static bool CreateAssemblyFromFile(string pathToFile, string saveTo)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
System.CodeDom.Compiler.CompilerResults results = codeProvider.CompileAssemblyFromFile(GenerateParameters(saveTo), pathToFile);
if (results.Errors.Count > 0)
{
foreach (System.CodeDom.Compiler.CompilerError err in results.Errors)
{
MessageBox.Show("Error in " + err.FileName + " at Line " + err.Line + ": " + err.ErrorText);
}
return false;
}
return true;
}
public Assembly CompileScriptFiles( String[] fullScriptFilePaths )
{
List<String> cSharpFiles = new List<String>();
#region Save as temp CS files
foreach( String file in fullScriptFilePaths )
{
StreamWriter
sw = new StreamWriter( file + ".cs" );
sw.Write( TransformScriptFileToCSharp( file ) );
sw.Close();
cSharpFiles.Add( file + ".cs" );
}
#endregion
Assembly assembly = null;
CSharpCodeProvider
codeProvider = new CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters
compilerParameters = new System.CodeDom.Compiler.CompilerParameters();
compilerParameters.GenerateExecutable = false;
compilerParameters.GenerateInMemory = false;
System.CodeDom.Compiler.CompilerResults
compilerResults = codeProvider.CompileAssemblyFromFile( compilerParameters, cSharpFiles.ToArray() );
foreach( System.CodeDom.Compiler.CompilerError error in compilerResults.Errors )
{
NotificationDetails
details = new NotificationDetails();
details.FileName = error.FileName;
details.Row = error.Column;
details.Collumn = error.Line;
details.Message = error.ErrorText;
if( error.IsWarning )
OnWarningOccured( this, details );
else
OnErrorOccured( this, details );
}
return assembly;
}
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);
}
}
private static string CompileCSharp(string source)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("system.dll");
cp.GenerateExecutable = true;
cp.GenerateInMemory = false;
cp.CompilerOptions = IntPtr.Size == 4 ? "/platform:x86" : "/platform:amd64";
cp.IncludeDebugInformation = true;
cp.OutputAssembly = Path.Combine(Helpers.TestWorkingDirectory, Path.ChangeExtension(Path.GetFileNameWithoutExtension(source), "exe"));
CompilerResults cr = provider.CompileAssemblyFromFile(cp, source);
Assert.AreEqual(0, cr.Errors.Count);
return cr.PathToAssembly;
}
public Interpreter(string name,
bool forceRecompilation,
bool forbidCompilation)
{
this.name = name;
string assetName = Path.GetFileNameWithoutExtension (name) + ".dll";
bool compilation = forceRecompilation || !File.Exists (assetName);
if (compilation && forbidCompilation) {
// compilation is mandatory... and forbidden
throw new Exception ("A compilation is mandatory, but the current settings forbids compilation. Sorry!");
}
if (compilation) {
if (!Directory.Exists (name)) {
// could not find script directory
throw new DirectoryNotFoundException (String.Format ("A compilation is mandatory for the assembly {0}, but the matching directory {1} cannot be found.",
assetName,
name));
}
// list all files
string[] scripts = Directory.GetFiles (name, "*.cs");
// do the compilation
CodeDomProvider provider = new CSharpCodeProvider ();
CompilerParameters parameters = new CompilerParameters ();
parameters.CompilerOptions = "/target:library";
parameters.GenerateExecutable = false;
parameters.OutputAssembly = String.Format (assetName);
parameters.IncludeDebugInformation = false;
parameters.ReferencedAssemblies.Add("LuxEngine.dll");
parameters.ReferencedAssemblies.Add(Environment.GetEnvironmentVariable("XNAGSv4") + @"References\Windows\x86\Microsoft.Xna.Framework.dll");
parameters.ReferencedAssemblies.Add(Environment.GetEnvironmentVariable("XNAGSv4") + @"References\Windows\x86\Microsoft.Xna.Framework.Game.dll");
CompilerResults results =
provider.CompileAssemblyFromFile (parameters,
scripts);
// check for errors
if (results.Errors.HasErrors) {
throw new Exception (String.Format ("The compilation of {0} failed.",
assetName));
}
this.assembly = results.CompiledAssembly;
} else {
// load the assembly
assembly = Assembly.LoadFrom (assetName);
}
}
/// <summary>
/// Loads all content from a folder hierarchy (overlaying anything already existing)
/// </summary>
/// <param name="project"></param>
/// <param name="path"></param>
public static void Load(DocProject project, string path)
{
// get all files within folder hierarchy
string pathSchema = path + @"\schemas";
IEnumerable <string> en = System.IO.Directory.EnumerateFiles(pathSchema, "*.cs", System.IO.SearchOption.AllDirectories);
List <string> list = new List <string>();
foreach (string s in en)
{
list.Add(s);
}
string[] files = list.ToArray();
Dictionary <string, string> options = new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
};
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(options);
System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateInMemory = true;
parms.GenerateExecutable = false;
parms.ReferencedAssemblies.Add("System.dll");
parms.ReferencedAssemblies.Add("System.Core.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll");
parms.ReferencedAssemblies.Add("System.Data.dll");
parms.ReferencedAssemblies.Add("System.Runtime.Serialization.dll");
parms.ReferencedAssemblies.Add("System.Xml.dll");
System.CodeDom.Compiler.CompilerResults results = prov.CompileAssemblyFromFile(parms, files);
System.Reflection.Assembly assem = results.CompiledAssembly;
// look through classes of assembly
foreach (Type t in assem.GetTypes())
{
string[] namespaceparts = t.Namespace.Split('.');
string schema = namespaceparts[namespaceparts.Length - 1];
DocSection docSection = null;
if (t.Namespace.EndsWith("Resource"))
{
docSection = project.Sections[7];
}
else if (t.Namespace.EndsWith("Domain"))
{
docSection = project.Sections[6];
}
else if (t.Namespace.Contains("Shared"))
{
docSection = project.Sections[5];
}
else
{
docSection = project.Sections[4]; // kernel, extensions
}
// find schema
DocSchema docSchema = null;
foreach (DocSchema docEachSchema in docSection.Schemas)
{
if (docEachSchema.Name.Equals(schema))
{
docSchema = docEachSchema;
break;
}
}
if (docSchema == null)
{
docSchema = new DocSchema();
docSchema.Name = schema;
docSection.Schemas.Add(docSchema);
docSection.SortSchemas();
}
DocDefinition docDef = null;
if (t.IsEnum)
{
DocEnumeration docEnum = new DocEnumeration();
docSchema.Types.Add(docEnum);
docDef = docEnum;
System.Reflection.FieldInfo[] fields = t.GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
foreach (System.Reflection.FieldInfo field in fields)
{
DocConstant docConst = new DocConstant();
docEnum.Constants.Add(docConst);
docConst.Name = field.Name;
DescriptionAttribute[] attrs = (DescriptionAttribute[])field.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length == 1)
{
docConst.Documentation = attrs[0].Description;
}
}
}
else if (t.IsValueType)
{
DocDefined docDefined = new DocDefined();
docSchema.Types.Add(docDefined);
docDef = docDefined;
PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
docDefined.DefinedType = fields[0].PropertyType.Name;
}
else if (t.IsInterface)
{
DocSelect docSelect = new DocSelect();
docSchema.Types.Add(docSelect);
docDef = docSelect;
}
else if (t.IsClass)
{
DocEntity docEntity = new DocEntity();
docSchema.Entities.Add(docEntity);
docDef = docEntity;
if (t.BaseType != typeof(object))
{
docEntity.BaseDefinition = t.BaseType.Name;
}
if (!t.IsAbstract)
{
docEntity.EntityFlags = 0x20;
}
Dictionary <int, DocAttribute> attrsDirect = new Dictionary <int, DocAttribute>();
List <DocAttribute> attrsInverse = new List <DocAttribute>();
PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
foreach (PropertyInfo field in fields)
{
DocAttribute docAttr = new DocAttribute();
docAttr.Name = field.Name.Substring(1);
Type typeField = field.PropertyType;
if (typeField.IsGenericType)
{
Type typeGeneric = typeField.GetGenericTypeDefinition();
typeField = typeField.GetGenericArguments()[0];
if (typeGeneric == typeof(Nullable <>))
{
docAttr.IsOptional = true;
}
else if (typeGeneric == typeof(ISet <>))
{
docAttr.AggregationType = (int)DocAggregationEnum.SET;
}
else if (typeGeneric == typeof(IList <>))
{
docAttr.AggregationType = (int)DocAggregationEnum.LIST;
}
}
docAttr.DefinedType = typeField.Name;
MinLengthAttribute mla = (MinLengthAttribute)field.GetCustomAttribute(typeof(MinLengthAttribute));
if (mla != null)
{
docAttr.AggregationLower = mla.Length.ToString();
}
MaxLengthAttribute mxa = (MaxLengthAttribute)field.GetCustomAttribute(typeof(MaxLengthAttribute));
if (mxa != null)
{
docAttr.AggregationUpper = mxa.Length.ToString();
}
PropertyInfo propinfo = t.GetProperty(docAttr.Name);
if (propinfo != null)
{
DescriptionAttribute da = (DescriptionAttribute)propinfo.GetCustomAttribute(typeof(DescriptionAttribute));
if (da != null)
{
docAttr.Documentation = da.Description;
}
}
DataMemberAttribute dma = (DataMemberAttribute)field.GetCustomAttribute(typeof(DataMemberAttribute));
if (dma != null)
{
attrsDirect.Add(dma.Order, docAttr);
RequiredAttribute rqa = (RequiredAttribute)field.GetCustomAttribute(typeof(RequiredAttribute));
if (rqa == null)
{
docAttr.IsOptional = true;
}
CustomValidationAttribute cva = (CustomValidationAttribute)field.GetCustomAttribute(typeof(CustomValidationAttribute));
if (cva != null)
{
docAttr.IsUnique = true;
}
}
else
{
InversePropertyAttribute ipa = (InversePropertyAttribute)field.GetCustomAttribute(typeof(InversePropertyAttribute));
if (ipa != null)
{
docAttr.Inverse = ipa.Property;
attrsInverse.Add(docAttr);
}
}
// xml
XmlIgnoreAttribute xia = (XmlIgnoreAttribute)field.GetCustomAttribute(typeof(XmlIgnoreAttribute));
if (xia != null)
{
docAttr.XsdFormat = DocXsdFormatEnum.Hidden;
}
else
{
XmlElementAttribute xea = (XmlElementAttribute)field.GetCustomAttribute(typeof(XmlElementAttribute));
if (xea != null)
{
if (!String.IsNullOrEmpty(xea.ElementName))
{
docAttr.XsdFormat = DocXsdFormatEnum.Element;
}
else
{
docAttr.XsdFormat = DocXsdFormatEnum.Attribute;
}
}
}
}
foreach (DocAttribute docAttr in attrsDirect.Values)
{
docEntity.Attributes.Add(docAttr);
}
foreach (DocAttribute docAttr in attrsInverse)
{
docEntity.Attributes.Add(docAttr);
}
// get derived attributes based on properties
PropertyInfo[] props = t.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
foreach (PropertyInfo prop in props)
{
// if no backing field, then derived
FieldInfo field = t.GetField("_" + prop.Name, BindingFlags.NonPublic | BindingFlags.Instance);
if (field == null)
{
DocAttribute docDerived = new DocAttribute();
docDerived.Name = prop.Name;
docEntity.Attributes.Add(docDerived);
}
}
}
if (docDef != null)
{
docDef.Name = t.Name;
docDef.Uuid = t.GUID;
}
docSchema.SortTypes();
docSchema.SortEntities();
}
// pass 2: hook up selects
foreach (Type t in assem.GetTypes())
{
Type[] typeInterfaces = t.GetInterfaces();
if (typeInterfaces.Length > 0)
{
foreach (Type typeI in typeInterfaces)
{
DocSelect docSelect = project.GetDefinition(typeI.Name) as DocSelect;
if (docSelect != null)
{
DocSelectItem docItem = new DocSelectItem();
docItem.Name = t.Name;
docSelect.Selects.Add(docItem);
}
}
}
}
// EXPRESS rules (eventually in C#, though .exp file snippets for now)
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.exp", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
string expr = null;
using (StreamReader readExpr = new StreamReader(file, Encoding.UTF8))
{
expr = readExpr.ReadToEnd();
}
if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocWhereRule docWhere = new DocWhereRule();
docWhere.Name = parts[1];
docWhere.Expression = expr;
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef == null)
{
//... global rule...
}
}
}
else
{
// function
string schema = Path.GetDirectoryName(file);
schema = Path.GetDirectoryName(schema);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
DocFunction docFunction = new DocFunction();
docSchema.Functions.Add(docFunction);
docFunction.Name = name;
docFunction.Expression = expr;
}
}
}
// now, hook up html documentation
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.htm", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
DocObject docObj = null;
if (name == "schema")
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
docObj = project.GetSchema(schema);
}
else if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
}
}
else
{
docObj = project.GetDefinition(name);
if (docObj == null)
{
docObj = project.GetFunction(name);
}
}
if (docObj != null)
{
using (StreamReader readHtml = new StreamReader(file, Encoding.UTF8))
{
docObj.Documentation = readHtml.ReadToEnd();
}
}
}
// load schema diagrams
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.svg", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
using (IfcDoc.Schema.SVG.SchemaSVG schemaSVG = new IfcDoc.Schema.SVG.SchemaSVG(file, docSchema, project))
{
schemaSVG.Load();
}
}
}
// psets, qsets
//...
// exchanges
en = System.IO.Directory.EnumerateFiles(path, "*.mvdxml", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
IfcDoc.Schema.MVD.SchemaMVD.Load(project, file);
}
// examples
string pathExamples = path + @"\examples";
if (Directory.Exists(pathExamples))
{
en = System.IO.Directory.EnumerateFiles(pathExamples, "*.htm", SearchOption.TopDirectoryOnly);
foreach (string file in en)
{
DocExample docExample = new DocExample();
docExample.Name = Path.GetFileNameWithoutExtension(file);
project.Examples.Add(docExample);
using (StreamReader reader = new StreamReader(file))
{
docExample.Documentation = reader.ReadToEnd();
}
string dirpath = file.Substring(0, file.Length - 4);
if (Directory.Exists(dirpath))
{
IEnumerable <string> suben = System.IO.Directory.EnumerateFiles(dirpath, "*.ifc", SearchOption.TopDirectoryOnly);
foreach (string ex in suben)
{
DocExample docEx = new DocExample();
docEx.Name = Path.GetFileNameWithoutExtension(ex);
docExample.Examples.Add(docEx);
// read the content of the file
using (FileStream fs = new FileStream(ex, FileMode.Open, FileAccess.Read))
{
docEx.File = new byte[fs.Length];
fs.Read(docEx.File, 0, docEx.File.Length);
}
// read documentation
string exdoc = ex.Substring(0, ex.Length - 4) + ".htm";
if (File.Exists(exdoc))
{
using (StreamReader reader = new StreamReader(exdoc))
{
docEx.Documentation = reader.ReadToEnd();
}
}
}
}
}
}
// localization
en = System.IO.Directory.EnumerateFiles(path, "*.txt", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
using (FormatCSV format = new FormatCSV(file))
{
try
{
format.Instance = project;
format.Load();
}
catch
{
}
}
}
}
/// <summary>
/// Loads all content from a folder hierarchy (overlaying anything already existing)
/// </summary>
/// <param name="project"></param>
/// <param name="path"></param>
public static void LoadFolder(DocProject project, string path)
{
// get all files within folder hierarchy
string pathSchema = path + @"\schemas";
IEnumerable <string> en = System.IO.Directory.EnumerateFiles(pathSchema, "*.cs", System.IO.SearchOption.AllDirectories);
List <string> list = new List <string>();
foreach (string s in en)
{
list.Add(s);
}
string[] files = list.ToArray();
Dictionary <string, string> options = new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
};
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(options);
System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateInMemory = true;
parms.GenerateExecutable = false;
parms.ReferencedAssemblies.Add("System.dll");
parms.ReferencedAssemblies.Add("System.Core.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll");
parms.ReferencedAssemblies.Add("System.Data.dll");
parms.ReferencedAssemblies.Add("System.Runtime.Serialization.dll");
parms.ReferencedAssemblies.Add("System.Xml.dll");
System.CodeDom.Compiler.CompilerResults results = prov.CompileAssemblyFromFile(parms, files);
System.Reflection.Assembly assem = results.CompiledAssembly;
LoadAssembly(project, assem);
// EXPRESS rules (eventually in C#, though .exp file snippets for now)
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.exp", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
string expr = null;
using (StreamReader readExpr = new StreamReader(file, Encoding.UTF8))
{
if (name.Contains('-'))
{
// where rule
expr = readExpr.ReadToEnd();
}
else
{
// function: skip first and last lines
readExpr.ReadLine();
StringBuilder sbExpr = new StringBuilder();
while (!readExpr.EndOfStream)
{
string line = readExpr.ReadLine();
if (!readExpr.EndOfStream)
{
sbExpr.AppendLine(line);
}
}
expr = sbExpr.ToString();
}
}
if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocWhereRule docWhere = new DocWhereRule();
docWhere.Name = parts[1];
docWhere.Expression = expr;
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef == null)
{
//... global rule...
}
}
}
else
{
// function
string schema = Path.GetDirectoryName(file);
schema = Path.GetDirectoryName(schema);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
DocFunction docFunction = new DocFunction();
docSchema.Functions.Add(docFunction);
docFunction.Name = name;
docFunction.Expression = expr;
}
}
}
// now, hook up html documentation
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.htm", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
DocObject docObj = null;
if (name == "schema")
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
docObj = project.GetSchema(schema);
}
else if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
}
}
else
{
docObj = project.GetDefinition(name);
if (docObj == null)
{
docObj = project.GetFunction(name);
}
}
if (docObj != null)
{
using (StreamReader readHtml = new StreamReader(file, Encoding.UTF8))
{
docObj.Documentation = readHtml.ReadToEnd();
}
}
}
// load schema diagrams
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.svg", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
using (IfcDoc.Schema.SVG.SchemaSVG schemaSVG = new IfcDoc.Schema.SVG.SchemaSVG(file, docSchema, project, DiagramFormat.UML))
{
schemaSVG.Load();
}
}
}
// psets, qsets
//...
// exchanges
en = System.IO.Directory.EnumerateFiles(path, "*.mvdxml", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
IfcDoc.Schema.MVD.SchemaMVD.Load(project, file);
}
// examples
string pathExamples = path + @"\examples";
if (Directory.Exists(pathExamples))
{
en = System.IO.Directory.EnumerateFiles(pathExamples, "*.htm", SearchOption.TopDirectoryOnly);
foreach (string file in en)
{
DocExample docExample = new DocExample();
docExample.Name = Path.GetFileNameWithoutExtension(file);
project.Examples.Add(docExample);
using (StreamReader reader = new StreamReader(file))
{
docExample.Documentation = reader.ReadToEnd();
}
string dirpath = file.Substring(0, file.Length - 4);
if (Directory.Exists(dirpath))
{
IEnumerable <string> suben = System.IO.Directory.EnumerateFiles(dirpath, "*.ifc", SearchOption.TopDirectoryOnly);
foreach (string ex in suben)
{
DocExample docEx = new DocExample();
docEx.Name = Path.GetFileNameWithoutExtension(ex);
docExample.Examples.Add(docEx);
// read the content of the file
using (FileStream fs = new FileStream(ex, FileMode.Open, FileAccess.Read))
{
docEx.File = new byte[fs.Length];
fs.Read(docEx.File, 0, docEx.File.Length);
}
// read documentation
string exdoc = ex.Substring(0, ex.Length - 4) + ".htm";
if (File.Exists(exdoc))
{
using (StreamReader reader = new StreamReader(exdoc))
{
docEx.Documentation = reader.ReadToEnd();
}
}
}
}
}
}
// localization
en = System.IO.Directory.EnumerateFiles(path, "*.txt", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
using (FormatCSV format = new FormatCSV(file))
{
try
{
format.Instance = project;
format.Load();
}
catch
{
}
}
}
}