public ConvertedAssemblyNode EnsureNode(ILConversion conversion, StructuralAssemblyNode inputStructuralNode)
{
if (conversion.MetadataModel.Assemblies.ByMetadataId.TryGetValue(inputStructuralNode.MetadataId, out ConvertedAssemblyNode convertedAssemblyNode))
{
return(convertedAssemblyNode);
}
var guid = Guid.NewGuid();
var fullName = Assemblies.Naming.GetAssemblyName(conversion, inputStructuralNode.FullName, guid);
convertedAssemblyNode = new ConvertedAssemblyNode()
{
Guid = guid,
Id = Runtimic.Identification.IssueId(conversion.RuntimicSystem),
InputStructuralNode = inputStructuralNode,
MetadataId = inputStructuralNode.MetadataId,
InputFullName = inputStructuralNode.FullName,
FullName = fullName
};
conversion.MetadataModel.Assemblies.ById.Add(convertedAssemblyNode.Id, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.ByMetadataId.Add(inputStructuralNode.MetadataId, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.ByName.Add(convertedAssemblyNode.FullName, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.BySourceName.Add(convertedAssemblyNode.InputFullName, convertedAssemblyNode);
convertedAssemblyNode.ConvertedAssembly = Assemblies.Creation.CreateConvertedAssembly(conversion, convertedAssemblyNode.FullName, convertedAssemblyNode);
return(convertedAssemblyNode);
}
public ConvertedModuleNode Ensure(ILConversion conversion, ConvertedAssemblyNode assemblyNode, StructuralModuleNode structuralModule)
{
if (conversion.MetadataModel.Modules.ByVersionId.TryGetValue(structuralModule.VersionId, out ConvertedModuleNode node))
{
return(node);
}
var moduleNode = new ConvertedModuleNode()
{
AssemblyNode = assemblyNode,
InputStructuralDefinition = structuralModule
};
conversion.MetadataModel.Modules.ByVersionId.Add(structuralModule.VersionId, moduleNode);
moduleNode.ConvertedModule = Modules.Creation.Create(conversion, moduleNode);
return(moduleNode);
}
public ILConversionResult Convert(ILConversion conversion)
{
// Build the configuration before doing anything else, as the configuration can affect anything else that happens.
Configurational.BuildConfiguration(conversion, conversion.Input.Options);
// If there is no runtimic system associated with the conversion, create one.
if (conversion.RuntimicSystem == null)
{
conversion.RuntimicSystem = new RuntimicSystemModel();
}
// Make sure the runatmic system whether created or passed in is adequetly built out.
Runtimic.Models.EnsureMinimumRuntimicSystem(conversion.RuntimicSystem);
// Ensure all the types, assemblies, and assembly definitions are turned into a list of type references that need to be converted.
Initialization.ProcessInputs(conversion);
try
{
ConvertedAssemblyNode[] completeAssembliesToConvert = new ConvertedAssemblyNode[(conversion.Input.AssembliesToConvert?.Length ?? 0) +
(conversion.Input.AssemblyStreamsToConvert?.Length ?? 0)];
// need to make a list of all assemblies that are being converted, so if they come up in the process of being converted,
// they are resolved.
var assembliesToConvertLength = conversion.Input.AssembliesToConvert?.Length ?? 0;
for (int i = 0; i < assembliesToConvertLength; i++)
{
// ReSharper disable once PossibleNullReferenceException
var currentAssembly = conversion.Input.AssembliesToConvert[i];
completeAssembliesToConvert[i] = Conversion.Metadata.Assemblies.EnsureNode(conversion, currentAssembly);
}
int offset = assembliesToConvertLength;
for (int i = 0; i < conversion.Input.AssemblyStreamsToConvert?.Length; i++)
{
var currentAssemblyStream = conversion.Input.AssemblyStreamsToConvert[i];
completeAssembliesToConvert[i + offset] = Conversion.Metadata.Assemblies.EnsureNode(conversion, currentAssemblyStream);
}
Dictionary <string, ConvertedAssemblyNode> nodes = null;
if (conversion.Input.TypesToConvert?.Length > 0)
{
nodes = new Dictionary <string, ConvertedAssemblyNode>();
for (int i = 0; i < completeAssembliesToConvert.Length; i++)
{
nodes.Add(completeAssembliesToConvert[i].InputFullName, completeAssembliesToConvert[i]);
}
for (int i = 0; i < conversion.Input.TypesToConvert.Length; i++)
{
var currentAssembly = conversion.Input.TypesToConvert[i].Assembly;
if (!nodes.ContainsKey(currentAssembly.FullName))
{
var conversionAssemblyNode = Conversion.Metadata.Assemblies.EnsureNode(conversion, currentAssembly);
nodes.Add(conversionAssemblyNode.InputFullName, conversionAssemblyNode);
}
}
}
for (int i = 0; i < completeAssembliesToConvert.Length; i++)
{
var currentAssemblyNode = completeAssembliesToConvert[i];
if (currentAssemblyNode.IsEntireAssemblyConverted)
{
continue;
}
currentAssemblyNode.IsEntireAssemblyConverted = true;
var assemblyDefinition = currentAssemblyNode.InputStructuralNode.CecilAssemblyDefinition;
for (int j = 0; j < assemblyDefinition.Modules.Count; j++)
{
var currentModule = assemblyDefinition.Modules[j];
var types = currentModule.Types;
for (int k = 0; k < types.Count; k++)
{
if (types[k].MetadataToken.ToInt32() == 0x02000001)
{
continue;
}
Execution.Types.Ensuring.Ensure(new ExecutionEnsureContext()
{
AssemblyNode = currentAssemblyNode,
ModuleDefinition = currentModule,
TypeReference = types[k],
IsConverted = true,
Conversion = conversion,
RuntimicSystem = conversion.RuntimicSystem
});
}
}
}
Type[] outputTypes = null;
if (conversion.Input.TypesToConvert != null && conversion.Input.TypesToConvert.Length > 0)
{
var typesToConvertLength = conversion.Input.TypesToConvert.Length;
var inputList = new Dictionary <string, Type>(typesToConvertLength);
for (var i = 0; i < conversion.Input.TypesToConvert.Length; i++)
{
var type = conversion.Input.TypesToConvert[i];
DecomposeGenericInstances(nodes, inputList, type);
}
outputTypes = inputList.Values.ToArray();
for (var i = 0; i < outputTypes.Length; i++)
{
var underlyingType = outputTypes[i];
var executionTypeNode = Execution.Types.Ensuring.Ensure(new ExecutionEnsureContext()
{
UnderlyingType = underlyingType,
IsConverted = true,
Conversion = conversion,
RuntimicSystem = conversion.RuntimicSystem
});
// ReSharper disable once PossibleNullReferenceException
outputTypes[i] = executionTypeNode.Type.UnderlyingType;
}
}
var assemblies = GetAssemblies(conversion.MetadataModel.Assemblies.ById.Values.ToList());
if (conversion.Input.TypesToConvert != null && conversion.Input.TypesToConvert.Length > 0)
{
var typeDictionary = XCommonAppPal.Api.Runtimic.Execution.Metadata.Assemblies.GetTypes(assemblies);
for (int i = 0; i < conversion.Input.TypesToConvert.Length; i++)
{
try
{
var inputType = conversion.Input.TypesToConvert[i];
outputTypes[i] = XCommonAppPal.Api.Runtimic.Execution.Metadata.Assemblies.GetType(typeDictionary, inputType);
}
catch (Exception e)
{
conversion.Result.Exceptions.Add(e);
throw;
}
}
}
CreateDesiredOutput(conversion, outputTypes, assemblies);
return(conversion.Result);
}
finally
{
CloseStreams(conversion);
}
}
public ConvertedAssembly CreateConvertedAssembly(ILConversion conversion, string name, ConvertedAssemblyNode assemblyNode)
{
var assemblyName = new AssemblyName(name)
{
Version = assemblyNode.InputStructuralNode.CecilAssemblyDefinition.Name.Version
};
// compiler crash / compiler error - do not put this line with initializer.
// If you use a fullname with version, public key, etc. It will crash the compiler
var builder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, conversion.Configuration.BuilderAccess);
var convertedAssembly = new ConvertedAssembly()
{
AssemblyBuilder = builder,
Name = name,
FullName = name,
AssemblyNode = assemblyNode,
Conversion = conversion,
};
return(convertedAssembly);
}
