private void LoadNestedClassMetadata() { if (!_stream.Tables.ContainsKey(MetadataTables.NestedClass)) { return; } MetadataRow[] nestedClasses = _stream.Tables[MetadataTables.NestedClass]; for (int i = 0; i < nestedClasses.Length; i++) { NestedClassMetadataTableRow nestedClassRow = nestedClasses[i] as NestedClassMetadataTableRow; TypeDefMetadataTableRow nestedClass = _stream.Tables.GetEntryFor( MetadataTables.TypeDef, nestedClassRow.NestedClass ) as TypeDefMetadataTableRow; TypeDef container = _map.GetDefinition(MetadataTables.TypeDef, _stream.Tables.GetEntryFor( MetadataTables.TypeDef, nestedClassRow.EnclosingClass )) as TypeDef; TypeDef nested = _map.GetDefinition(MetadataTables.TypeDef, nestedClass) as TypeDef; _assembly.Map.Remove(nested); // remove type originally added when loading typedef records nested.ContainingClass = container; _assembly.Map.Add(nested); } }
private void LoadInterfaceImplMetadata() { if (!_stream.Tables.ContainsKey(MetadataTables.InterfaceImpl)) { return; } MetadataRow[] interfaceImplementations = _stream.Tables[MetadataTables.InterfaceImpl]; for (int i = 0; i < interfaceImplementations.Length; i++) { InterfaceImplMetadataTableRow interfaceImplRow = interfaceImplementations[i] as InterfaceImplMetadataTableRow; TypeDefMetadataTableRow implementingClassRow = _stream.Tables.GetEntryFor( MetadataTables.TypeDef, interfaceImplRow.Class ) as TypeDefMetadataTableRow; MetadataRow interfaceRow = _stream.Tables.GetEntryFor( interfaceImplRow.Interface.Table, interfaceImplRow.Interface.Index); TypeDef implementingClass = _map.GetDefinition(MetadataTables.TypeDef, implementingClassRow) as TypeDef; TypeRef implementedClass = _map.GetDefinition(interfaceImplRow.Interface.Table, interfaceRow) as TypeRef; if (implementedClass is TypeSpec) { ((TypeSpec)implementedClass).ImplementingType = implementingClass; } implementingClass.Implements.Add(_map.GetDefinition(interfaceImplRow.Interface.Table, interfaceRow) as TypeRef); } }
internal List <TypeRef> GetExtendindTypes(TypeDef type, CodedIndex ciForThisType) { List <TypeRef> inheritingTypes = new List <TypeRef>(); List <CodedIndex> ourIndexes = new List <CodedIndex>(); // our coded index in typedef and any that appear in the type spec metadata Signatures ourIndexes.Add(ciForThisType); // All types in this assembly that extend another use the TypeDef.Extends data in the metadata // table. if (type.IsGeneric) { MetadataRow[] typeSpecs = _metadataStream.Tables[MetadataTables.TypeSpec]; for (int i = 0; i < typeSpecs.Length; i++) { TypeSpecMetadataTableRow row = typeSpecs[i] as TypeSpecMetadataTableRow; if (row != null) { // We need to find all of the TypeSpec references that point back to us, remember // that as a generic type people can inherit from us in different ways - Type<int> or Type<string> // for example. Each one of these will be a different type spec. TypeSpec spec = _metadataMap.GetDefinition(MetadataTables.TypeSpec, row) as TypeSpec; SignatureToken token = spec.Signiture.TypeToken.Tokens[0]; // First check if it is a GenericInstance as per the signiture spec in ECMA 23.2.14 if (token.TokenType == SignatureTokens.ElementType && ((ElementTypeSignatureToken)token).ElementType == ElementTypes.GenericInstance) { ElementTypeSignatureToken typeToken = spec.Signiture.TypeToken.Tokens[1] as ElementTypeSignatureToken; TypeRef typeRef = typeToken.ResolveToken(Assembly); if (typeRef == type) { ourIndexes.Add(new CodedIndex(MetadataTables.TypeSpec, (uint)i + 1)); } } } } } MetadataRow[] typeDefs = _metadataStream.Tables[MetadataTables.TypeDef]; for (int i = 0; i < typeDefs.Length; i++) { for (int j = 0; j < ourIndexes.Count; j++) { TypeDefMetadataTableRow row = (TypeDefMetadataTableRow)typeDefs[i]; CodedIndex ourCi = ourIndexes[j]; if (row.Extends == ourCi) { inheritingTypes.Add( (TypeDef)_metadataMap.GetDefinition(MetadataTables.TypeDef, _metadataStream.Tables[MetadataTables.TypeDef][i]) ); continue; // a type can only be extending once so if we find ourselves we are done } } } return(inheritingTypes); }
public TypeDefBuilder(BuildReferences references, TypeDefMetadataTableRow fromRow) { _references = references; _assembly = references.Assembly; _fromRow = fromRow; _metadata = references.Metadata; _map = references.Map; _metadataStream = _metadata.GetMetadataStream(); }
public TypeDefEntry(MetadataDirectory directory, TypeDefMetadataTableRow row) { this.Extends = row.Extends.ToString(); this.FieldsList = row.FieldList.ToString(); this.FileOffset = string.Format("0x{0:x}", row.FileOffset); this.Flags = string.Format("0x{0:x}", row.Flags); this.MethodList = row.MethodList.ToString(); this.Name = ((StringStream)directory.Streams[Streams.StringStream]).GetString(row.Name.Value); this.Namespace = ((StringStream)directory.Streams[Streams.StringStream]).GetString(row.Namespace.Value); }
public void TypeDef_WhenCreated_OffsetIsMovedOn() { IIndexDetails indexDetails = IndexHelper.CreateIndexDetails(2); byte[] contents = new byte[14]; ICodedIndexResolver resolver = IndexHelper.CreateCodedIndexResolver(2); Offset offset = 0; TypeDefMetadataTableRow row = new TypeDefMetadataTableRow(contents, offset, resolver, indexDetails); Assert.AreEqual(14, offset.Current); }
private void LoadTypeDefMetadata() { MetadataRow[] table = _stream.Tables[MetadataTables.TypeDef]; int count = table.Length; for (int i = 0; i < count; i++) { TypeDefMetadataTableRow typeDefRow = table[i] as TypeDefMetadataTableRow; TypeDef type = TypeDef.CreateFromMetadata(_references, typeDefRow); _map.Add(MetadataTables.TypeDef, typeDefRow, type); _assembly.Map.Add(type); _assembly.Types.Add(type); } }
public void TypeDef_WhenCreated_FieldsAreReadCorrectly() { IIndexDetails indexDetails = IndexHelper.CreateIndexDetails(2); byte[] contents = new byte[] { 0x80, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x03, 0x00, 0x04, 0x00 }; ICodedIndexResolver resolver = IndexHelper.CreateCodedIndexResolver(2); Offset offset = 0; TypeDefMetadataTableRow row = new TypeDefMetadataTableRow(contents, offset, resolver, indexDetails); Assert.AreEqual(TypeAttributes.Abstract, row.Flags); Assert.AreEqual(1, row.Name.Value); Assert.AreEqual(2, row.Namespace.Value); Assert.IsNotNull(row.Extends); Assert.AreEqual(3, row.FieldList.Value); Assert.AreEqual(4, row.MethodList.Value); }
internal static TypeDef CreateFromMetadata(BuildReferences references, TypeDefMetadataTableRow fromRow) { TypeDefBuilder builder = new TypeDefBuilder(references, fromRow); return(builder.Build()); }