void MatchExportedType(ExportedType exportedType, ModuleDefinition module, Regex regex, XPathNavigator nav)
{
if (regex.Match(exportedType.FullName).Success)
{
MarkingHelpers.MarkExportedType(exportedType, module);
TypeDefinition type = null;
try {
type = exportedType.Resolve();
}
catch (AssemblyResolutionException) {
}
if (type != null)
{
ProcessType(type, nav);
}
}
}
/// <summary>
/// Get the full name of an ExportedType, including namespace
/// </summary>
private static string GetExportedTypeFullName(MetadataReader mdReader, ExportedTypeHandle handle)
{
string typeNamespace = "";
string typeStr = "";
try
{
ExportedType exportedType = mdReader.GetExportedType(handle);
typeStr = "." + mdReader.GetString(exportedType.Name) + typeStr;
typeNamespace = mdReader.GetString(exportedType.Namespace);
}
catch (BadImageFormatException)
{
return(null);
}
return(typeNamespace + typeStr);
}
private static string GetFullName(MetadataReader reader, ExportedType type)
{
Debug.Assert(type.IsForwarder);
if (type.Implementation.Kind == HandleKind.AssemblyReference)
{
var name = reader.GetString(type.Name);
var ns = type.Namespace.IsNil ? null : reader.GetString(type.Namespace);
var fullName = string.IsNullOrEmpty(ns) ? name : ns + "." + name;
return(fullName);
}
if (type.Implementation.Kind == HandleKind.ExportedType)
{
var name = reader.GetString(type.Name);
Debug.Assert(type.Namespace.IsNil);
return(GetFullName(reader, reader.GetExportedType((ExportedTypeHandle)type.Implementation)) + "." + name);
}
throw new NotSupportedException(type.Implementation.Kind.ToString());
}
private uint AddImplementation(IImplementation implementation)
{
if (implementation is null)
{
return(0);
}
var token = implementation switch
{
AssemblyReference assemblyReference => GetAssemblyReferenceToken(assemblyReference),
ExportedType exportedType => AddExportedType(exportedType),
FileReference fileReference => AddFileReference(fileReference),
_ => throw new ArgumentOutOfRangeException(nameof(implementation))
};
return(Metadata.TablesStream
.GetIndexEncoder(CodedIndex.Implementation)
.EncodeToken(token));
}
public static TypeReference CreateReference(this ExportedType exportedType, ModuleDefinition exportingModule, ModuleDefinition targetModule)
{
var typeDef = exportedType.ResolveRequiredType();
var metadataScope = MapAssemblyReference(targetModule, exportingModule.Assembly.Name);
var typeRef = new TypeReference(exportedType.Namespace, exportedType.Name, exportingModule, metadataScope, typeDef.IsValueType)
{
DeclaringType = exportedType.DeclaringType?.CreateReference(exportingModule, targetModule)
};
if (typeDef.HasGenericParameters)
{
foreach (var param in typeDef.GenericParameters)
{
typeRef.GenericParameters.Add(new GenericParameter(param.Name, typeRef));
}
}
return(typeRef);
}
private void Commit()
{
ModuleDefinition victimModule = _victimAssembly.MainModule;
ModuleDefinition exportedModule = _exportedAssembly.MainModule;
AssemblyNameReference modReference = victimModule.AssemblyReferences.First(r => r.FullName == _exportedAssembly.MainModule.Assembly.Name.FullName);
foreach (TypeDefinition oldType in _terminators.Values)
{
victimModule.Types.Remove(oldType);
}
foreach (TypeExporter exporter in _exporters.Values)
{
TypeDefinition oldType = exporter.VictimType;
ExportedType exportedType = new ExportedType(oldType.Namespace, oldType.Name, exportedModule, modReference);
victimModule.Types.Remove(oldType);
victimModule.ExportedTypes.Add(exportedType);
}
}
private static void AddNestedTypes(TypeDefinition mainModuleType, ExportedType importedType, ModuleDefinition targetModule)
{
foreach (var nested in mainModuleType.NestedTypes)
{
if ((nested.Attributes & TypeAttributes.VisibilityMask) != TypeAttributes.NestedPublic)
{
continue;
}
var nestedImport = targetModule.ImportReference(nested);
var nestedExport = new ExportedType(nestedImport.Namespace, nestedImport.Name, nestedImport.Module, nestedImport.Scope)
{
Attributes = TypeAttributes.Forwarder
};
nestedExport.DeclaringType = importedType;
targetModule.ExportedTypes.Add(nestedExport);
AddNestedTypes(nested, nestedExport, targetModule);
}
}
public void Import(ExportedType type, Collection <ExportedType> col, ModuleDefinition module)
{
var scope = default(IMetadataScope);
// try to skip redirects to merged assemblies
if (type.Scope is AssemblyNameReference)
{
if (_repackContext.MergedAssemblies.Any(x => x.Name.Name == ((AssemblyNameReference)type.Scope).Name))
{
return;
}
scope = _repackContext.PlatformFixer.FixPlatformVersion(((AssemblyNameReference)type.Scope));
}
else if (type.Scope is ModuleReference)
{
if (_repackContext.MergedAssemblies.SelectMany(x => x.Modules).Any(x => x.Name == ((ModuleReference)type.Scope).Name))
{
return;
}
// TODO fix scope (should probably be added to target ModuleReferences, otherwise metadatatoken will be wrong)
// I've never seen an exported type redirected to a module, doing so would be blind guessing
scope = type.Scope;
}
if (type.IsForwarder)
{
// Skip duplicated forwarders
var fullName = type.FullName;
if (col.Any(t => t.IsForwarder && t.FullName == fullName))
{
return;
}
}
var nt = new ExportedType(type.Namespace, type.Name, module, scope)
{
Attributes = type.Attributes,
Identifier = type.Identifier, // TODO: CHECK THIS when merging multiple assemblies when exported types ?
DeclaringType = type.DeclaringType
};
col.Add(nt);
}
private Object ResolveExportedType(ExportedTypeHandle handle)
{
ExportedType exportedType = _metadataReader.GetExportedType(handle);
var implementation = GetObject(exportedType.Implementation, NotFoundBehavior.ReturnResolutionFailure);
if (implementation is ModuleDesc)
{
var module = (ModuleDesc)implementation;
string nameSpace = _metadataReader.GetString(exportedType.Namespace);
string name = _metadataReader.GetString(exportedType.Name);
MetadataType resolvedType = module.GetType(nameSpace, name, NotFoundBehavior.ReturnResolutionFailure);
if (resolvedType == null)
{
return(ModuleDesc.GetTypeResolutionFailure);
}
return(resolvedType);
}
else
if (implementation is MetadataType)
{
var type = (MetadataType)implementation;
string name = _metadataReader.GetString(exportedType.Name);
var nestedType = type.GetNestedType(name);
if (nestedType == null)
{
return(ResolutionFailure.GetTypeLoadResolutionFailure(name, this));
}
return(nestedType);
}
else if (implementation is ResolutionFailure)
{
return(implementation);
}
else
{
ThrowHelper.ThrowBadImageFormatException();
return(null);
}
}
static dynamic LoadFluentDesignUI()
{
try
{
var Dll = Assembly.LoadFile(Path.Combine(Directory.GetCurrentDirectory(), "KrkrExtract.UI.FluentDesign.dll"));
foreach (Type ExportedType in Dll.GetExportedTypes())
{
if (ExportedType.GetTypeInfo().Name == "KrkrExtractUIFluentDesign")
{
return(Activator.CreateInstance(ExportedType));
}
}
throw new EntryPointNotFoundException("KrkrExtractUIFluentDesign not found");
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "KrkrExtract (Loadind UI)", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
public void FixPlatformVersion(ExportedType exported)
{
if (exported == null)
{
return;
}
AssemblyNameReference scopeAsm = exported.Scope as AssemblyNameReference;
if (scopeAsm == null)
{
return;
}
var platformAsm = GetFixedPlatformVersion(scopeAsm);
if (platformAsm == null)
{
return;
}
exported.Scope = platformAsm;
}
private void InitilizeAssemblies(ProductVersion productVersion, string[] files)
{
foreach (var file in files)
{
var directory = Path.GetDirectoryName(file);
var xmlFile = Path.Combine(directory, Path.GetFileNameWithoutExtension(file) + ".xml");
XmlDocument doc = new XmlDocument();
doc.Load(xmlFile);
var members = doc.SelectNodes("/doc/members/member")
.OfType <XmlNode>()
.ToDictionary(x => x.Attributes["name"].Value, x => x.SelectSingleNode("summary").InnerText?.Trim());
var types = Assembly.LoadFile(file).GetExportedTypes().Where(x => x.IsPublic)
.ToList();
foreach (var type in types)
{
var typeDescription = GetClassSummary(members, type);
var exportedType = new ExportedType
{
Description = typeDescription,
Name = Regex.Replace(type.Name, @"\`\d+", string.Empty),
Namespace = type.Namespace
};
if (type.IsGenericType)
{
exportedType.IsGeneric = true;
exportedType.GenericParameters = type.GetGenericArguments().Select(x => new ExportedTypeGenericParameter()
{
Name = Regex.Replace(x.Name, @"\`\d+", string.Empty),
Description = GetClassSummary(members, x),
ExportedType = exportedType
}).ToList();
}
productVersion.ExportedTypes.Add(exportedType);
InitilizeTypes(type, exportedType, members);
}
}
}
protected sealed override void IterateTypeForwards(TypeForwardHandler handler)
{
MetadataReader reader = Reader;
foreach (ExportedTypeHandle exportedTypeHandle in reader.ExportedTypes)
{
ExportedType exportedType = reader.GetExportedType(exportedTypeHandle);
if (!exportedType.IsForwarder)
{
continue;
}
EntityHandle implementation = exportedType.Implementation;
if (implementation.Kind != HandleKind.AssemblyReference) // This check also weeds out nested types. This is intentional.
{
continue;
}
RoAssembly redirectedAssembly = ((AssemblyReferenceHandle)implementation).ResolveToAssemblyOrExceptionAssembly(GetEcmaManifestModule());
ReadOnlySpan <byte> ns = exportedType.Namespace.AsReadOnlySpan(reader);
ReadOnlySpan <byte> name = exportedType.Name.AsReadOnlySpan(reader);
handler(redirectedAssembly, ns, name);
}
}
protected override TypeDefinition ProcessExportedType(ExportedType exported, AssemblyDefinition assembly)
{
MarkingHelpers.MarkExportedType(exported, assembly.MainModule, new DependencyInfo(DependencyKind.XmlDescriptor, _xmlDocumentLocation));
return(base.ProcessExportedType(exported, assembly));
}
private static ExportEntryViewModel GetEntryViewModel(ExportedType export)
{
ExportEntryViewModel vm = new ExportEntryViewModel();
vm.Name = export.Attribute.Alias;
vm.DisplayName = InformationAttribute.GetDisplayName(export.Type);
vm.Description = InformationAttribute.GetDescription(export.Type);
if (string.IsNullOrWhiteSpace(vm.Description))
{
// If there is no useful description, set it to null to make TargetNullValue in binding effective.
vm.Description = null;
}
return vm;
}
/// <inheritdoc />
public int GetHashCode(ExportedType obj)
{
return(GetHashCode((ITypeDescriptor)obj));
}
/// <summary>
/// Gets cloners for the given source item.
/// </summary>
/// <param name="item">Item to get cloners for.</param>
/// <returns>Cloners for the <paramref name="item"/>.</returns>
protected override IReadOnlyCollection <ICloner <object, object> > InvokeForItem(ExportedType item)
{
return(new ICloner <object, object> [0]);
}
public static string ToString(this MetadataReader reader, ExportedType x) => $"{{ExpType[{RowId(x):X}]: {reader.ToString( x.Namespace)}::{reader.ToString( x.Name)} {reader.ToString( x.Implementation)}[{x.GetTypeDefinitionId()}]}}";
protected virtual TypeDefinition ProcessExportedType(ExportedType exported, AssemblyDefinition assembly) => exported.Resolve();
public Tabels(PEFile p)
{
//Init
this.r = p.MetadataReader;
//Read all of the tabels
ModuleTabel = new List <Module>();
TypeRefTabel = new List <TypeRef>();
TypeDefTabel = new List <TypeDef>();
FieldTabel = new List <Field>();
MethodTabel = new List <Method>();
ParmTabel = new List <Param>();
InterfaceImplTable = new List <InterfaceImpl>();
MemberRefTabelRow = new List <MemberRef>();
ConstantTabel = new List <Constant>();
CustomAttributeTabel = new List <CustomAttribute>();
FieldMarshalTabel = new List <FieldMarshal>();
DeclSecurityTabel = new List <DeclSecurity>();
ClassLayoutTabel = new List <ClassLayout>();
FieldLayoutTabel = new List <FieldLayout>();
StandAloneSigTabel = new List <StandAloneSig>();
EventMapTabel = new List <EventMap>();
EventTabel = new List <Event>();
PropertyMapTabel = new List <PropertyMap>();
PropertyTabel = new List <PropertyTabel>();
MethodSemanticsTabel = new List <MethodSemantics>();
MethodImplTabel = new List <MethodImpl>();
ModuleRefTabel = new List <ModuleRef>();
TypeSpecTabel = new List <TypeSpec>();
ImplMapTabel = new List <ImplMap>();
FieldRVATabel = new List <FieldRVA>();
AssemblyTabel = new List <Assembly>();
AssemblyRefTabel = new List <AssemblyRef>();
FileTable = new List <File>();
ExportedTypeTable = new List <ExportedType>();
ManifestResourceTable = new List <ManifestResource>();
NestedClassTable = new List <NestedClass>();
GenericParamTable = new List <GenericParam>();
MethodSpecTable = new List <MethodSpec>();
int a = 0;
//Read module Tabel (if any)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Module) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Module();
m.Read(r);
ModuleTabel.Add(m);
}
a++;
}
//Read TypeRef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeRef();
m.Read(r);
TypeRefTabel.Add(m);
}
a++;
}
//Read TypeDef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeDef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeDef();
m.Read(r);
TypeDefTabel.Add(m);
}
a++;
}
//Read Field Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Field) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Field();
m.Read(r);
FieldTabel.Add(m);
}
a++;
}
//Read Method tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Method) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Method();
m.Read(r);
MethodTabel.Add(m);
}
a++;
}
//Read Parm Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Param) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Param();
m.Read(r);
ParmTabel.Add(m);
}
a++;
}
//Read interfaceimpl Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.InterfaceImpl) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new InterfaceImpl();
m.Read(r);
InterfaceImplTable.Add(m);
}
a++;
}
//Read MemberRef tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MemberRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MemberRef();
m.Read(r);
MemberRefTabelRow.Add(m);
}
a++;
}
//Read Constant tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Constant) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Constant();
m.Read(r);
ConstantTabel.Add(m);
}
a++;
}
//Read CustomAttribute tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.CustomAttribute) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new CustomAttribute();
m.Read(r);
CustomAttributeTabel.Add(m);
}
a++;
}
//Read FieldMarshal tabel (Please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldMarshal) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldMarshal();
m.Read(r);
FieldMarshalTabel.Add(m);
}
a++;
}
//Read DeclSecurity tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.DeclSecurity) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new DeclSecurity();
m.Read(r);
DeclSecurityTabel.Add(m);
}
a++;
}
//Read ClassLayout tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ClassLayout) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ClassLayout();
m.Read(r);
ClassLayoutTabel.Add(m);
}
a++;
}
//Read FieldLayout tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldLayout) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldLayout();
m.Read(r);
FieldLayoutTabel.Add(m);
}
a++;
}
//Read StandAloneSig tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.StandAloneSig) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new StandAloneSig();
m.Read(r);
StandAloneSigTabel.Add(m);
}
a++;
}
//Read EventMap tabel (please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.EventMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new EventMap();
m.Read(r);
EventMapTabel.Add(m);
}
a++;
}
//Read event tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Event) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Event();
m.Read(r);
EventTabel.Add(m);
}
a++;
}
//Read Property Map tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.PropertyMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new PropertyMap();
m.Read(r);
PropertyMapTabel.Add(m);
}
a++;
}
//Read Property tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Property) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new PropertyTabel();
m.Read(r);
PropertyTabel.Add(m);
}
a++;
}
//Read MethodSemantics tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSemantics) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodSemantics();
m.Read(r);
MethodSemanticsTabel.Add(m);
}
a++;
}
//Read MethodImpl tabel (Please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodImpl) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodImpl();
m.Read(r);
MethodImplTabel.Add(m);
}
a++;
}
//Read ModuleRef tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ModuleRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ModuleRef();
m.Read(r);
ModuleRefTabel.Add(m);
}
a++;
}
//Read TypeSpec tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeSpec) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeSpec();
m.Read(r);
TypeSpecTabel.Add(m);
}
a++;
}
//Read ImplMap tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ImplMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ImplMap();
m.Read(r);
ImplMapTabel.Add(m);
}
a++;
}
//Read FieldRVA tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldRVA) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldRVA();
m.Read(r);
FieldRVATabel.Add(m);
}
a++;
}
//Read Assembly tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Assembly) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Assembly();
m.Read(r);
AssemblyTabel.Add(m);
}
a++;
}
//Read ignored tabels (These never should be present!)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyProcessor) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var proc = r.ReadUInt32();
}
a++;
}
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyOS) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 11; //Test please
}
a++;
}
//Read AssemblyRef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new AssemblyRef();
m.Read(r);
AssemblyRefTabel.Add(m);
}
a++;
}
//Read AssemblyRefProcessor Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefProcessor) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 8; //Test please
}
a++;
}
//Read AssemblyRefOS Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefOS) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 16; //Test please
}
a++;
}
//Read File Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.File) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new File();
m.Read(r);
FileTable.Add(m);
}
a++;
}
//Read ExportedType Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ExportedType) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ExportedType();
m.Read(r);
ExportedTypeTable.Add(m);
}
a++;
}
//Read ManifestResource Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ManifestResource) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ManifestResource();
m.Read(r);
ManifestResourceTable.Add(m);
}
a++;
}
//Read NestedClass Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.NestedClass) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new NestedClass();
m.Read(r);
NestedClassTable.Add(m);
}
a++;
}
//Read GenericParam Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.GenericParam) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new GenericParam();
m.Read(r);
GenericParamTable.Add(m);
}
a++;
}
//Read MethodSpec Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSpec) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodSpec();
m.Read(r);
MethodSpecTable.Add(m);
}
a++;
}
}
public static bool GetMatchingExportedType(this ModuleDefinition module, TypeDefinition typeDefinition, out ExportedType exportedType)
{
exportedType = null;
if (!module.HasExportedTypes || typeDefinition == null)
{
return(false);
}
foreach (var et in module.ExportedTypes)
{
if (et.Resolve() == typeDefinition)
{
exportedType = et;
return(true);
}
}
return(false);
}
public void Save(ExportedType type, string path)
{
var result = ToString();
File.WriteAllText(path, result);
}
public void MarkExportedType(ExportedType type, ModuleDefinition module, in DependencyInfo reason)
/// <summary>
/// Gets a hint at the likely row number of the target type in the TypeDef table of its module.
/// If the namespaces and names do not match, resolution falls back to a full search of the
/// target TypeDef table. Ignored and should be zero if <see cref="ExportedType.IsForwarder"/> is
/// true.
/// </summary>
public static int GetTypeDefinitionId(this ExportedType exportedType)
{
return((int)exportedType.reader.ExportedTypeTable.GetTypeDefId(exportedType.rowId));
}
protected virtual void ProcessExportedType(ExportedType exportedType)
{
}
public ExportedTypeEntry(int metadataOffset, PEFile module, ExportedTypeHandle handle, ExportedType type)
{
this.metadataOffset = metadataOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.type = type;
}
protected override TypeDefinition ProcessExportedType(ExportedType exported, AssemblyDefinition assembly) => null;
protected abstract void ProcessExportedType(ExportedType exportedType);
protected override TypeDefinition?ProcessExportedType(ExportedType exported, AssemblyDefinition assembly, XPathNavigator nav) => null;
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
{
return(new ObjectData(Array.Empty <byte>(), Array.Empty <Relocation>(), 1, new ISymbolDefinitionNode[] { this }));
}
NativeWriter writer = new NativeWriter();
Section section = writer.NewSection();
VertexHashtable typesHashtable = new VertexHashtable();
section.Place(typesHashtable);
ReadyToRunTableManager r2rManager = (ReadyToRunTableManager)factory.MetadataManager;
foreach (TypeInfo <TypeDefinitionHandle> defTypeInfo in r2rManager.GetDefinedTypes())
{
TypeDefinitionHandle defTypeHandle = defTypeInfo.Handle;
int hashCode = 0;
for (; ;)
{
TypeDefinition defType = defTypeInfo.MetadataReader.GetTypeDefinition(defTypeHandle);
string namespaceName = defTypeInfo.MetadataReader.GetString(defType.Namespace);
string typeName = defTypeInfo.MetadataReader.GetString(defType.Name);
hashCode ^= ReadyToRunHashCode.NameHashCode(namespaceName, typeName);
if (!defType.Attributes.IsNested())
{
break;
}
defTypeHandle = defType.GetDeclaringType();
}
typesHashtable.Append(unchecked ((uint)hashCode), section.Place(new UnsignedConstant(((uint)MetadataTokens.GetRowNumber(defTypeInfo.Handle) << 1) | 0)));
}
foreach (TypeInfo <ExportedTypeHandle> expTypeInfo in r2rManager.GetExportedTypes())
{
ExportedTypeHandle expTypeHandle = expTypeInfo.Handle;
int hashCode = 0;
for (; ;)
{
ExportedType expType = expTypeInfo.MetadataReader.GetExportedType(expTypeHandle);
string namespaceName = expTypeInfo.MetadataReader.GetString(expType.Namespace);
string typeName = expTypeInfo.MetadataReader.GetString(expType.Name);
hashCode ^= ReadyToRunHashCode.NameHashCode(namespaceName, typeName);
if (expType.Implementation.Kind != HandleKind.ExportedType)
{
// Not a nested class
break;
}
expTypeHandle = (ExportedTypeHandle)expType.Implementation;
}
typesHashtable.Append(unchecked ((uint)hashCode), section.Place(new UnsignedConstant(((uint)MetadataTokens.GetRowNumber(expTypeInfo.Handle) << 1) | 1)));
}
MemoryStream writerContent = new MemoryStream();
writer.Save(writerContent);
return(new ObjectData(
data: writerContent.ToArray(),
relocs: null,
alignment: 8,
definedSymbols: new ISymbolDefinitionNode[] { this }));
}
/// <summary>
/// Gets the parent of the given item.
/// </summary>
/// <param name="item">Item to get parent of.</param>
/// <returns>Parent of <paramref name="item"/>.</returns>
protected override IEnumerable <object> InvokeForItem(ExportedType item)
{
return(new object[] { item.DeclaringType });
}
