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