internal int ConstructMetaDataToken(MetaDataTableType type, int index)
{
int token = ((int)type);
token = token << 0x18;
token += (index + 1);
return token;
}
private void ReorderRange <TParent, TMember>(Workspace workspace, MetaDataTableType parentTable, MetaDataTableType memberTable, int memberListIndex, Func <TParent, TMember[]> getMembersFunc)
where TParent : MetaDataMember
where TMember : MetaDataMember
{
if (workspace.Members.ContainsKey(parentTable) && workspace.Members.ContainsKey(memberTable))
{
MetaDataMemberInfo[] newRange = new MetaDataMemberInfo[workspace.Members[memberTable].Length];
TParent[] parentMembers = workspace.GetMembers <TParent>(parentTable);
MetaDataTable targetTable = workspace.Members[memberTable][0].Instance.Table;
uint currentIndex = 0;
for (int i = 0; i < parentMembers.Length; i++)
{
TMember[] members = getMembersFunc(parentMembers[i]);
if (members.Length > 0)
{
int startIndex = workspace.GetIndexOfMember(members[0]);
int endIndex = workspace.GetIndexOfMember(members[members.Length - 1]);
Array.Copy(workspace.Members[memberTable], startIndex, newRange, currentIndex, endIndex - startIndex + 1);
}
parentMembers[i].MetaDataRow.Parts[memberListIndex] = ConvertToIndex(targetTable, currentIndex + 1);
currentIndex += (uint)members.Length;
}
workspace.Members[memberTable] = newRange;
}
}
internal MetaDataMember CreateMember(Type type, MetaDataRow row, MetaDataTableType table, int index)
{
MetaDataMember member = (MetaDataMember)Activator.CreateInstance(type, row);
member._table = table;
member._netheader = tablesHeap._netheader;
member._metadatatoken = (uint)(((int)table) << 24 | index);
return member;
}
internal T CreateMember <T>(byte[] rowSignature, MetaDataTableType table) where T : MetaDataMember
{
T member = (T)Activator.CreateInstance(typeof(T), ReadRow(rowSignature));
member.table = table;
member.netheader = tablesHeap.netheader;
return(member);
}
internal uint ConstructMetaDataToken(MetaDataTableType type, uint index)
{
uint token = ((uint)type);
token = token << 0x18;
token += (index + 1);
return(token);
}
public void AddTable(MetaDataTableType type)
{
MetaDataTable table = new MetaDataTable(this, true);
table._type = type;
_tables[(int)type] = table;
MaskValid |= ((ulong)1 << (int)type);
}
internal MetaDataMember CreateMember(Type type, MetaDataRow row, MetaDataTableType table, int index)
{
MetaDataMember member = (MetaDataMember)Activator.CreateInstance(type, row);
member._table = table;
member._netheader = tablesHeap._netheader;
member._metadatatoken = (uint)(((int)table) << 24 | index);
return(member);
}
private byte GetIndexSize(MetaDataTableType type)
{
MetaDataTable table = tablesHeap.Tables[(int)type];
if (table != null && table.IsLarge(0))
{
return(sizeof(uint));
}
return(sizeof(ushort));
}
public T[] GetMembers <T>(MetaDataTableType table) where T : MetaDataMember
{
T[] output = new T[Members[table].Length];
for (int i = 0; i < output.Length; i++)
{
output[i] = Members[table][i].Instance as T;
}
return(output);
}
public MetaDataTable GetTable(MetaDataTableType type, bool addIfNotPresent)
{
if (!HasTable(type))
{
if (addIfNotPresent)
{
AddTable(type);
}
else
{
return(null);
}
}
return(_tables[(int)type]);
}
/// <summary>
/// Resolves a member by its metadata token.
/// </summary>
/// <param name="metadataToken">The token of the member to look up.</param>
/// <returns></returns>
public MetaDataMember ResolveMember(uint metadataToken)
{
if (metadataToken == 0)
{
throw new ArgumentException("Cannot resolve a member from a zero metadata token", "metadataToken");
}
MetaDataTableType tabletype = (MetaDataTableType)(metadataToken >> 0x18);
if (!_netheader.TablesHeap.HasTable(tabletype))
{
throw new ArgumentException("Table is not present in tables heap.");
}
uint rowindex = metadataToken & 0x00FFFFFF;
return(_netheader.TablesHeap.GetTable(tabletype).Members[(int)rowindex - 1]);
}
private void PopulateTableRows(AssemblyBuffer buffer)
{
for (int idx = 0; idx < this.TableLengths.Length; idx++)
{
MetaDataTableType tableType = (MetaDataTableType)idx;
// These weren't valid in the present DWORD.
if (this.TableLengths[idx] == 0)
{
continue;
}
if (!this.TableRowTypes.ContainsKey(tableType))
{
Console.WriteLine($"WARNING: NO TYPE HANDLER FOR: {tableType.ToString()}");
continue;
}
Type rowType = this.TableRowTypes[tableType];
List <TableRow> tableRows = new List <TableRow>();
for (int tableIdx = 0; tableIdx < this.TableLengths[idx]; tableIdx++)
{
TableRow row = (TableRow)Activator.CreateInstance(rowType, buffer);
if (row == null)
{
Console.WriteLine($"WARNING: No Row type for :{tableType.ToString()}");
continue;
}
row.SetStreamHeaderState(this._metaDataHeader.Streams);
row.Read(buffer);
tableRows.Add(row);
}
this.TableRows.Add(tableType, tableRows);
}
}
private void CollectMembers(TablesHeap tablesHeap, Workspace workspace)
{
Constructor.Log("Collecting .NET metadata members.");
for (int i = 0; i < tablesHeap._tables.Length; i++)
{
MetaDataTableType tableType = (MetaDataTableType)i;
if (tablesHeap.HasTable(tableType))
{
MetaDataTable table = tablesHeap.GetTable(tableType);
if (table.Members.Count != 0)
{
MetaDataMemberInfo[] subMembers = new MetaDataMemberInfo[table.Members.Count];
for (int j = 0; j < subMembers.Length; j++)
{
subMembers[j] = new MetaDataMemberInfo(table.Members[j]);
}
workspace.Members.Add(tableType, subMembers);
}
}
}
}
public bool HasTable(MetaDataTableType table)
{
return ((this.MaskValid >> (byte)table) & (ulong)1) == 1;
}
private byte GetIndexSize(MetaDataTableType type)
{
MetaDataTable table = tablesHeap.Tables[(int)type];
if (table != null && table.IsLarge(0))
return sizeof(uint);
return sizeof(ushort);
}
public void AddTable(MetaDataTableType type)
{
MetaDataTable table = new MetaDataTable(this, true);
table._type = type;
_tables[(int)type] = table;
MaskValid |= ((ulong)1 << (int)type);
}
public MetaDataTable GetTable(MetaDataTableType type)
{
if (!HasTable(type))
return null;
return tables.FirstOrDefault(t => t != null && t.type == type);
}
public MetaDataTable GetTable(MetaDataTableType type)
{
return(GetTable(type, false));
}
public MetaDataTable GetTable(MetaDataTableType type)
{
return GetTable(type, false);
}
public bool HasTable(MetaDataTableType table)
{
return(((this.MaskValid >> (byte)table) & (ulong)1) == 1);
}
public MetaDataTable GetTable(MetaDataTableType type, bool addIfNotPresent)
{
if (!HasTable(type))
{
if (addIfNotPresent)
AddTable(type);
else
return null;
}
return _tables[(int)type];
}
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 byte GetDefaultIndex(MetaDataTableType type)
{
for (int i = 0;i< tableheap.tables.Length;i++)
if (tableheap.tables[i] != null)
if (tableheap.tables[i].type == type && tableheap.tables[i].IsLarge(0))
return sizeof(uint);
return sizeof(ushort);
}
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;
}
