/// <summary>
/// Converte para as informações do assembly.
/// </summary>
/// <param name="data"></param>
/// <param name="fileName"></param>
/// <returns></returns>
private static AssemblyInfo ConvertAssemblyInfo(AsmData data, string fileName)
{
var info = new AssemblyInfo {
Name = System.IO.Path.GetFileNameWithoutExtension(fileName),
LastWriteTime = System.IO.File.GetLastWriteTime(fileName),
References = data.References.Select(f => f.Name).ToArray()
};
return(info);
}
public void FlushAsmFile()
{
// Flush String Data table
FlushStringDataTable();
VTableFlush();
// Add a label of Kernel End, it is used by our heap to know from where it starts allocating memory
Core.AssemblerCode.Add(new Label("Compiler_End"));
using (var xWriter = new StreamWriter(ILCompiler.OutputFile, false))
{
foreach (var Header in Core.NasmHeaders)
{
xWriter.WriteLine(Header);
}
// if any BSS data is contained or not
if (Core.DataMemberBssSegmentIndex > 0)
{
BssSectionHeader(xWriter);
}
// Firstly add datamember
bool IsFlagged = true;
foreach (var AsmData in Core.DataMember)
{
if (AsmData.IsBssData == false && IsFlagged == true)
{
IsFlagged = false;
DataSectionHeader(xWriter);
}
AsmData.FlushText(xWriter);
}
TextSectionHeader(xWriter);
if (DoOptimization)
{
//Try to execute optimizer
try { Core.AssemblerCode = new Worker(Core.AssemblerCode).Start(); }
catch (Exception e) { Console.WriteLine("Optimization-Exception:" + e.ToString()); }
}
foreach (var instruction in Core.AssemblerCode)
{
if (instruction is Label)
{
xWriter.WriteLine();
instruction.FlushText(xWriter);
}
else
{
xWriter.Write(" ");
if (instruction is Call)
{
var InstCall = instruction as Call;
if (InstCall.FunctionLabel)
{
Call.FlushText(xWriter, (Core.StaticLabels[InstCall.Address] as MethodBase).FullName());
continue;
}
}
instruction.FlushText(xWriter);
}
}
}
}
private AssemblyPackageContainer GetAssemblyPackageFromLocal(IEnumerable <AssemblyPart> assemblyParts)
{
var assemblyNames = new List <string>();
List <string> files = new List <string>();
foreach (var dir in _assemblyFilesDirectories)
{
try
{
foreach (var file in System.IO.Directory.GetFiles(dir).Select(f => System.IO.Path.GetFileName(f)).OrderBy(f => f))
{
var index = files.BinarySearch(file, StringComparer.OrdinalIgnoreCase);
if (index < 0)
{
files.Insert(~index, file);
}
}
}
catch (Exception ex)
{
throw new DetailsException(ResourceMessageFormatter.Create(() => Properties.Resources.AssemblyRepository_GetFilesFromRepositoryDirectoryError, dir), ex);
}
}
var parts2 = assemblyParts.ToArray();
IComparer <string> comparer = StringComparer.Create(System.Globalization.CultureInfo.InvariantCulture, true);
foreach (var part in parts2)
{
var index = files.BinarySearch(part.Source, comparer);
if (index >= 0)
{
assemblyNames.Add(files[index]);
}
}
var analyzer = new AssemblyAnalyzer();
var assemblyPaths = new List <string>();
var names = new List <string>();
if (_assemblyInfoRepository != null)
{
AssemblyInfo info = null;
Exception exception = null;
var infos = new Queue <AssemblyInfo>();
var pending = new Queue <string>(assemblyNames);
while (pending.Count > 0)
{
var assemblyName = pending.Dequeue();
if (names.FindIndex(f => StringComparer.InvariantCultureIgnoreCase.Equals(f, assemblyName)) < 0)
{
if (!_assemblyInfoRepository.TryGet(System.IO.Path.GetFileNameWithoutExtension(assemblyName), out info, out exception))
{
continue;
}
foreach (var i in info.References)
{
pending.Enqueue(i + ".dll");
}
names.Add(assemblyName);
foreach (var dir in _assemblyFilesDirectories)
{
if (System.IO.File.Exists(System.IO.Path.Combine(dir, assemblyName)))
{
assemblyPaths.Add(System.IO.Path.Combine(dir, assemblyName));
}
}
}
}
}
else
{
foreach (var assemblyName in assemblyNames)
{
string assemblyPath = null;
foreach (var dir in _assemblyFilesDirectories)
{
assemblyPath = System.IO.Path.Combine(dir, assemblyName);
if (System.IO.File.Exists(assemblyPath))
{
break;
}
}
AsmData data = null;
try
{
data = analyzer.AnalyzeRootAssembly(assemblyPath);
}
catch (Exception ex)
{
throw new DetailsException(ResourceMessageFormatter.Create(() => Properties.Resources.AssemblyRepository_AnalyzeAssemblyError, assemblyName), ex);
}
var queue = new Queue <AsmData>();
queue.Enqueue(data);
while (queue.Count > 0)
{
data = queue.Dequeue();
if (string.IsNullOrEmpty(data.Path))
{
continue;
}
var fileName = System.IO.Path.GetFileName(data.Path);
var index = names.FindIndex(f => StringComparer.InvariantCultureIgnoreCase.Equals(f, fileName));
if (index < 0)
{
names.Add(fileName);
assemblyPaths.Add(data.Path);
}
foreach (var i in data.References)
{
if (!string.IsNullOrEmpty(i.Path) && names.FindIndex(f => f == System.IO.Path.GetFileName(i.Path)) < 0)
{
queue.Enqueue(i);
}
}
}
}
}
names.Reverse();
var languages = new IO.Xap.LanguageInfo[] {
new IO.Xap.LanguageInfo(new string[] {
".dll"
}, names.ToArray(), "")
};
var configuration = new IO.Xap.XapConfiguration(new IO.Xap.AppManifestTemplate(), languages, null);
if (assemblyPaths.Count > 0 && UseDirectoryAssemblyPackages)
{
return(new AssemblyPackageContainer(new DirectoryAssemblyPackage(_assemblyResolverManager, assemblyPaths)));
}
else if (assemblyPaths.Count > 0)
{
assemblyPaths.Reverse();
var entries = assemblyPaths.Select(f => {
var fileInfo = new System.IO.FileInfo(f);
return(new IO.Xap.XapBuilder.XapEntry(fileInfo.Name, new Lazy <System.IO.Stream>(() => fileInfo.OpenRead()), fileInfo.LastWriteTime));
}).ToArray();
var pkgUid = Guid.NewGuid();
try
{
var fileName = GetAssemblyPackageLocalFileName(pkgUid);
if (System.IO.File.Exists(fileName))
{
System.IO.File.Delete(fileName);
}
IO.Xap.XapBuilder.XapToDisk(configuration, entries, fileName);
var pkg = new AssemblyPackageResult(_assemblyResolverManager, pkgUid, fileName).CreatePackage();
lock (_objLock)
_packages.Add(new AssemblyPackageCacheEntry(pkg, null, fileName));
return(new AssemblyPackageContainer(pkg));
}
finally
{
foreach (var i in entries)
{
i.Dispose();
}
}
}
else
{
lock (_objLock)
_packages.Add(new AssemblyPackageCacheEntry(null, parts2, null));
return(null);
}
}
