internal void ReadTableHeaders(BinaryReader reader)
{
SetupCodedIndexes();
for (int i = 0; i < 45; i++)
{
if (tablesHeap.HasTable((MetaDataTableType)i))
{
long headerOffset = reader.BaseStream.Position + tablesHeap.StreamOffset;
MetaDataTable table = CreateTable((MetaDataTableType)i, reader.ReadInt32(), headerOffset);
tablesHeap._tables[i] = table;
}
}
uint tableOffset = (uint)(tablesHeap.StreamOffset + Marshal.SizeOf(typeof(Structures.METADATA_TABLE_HEADER)) + (tablesHeap._tablecount) * 4);
foreach (MetaDataTable table in tablesHeap._tables)
{
if (table != null)
{
table.TableOffset = tableOffset;
tableOffset += (uint)table.PhysicalSize;
}
}
}
public void AddTable(MetaDataTableType type)
{
MetaDataTable table = new MetaDataTable(this, true);
table._type = type;
_tables[(int)type] = table;
MaskValid |= ((ulong)1 << (int)type);
}
private byte GetIndexSize(MetaDataTableType type)
{
MetaDataTable table = tablesHeap.Tables[(int)type];
if (table != null && table.IsLarge(0))
{
return(sizeof(uint));
}
return(sizeof(ushort));
}
internal MetaDataMember ReadMember(MetaDataTable table, int index)
{
using (MemoryStream stream = new MemoryStream(tablesHeap.Contents))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Position = table.TableOffset - tablesHeap.StreamOffset;
stream.Position += (table.CalculateRowSize() * (index - 1));
Type type;
MetaDataRow row;
if (GetRowAndType(reader, table, out row, out type))
{
return(CreateMember(type, row, table.Type, index));
}
}
}
return(null);
}
public uint GetCodedIndex(MetaDataMember member)
{
if (member == null)
{
return(0);
}
MetaDataTable table = _tables.FirstOrDefault(t => t != null && t.Type == member.TableType);
if (table == null)
{
throw new ArgumentException("Member does not belong to the metadata table group.");
}
uint rowIndex = ((uint)(member._metadatatoken - ((uint)table.Type << 24)));
uint tableIndex = (uint)Array.IndexOf(_tables, table);
return((rowIndex << _bits) | tableIndex);
}
public MemberCollection(MetaDataTable table)
{
_table = table;
_internalArray = new MetaDataMember[table.AmountOfRows];
}
public static MemberRange <T> CreateRange <T>(MetaDataMember member, int mdrowIndex, MetaDataTable targetTable) where T : MetaDataMember
{
MemberRange <T> range = new MemberRange <T>();
range.Start = Convert.ToInt32(member.MetaDataRow.Parts[mdrowIndex]) - 1;
if (targetTable == null)
{
range.Length = 0;
return(range);
}
range.TargetTable = targetTable;
int memberIndex = (int)(member._metadatatoken | (0xFF << 24)) - (0xFF << 24);
if (member.Table != null)
{
if (memberIndex == member.Table.AmountOfRows)
{
range.Length = targetTable.AmountOfRows - range.Start;
}
else
{
int nextIndex = Convert.ToInt32(member.Table.Members[memberIndex].MetaDataRow.Parts[mdrowIndex]) - 1;
range.Length = nextIndex - range.Start;
}
}
if (range.Length > targetTable.AmountOfRows - range.Start)
{
range.Length = 0;
}
return(range);
}
internal MetaDataTable CreateTable(MetaDataTableType type, int rowAmount, long rowAmountOffset)
{
//customattribute[permission]?
MetaDataTable table = new MetaDataTable(tablesHeap, false);
table.Type = type;
table._rowAmount = rowAmount;
table._rowAmountOffset = rowAmountOffset;
switch (type)
{
case MetaDataTableType.Assembly:
tablesHeap.HasCustomAttribute[14] = table;
tablesHeap.HasDeclSecurity[2] = table;
break;
case MetaDataTableType.AssemblyRef:
tablesHeap.HasCustomAttribute[15] = table;
tablesHeap.Implementation[1] = table;
tablesHeap.ResolutionScope[2] = table;
break;
case MetaDataTableType.Event:
tablesHeap.HasCustomAttribute[10] = table;
tablesHeap.HasSemantics[0] = table;
break;
case MetaDataTableType.ExportedType:
tablesHeap.HasCustomAttribute[17] = table;
tablesHeap.Implementation[2] = table;
break;
case MetaDataTableType.Field:
tablesHeap.HasConstant[0] = table;
tablesHeap.HasCustomAttribute[1] = table;
tablesHeap.HasFieldMarshall[0] = table;
tablesHeap.MemberForwarded[0] = table;
break;
case MetaDataTableType.File:
tablesHeap.HasCustomAttribute[16] = table;
tablesHeap.Implementation[0] = table;
break;
case MetaDataTableType.GenericParam:
tablesHeap.HasCustomAttribute[19] = table;
break;
case MetaDataTableType.GenericParamConstraint:
tablesHeap.HasCustomAttribute[20] = table;
break;
case MetaDataTableType.InterfaceImpl:
tablesHeap.HasCustomAttribute[5] = table;
break;
case MetaDataTableType.ManifestResource:
tablesHeap.HasCustomAttribute[18] = table;
break;
case MetaDataTableType.MemberRef:
tablesHeap.HasCustomAttribute[6] = table;
tablesHeap.MethodDefOrRef[1] = table;
tablesHeap.CustomAttributeType[3] = table;
break;
case MetaDataTableType.Method:
tablesHeap.HasCustomAttribute[0] = table;
tablesHeap.HasDeclSecurity[1] = table;
tablesHeap.MemberRefParent[3] = table;
tablesHeap.MethodDefOrRef[0] = table;
tablesHeap.MemberForwarded[1] = table;
tablesHeap.CustomAttributeType[2] = table;
tablesHeap.TypeOrMethod[1] = table;
break;
case MetaDataTableType.MethodSpec:
tablesHeap.HasCustomAttribute[21] = table;
break;
case MetaDataTableType.Module:
tablesHeap.HasCustomAttribute[7] = table;
tablesHeap.ResolutionScope[0] = table;
break;
case MetaDataTableType.ModuleRef:
tablesHeap.HasCustomAttribute[12] = table;
tablesHeap.MemberRefParent[2] = table;
tablesHeap.ResolutionScope[1] = table;
break;
case MetaDataTableType.Param:
tablesHeap.HasConstant[1] = table;
tablesHeap.HasCustomAttribute[4] = table;
tablesHeap.HasFieldMarshall[1] = table;
break;
case MetaDataTableType.Property:
tablesHeap.HasConstant[2] = table;
tablesHeap.HasCustomAttribute[9] = table;
tablesHeap.HasSemantics[1] = table;
break;
case MetaDataTableType.StandAloneSig:
tablesHeap.HasCustomAttribute[11] = table;
break;
case MetaDataTableType.TypeDef:
tablesHeap.TypeDefOrRef[0] = table;
tablesHeap.HasCustomAttribute[3] = table;
tablesHeap.HasDeclSecurity[0] = table;
tablesHeap.MemberRefParent[0] = table;
tablesHeap.TypeOrMethod[0] = table;
break;
case MetaDataTableType.TypeRef:
tablesHeap.TypeDefOrRef[1] = table;
tablesHeap.HasCustomAttribute[2] = table;
tablesHeap.MemberRefParent[1] = table;
tablesHeap.ResolutionScope[3] = table;
break;
case MetaDataTableType.TypeSpec:
tablesHeap.TypeDefOrRef[2] = table;
tablesHeap.HasCustomAttribute[13] = table;
tablesHeap.MemberRefParent[4] = table;
break;
}
return(table);
}
private bool GetRowAndType(BinaryReader reader, MetaDataTable table, out MetaDataRow row, out Type type)
{
type = null;
row = default(MetaDataRow);
switch (table.Type)
{
case MetaDataTableType.Module:
row = ReadRow(reader, GetModuleSignature()); type = typeof(ModuleDefinition); break;
case MetaDataTableType.TypeRef:
row = ReadRow(reader, GetTypeRefSignature()); type = typeof(TypeReference); break;
case MetaDataTableType.TypeDef:
row = ReadRow(reader, GetTypeDefSignature()); type = typeof(TypeDefinition); break;
case MetaDataTableType.FieldPtr:
row = ReadRow(reader, GetFieldPtrSignature()); type = typeof(FieldPtr); break;
case MetaDataTableType.Field:
row = ReadRow(reader, GetFieldDefSignature()); type = typeof(FieldDefinition); break;
case MetaDataTableType.MethodPtr:
row = ReadRow(reader, GetMethodPtrSignature()); type = typeof(MethodPtr); break;
case MetaDataTableType.Method:
row = ReadRow(reader, GetMethodDefSignature()); type = typeof(MethodDefinition); break;
case MetaDataTableType.ParamPtr:
row = ReadRow(reader, GetParamPtrSignature()); type = typeof(ParamPtr); break;
case MetaDataTableType.Param:
row = ReadRow(reader, GetParamDefSignature()); type = typeof(ParameterDefinition); break;
case MetaDataTableType.InterfaceImpl:
row = ReadRow(reader, GetInterfaceImplSignature()); type = typeof(InterfaceImplementation); break;
case MetaDataTableType.MemberRef:
row = ReadRow(reader, GetMemberRefSignature());
tablesHeap._netheader.BlobHeap._mainStream.Seek(Convert.ToUInt32(row._parts[2]), SeekOrigin.Begin);
tablesHeap._netheader.BlobHeap._binReader.ReadByte();
byte sigtype = tablesHeap._netheader.BlobHeap._binReader.ReadByte();
if (sigtype == 0x6)
{
type = typeof(FieldReference);
}
else
{
type = typeof(MethodReference);
}
break;
case MetaDataTableType.Constant:
row = ReadRow(reader, GetConstantSignature()); type = typeof(Constant); break;
case MetaDataTableType.CustomAttribute:
row = ReadRow(reader, GetCustomAttributeSignature()); type = typeof(CustomAttribute); break;
case MetaDataTableType.FieldMarshal:
row = ReadRow(reader, GetFieldMarshalSignature()); type = typeof(FieldMarshal); break;
case MetaDataTableType.DeclSecurity:
row = ReadRow(reader, GetSecurityDeclSignature()); type = typeof(SecurityDeclaration); break;
case MetaDataTableType.ClassLayout:
row = ReadRow(reader, GetClassLayoutSignature()); type = typeof(ClassLayout); break;
case MetaDataTableType.FieldLayout:
row = ReadRow(reader, GetFieldLayoutSignature()); type = typeof(FieldLayout); break;
case MetaDataTableType.StandAloneSig:
row = ReadRow(reader, GetStandAloneSigSignature()); type = typeof(StandAloneSignature); break;
case MetaDataTableType.EventMap:
row = ReadRow(reader, GetEventMapSignature()); type = typeof(EventMap); break;
case MetaDataTableType.Event:
row = ReadRow(reader, GetEventDefSignature()); type = typeof(EventDefinition); break;
case MetaDataTableType.PropertyMap:
row = ReadRow(reader, GetPropertyMapSignature()); type = typeof(PropertyMap); break;
case MetaDataTableType.PropertyPtr:
row = ReadRow(reader, GetPropertyPtrSignature()); type = typeof(PropertyPtr); break;
case MetaDataTableType.Property:
row = ReadRow(reader, GetPropertyDefSignature()); type = typeof(PropertyDefinition); break;
case MetaDataTableType.MethodSemantics:
row = ReadRow(reader, GetMethodSemanticsSignature()); type = typeof(MethodSemantics); break;
case MetaDataTableType.MethodImpl:
row = ReadRow(reader, GetMethodImplSignature()); type = typeof(MethodImplementation); break;
case MetaDataTableType.ModuleRef:
row = ReadRow(reader, GetModuleRefSignature()); type = typeof(ModuleReference); break;
case MetaDataTableType.TypeSpec:
row = ReadRow(reader, GetTypeSpecSignature()); type = typeof(TypeSpecification); break;
case MetaDataTableType.MethodSpec:
row = ReadRow(reader, GetMethodSpecSignature()); type = typeof(MethodSpecification); break;
case MetaDataTableType.ImplMap:
row = ReadRow(reader, GetPInvokeImplSignature()); type = typeof(PInvokeImplementation); break;
case MetaDataTableType.FieldRVA:
row = ReadRow(reader, GetFieldRVASignature()); type = typeof(FieldRVA); break;
case MetaDataTableType.Assembly:
row = ReadRow(reader, GetAssemblyDefSignature()); type = typeof(AssemblyDefinition); break;
case MetaDataTableType.AssemblyProcessor:
row = ReadRow(reader, GetAssemblyProcSignature()); type = typeof(AssemblyProcessor); break;
case MetaDataTableType.AssemblyOS:
row = ReadRow(reader, GetAssemblyOSSignature()); type = typeof(AssemblyOS); break;
case MetaDataTableType.AssemblyRef:
row = ReadRow(reader, GetAssemblyRefSignature()); type = typeof(AssemblyReference); break;
case MetaDataTableType.AssemblyRefProcessor:
row = ReadRow(reader, GetAssemblyRefProcSignature()); type = typeof(AssemblyRefProcessor); break;
case MetaDataTableType.AssemblyRefOS:
row = ReadRow(reader, GetAssemblyRefOSSignature()); type = typeof(AssemblyRefOS); break;
case MetaDataTableType.File:
row = ReadRow(reader, GetFileReferenceSignature()); type = typeof(File); break;
case MetaDataTableType.ExportedType:
row = ReadRow(reader, GetExportedTypeSignature()); type = typeof(ExportedType); break;
case MetaDataTableType.ManifestResource:
row = ReadRow(reader, GetManifestResSignature()); type = typeof(ManifestResource); break;
case MetaDataTableType.NestedClass:
row = ReadRow(reader, GetNestedClassSignature()); type = typeof(NestedClass); break;
case MetaDataTableType.EncLog:
row = ReadRow(reader, GetEnCLogSignature()); type = typeof(EnCLog); break;
case MetaDataTableType.EncMap:
row = ReadRow(reader, GetEnCMapSignature()); type = typeof(EnCMap); break;
case MetaDataTableType.GenericParam:
row = ReadRow(reader, GetGenericParamSignature()); type = typeof(GenericParameter); break;
case MetaDataTableType.GenericParamConstraint:
row = ReadRow(reader, GetGenericParamConstraintSignature()); type = typeof(GenericParamConstraint); break;
}
return(type != null);
}
