private static ImmutableArray <AssemblyIdentity> ReadReferences(
SystemMetadataReader metadataReader
)
{
var builder = ImmutableArray.CreateBuilder <AssemblyIdentity>();
foreach (var referenceHandle in metadataReader.AssemblyReferences)
{
var reference = metadataReader.GetAssemblyReference(referenceHandle);
var refname = metadataReader.GetString(reference.Name);
var refversion = reference.Version;
var refcultureName = metadataReader.GetString(reference.Culture);
var refpublicKeyOrToken = metadataReader.GetBlobContent(reference.PublicKeyOrToken);
var refflags = reference.Flags;
var refhasPublicKey = (refflags & AssemblyFlags.PublicKey) != 0;
builder.Add(
new AssemblyIdentity(
refname,
refversion,
refcultureName,
refpublicKeyOrToken,
hasPublicKey: refhasPublicKey
)
);
}
return(builder.ToImmutable());
}
private void InitializeTypeForwarder(ForwarderKey key, TypeForwarder record)
{
Cts.Ecma.EcmaModule module = key.Module;
Ecma.MetadataReader reader = module.MetadataReader;
Ecma.ExportedType exportedType = reader.GetExportedType(key.ExportedType);
record.Name = HandleString(reader.GetString(exportedType.Name));
switch (exportedType.Implementation.Kind)
{
case Ecma.HandleKind.AssemblyReference:
{
string ns = reader.GetString(exportedType.Namespace);
NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns);
Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation);
AssemblyName refName = new AssemblyName
{
ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9),
Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask),
CultureName = reader.GetString(assemblyRef.Culture),
Name = reader.GetString(assemblyRef.Name),
Version = assemblyRef.Version,
};
if ((assemblyRef.Flags & AssemblyFlags.PublicKey) != 0)
{
refName.SetPublicKey(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken));
}
else
{
refName.SetPublicKeyToken(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken));
}
record.Scope = HandleScopeReference(refName);
namespaceDefinition.TypeForwarders.Add(record);
}
break;
case Ecma.HandleKind.ExportedType:
{
TypeForwarder scope = HandleTypeForwarder(module, (Ecma.ExportedTypeHandle)exportedType.Implementation);
record.Scope = scope.Scope;
scope.NestedTypes.Add(record);
}
break;
default:
throw new BadImageFormatException();
}
}
public static RuntimeAssemblyName ToRuntimeAssemblyName(this AssemblyReferenceHandle assemblyReferenceHandle, MetadataReader reader)
{
AssemblyReference assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return CreateRuntimeAssemblyNameFromMetadata(
reader,
assemblyReference.Name,
assemblyReference.Version,
assemblyReference.Culture,
assemblyReference.PublicKeyOrToken,
assemblyReference.Flags
);
}
private static Reference[] GetAssemblyReferences(MetadataReader reader)
{
var references = new List<Reference>();
foreach (var handle in reader.AssemblyReferences)
{
var reference = reader.GetAssemblyReference(handle);
references.Add(new Reference(reader.GetString(reference.Name), reference.Version));
}
return references.ToArray();
}
private TypeForwarder HandleTypeForwarder(Cts.Ecma.EcmaModule module, Ecma.ExportedType exportedType)
{
Ecma.MetadataReader reader = module.MetadataReader;
string name = reader.GetString(exportedType.Name);
TypeForwarder result;
switch (exportedType.Implementation.Kind)
{
case Ecma.HandleKind.AssemblyReference:
{
string ns = reader.GetString(exportedType.Namespace);
NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns);
Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation);
AssemblyName refName = new AssemblyName
{
ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9),
Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask),
CultureName = reader.GetString(assemblyRef.Culture),
Name = reader.GetString(assemblyRef.Name),
Version = assemblyRef.Version,
};
result = new TypeForwarder
{
Name = HandleString(name),
Scope = HandleScopeReference(refName),
};
namespaceDefinition.TypeForwarders.Add(result);
}
break;
case Ecma.HandleKind.ExportedType:
{
TypeForwarder scope = HandleTypeForwarder(module, reader.GetExportedType((Ecma.ExportedTypeHandle)exportedType.Implementation));
result = new TypeForwarder
{
Name = HandleString(name),
Scope = scope.Scope,
};
scope.NestedTypes.Add(result);
}
break;
default:
throw new BadImageFormatException();
}
return(result);
}
private static ImmutableArray<AssemblyIdentity> ReadReferences(SystemMetadataReader metadataReader)
{
var builder = ImmutableArray.CreateBuilder<AssemblyIdentity>();
foreach (var referenceHandle in metadataReader.AssemblyReferences)
{
var reference = metadataReader.GetAssemblyReference(referenceHandle);
string refname = metadataReader.GetString(reference.Name);
Version refversion = reference.Version;
string refcultureName = metadataReader.GetString(reference.Culture);
ImmutableArray<byte> refpublicKeyOrToken = metadataReader.GetBlobContent(reference.PublicKeyOrToken);
AssemblyFlags refflags = reference.Flags;
bool refhasPublicKey = (refflags & AssemblyFlags.PublicKey) != 0;
builder.Add(new AssemblyIdentity(refname, refversion, refcultureName, refpublicKeyOrToken, hasPublicKey: refhasPublicKey));
}
return builder.ToImmutable();
}
private static AssemblyReference[] GetAssemblyReferences(MetadataReader reader)
{
var count = reader.GetTableRowCount(TableIndex.AssemblyRef);
var references = new AssemblyReference[count];
for (int i = 0; i < count; i++)
{
var reference = reader.GetAssemblyReference(MetadataTokens.AssemblyReferenceHandle(i + 1));
references[i] = new AssemblyReference(reader.GetString(reference.Name), reference.Version);
}
return references.ToArray();
}
private bool IsSameResolutionScope(MetadataReader referenceMetadata, MetadataReader newMetadata, Handle referenceResolutionScope, Handle newResolutionScope)
{
if (referenceResolutionScope.IsNil != newResolutionScope.IsNil)
return false;
if (referenceResolutionScope.Kind != newResolutionScope.Kind)
return false;
switch (referenceResolutionScope.Kind)
{
case HandleKind.ModuleDefinition:
Console.WriteLine("ResolutionScope:{0} checking not yet implemented.", referenceResolutionScope.Kind);
break;
case HandleKind.ModuleReference:
Console.WriteLine("ResolutionScope:{0} checking not yet implemented.", referenceResolutionScope.Kind);
break;
case HandleKind.AssemblyReference:
AssemblyReference referenceResolutionScopeAssemblyReference = referenceMetadata.GetAssemblyReference((AssemblyReferenceHandle)referenceResolutionScope);
AssemblyReference newResolutionScopeAssemblyReference = newMetadata.GetAssemblyReference((AssemblyReferenceHandle)newResolutionScope);
return IsSameResolutionScope(referenceMetadata, newMetadata, referenceResolutionScopeAssemblyReference, newResolutionScopeAssemblyReference);
case HandleKind.TypeReference:
Console.WriteLine("ResolutionScope:{0} checking not yet implemented.", referenceResolutionScope.Kind);
break;
default:
throw new InvalidOperationException("Invalid ResolutionScope kind.");
}
return true;
}
