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); }