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