public ConversionTypeNode EnsureTypeNode(ILConversion conversion, ConvertedModuleNode convertedModuleNode, Type type)
{
// By passing in the module node, the cecil system does not have to start from scratch looking for the type. It just needs to look at this module
// for the type.
//var structuralTypeNode = Cecil.Metadata.Members.Types.Ensuring.EnsureTypeNode(conversion.RuntimicSystem, convertedModuleNode.StructuralNode, type);
var structuralTypeNode = Structural.Types.Ensure(conversion.RuntimicSystem, type);
return(EnsureTypeNode(conversion, convertedModuleNode, structuralTypeNode));
}
public ConvertedModule Create(ILConversion conversion, ConvertedModuleNode moduleNode)
{
var assemblyNode = moduleNode.AssemblyNode;
ModuleDefinition moduleDefinition = moduleNode.InputStructuralDefinition.CecilModuleDefinition;
string name;
if (assemblyNode.Guid != Guid.Empty)
{
name = moduleDefinition.Name;
var lower = name.ToLower();
if (lower.EndsWith(".dll") || lower.EndsWith(".exe"))
{
var subName = name.Substring(0, lower.Length - 4);
var ending = name.Substring(lower.Length - 4, 4);
// When saving an assemlby, the module name has to equal the file name, as you are specifiying what module to save.
// You cannot specify what directory to save the assembly, so it is saved in the execution directory which can contain the source assembly with the
// same name. To prevent this, the module name has the assemblies guid appended to its name to prevent a name conflict.
name = $"{subName}_{assemblyNode.Guid.ToString("N")}{ending}";
}
else
{
name = $"{name}_{assemblyNode.Guid.ToString("N")}";
}
}
else
{
name = moduleDefinition.Name;
}
var module = new ConvertedModule()
{
ModuleBuilder = assemblyNode.ConvertedAssembly.AssemblyBuilder.DefineDynamicModule(name),
Name = name,
Assembly = assemblyNode.ConvertedAssembly,
SourceModuleDefinition = moduleDefinition,
Conversion = conversion,
};
return(module);
}
public ConversionTypeNode EnsureTypeNode(ILConversion conversion, ConvertedModuleNode convertedModuleNode, StructuralTypeNode structuralTypeNode)
{
// By passing in the module node, the cecil system does not have to start from scratch looking for the type. It just needs to look at this module
// for the type.
//var structuralTypeNode = Cecil.Metadata.Members.Types.Ensuring.EnsureTypeNode(conversion.RuntimicSystem, convertedModuleNode.StructuralNode, type);
//if (!structuralTypeNode.IsDerived)
//{
// ConvertedTypeTable table;
// var tableId = (int) (structuralTypeNode.MetadataToken & 0xFF000000);
// if (!convertedModuleNode.Tables.TryGetValue(tableId, out table))
// {
// table = new ConvertedTypeTable();
// convertedModuleNode.Tables.Add(tableId, table);
// }
// var rowId = structuralTypeNode.MetadataToken & 0x00FFFFFF;
// if (rowId > 0 && table.ByRow.TryGetValue(rowId, out ConversionTypeNode node))
// {
// return node;
// }
//}
//node = new ConversionTypeNode()
//{
// StemType = structuralTypeNode.StemType != null ? EnsureTypeNode(conversion, convertedModuleNode, structuralTypeNode.StemType) : null,
// InputStructuralNode = structuralTypeNode,
// IsDerived = structuralTypeNode.IsDerived
//};
//if (rowId > 0)
//{
// table.ByRow.Add(rowId, node);
//}
//return node;
throw new System.NotImplementedException();
}
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);
}
