public MetaDataTableNode(HexDocument doc, MDTable mdTable, IMetaData md)
: base((ulong)mdTable.StartOffset, (ulong)mdTable.EndOffset - 1) {
this.doc = doc;
this.tableInfo = mdTable.TableInfo;
this.tablesStreamVM = MetaDataTableVM.Create(this, doc, StartOffset, mdTable);
this.tablesStreamVM.FindMetaDataTable = FindMetaDataTable;
this.tablesStreamVM.InitializeHeapOffsets((ulong)md.StringsStream.StartOffset, (ulong)md.StringsStream.EndOffset - 1);
}
Tuple<int[], Action<ITextColorWriter>> GetInfoTuple(TableInfo tableInfo) {
switch (tableInfo.Table) {
case Table.Module: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WriteModuleInfo);
case Table.TypeRef: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1, 2 }, WriteTypeRefInfo);
case Table.TypeDef: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1, 2 }, WriteTypeDefInfo);
case Table.FieldPtr: return null;
case Table.Field: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WriteFieldInfo);
case Table.MethodPtr: return null;
case Table.Method: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 3 }, WriteMethodInfo);
case Table.ParamPtr: return null;
case Table.Param: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 2 }, WriteParamInfo);
case Table.InterfaceImpl: return null;
case Table.MemberRef: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WriteMemberRefInfo);
case Table.Constant: return null;
case Table.CustomAttribute: return null;
case Table.FieldMarshal: return null;
case Table.DeclSecurity: return null;
case Table.ClassLayout: return null;
case Table.FieldLayout: return null;
case Table.StandAloneSig: return null;
case Table.EventMap: return null;
case Table.EventPtr: return null;
case Table.Event: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WriteEventInfo);
case Table.PropertyMap: return null;
case Table.PropertyPtr: return null;
case Table.Property: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WritePropertyInfo);
case Table.MethodSemantics: return null;
case Table.MethodImpl: return null;
case Table.ModuleRef: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 0 }, WriteModuleRefInfo);
case Table.TypeSpec: return null;
case Table.ImplMap: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 2 }, WriteImplMapInfo);
case Table.FieldRVA: return null;
case Table.ENCLog: return null;
case Table.ENCMap: return null;
case Table.Assembly: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 7 }, WriteAssemblyInfo);
case Table.AssemblyProcessor: return null;
case Table.AssemblyOS: return null;
case Table.AssemblyRef: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 6 }, WriteAssemblyRefInfo);
case Table.AssemblyRefProcessor: return null;
case Table.AssemblyRefOS: return null;
case Table.File: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 1 }, WriteFileInfo);
case Table.ExportedType: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 2, 3 }, WriteExportedTypeInfo);
case Table.ManifestResource: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 2 }, WriteManifestResourceInfo);
case Table.NestedClass: return null;
case Table.GenericParam: return new Tuple<int[], Action<ITextColorWriter>>(new int[] { 3 }, WriteGenericParamInfo);
case Table.MethodSpec: return null;
case Table.GenericParamConstraint: return null;
case Table.Document: return null;
case Table.MethodDebugInformation: return null;
case Table.LocalScope: return null;
case Table.LocalVariable: return null;
case Table.LocalConstant: return null;
case Table.ImportScope: return null;
case Table.StateMachineMethod: return null;
case Table.CustomDebugInformation: return null;
default: throw new InvalidOperationException();
}
}
public static bool CanSort(TableInfo table) {
switch (table.Table) {
case Table.InterfaceImpl:
case Table.Constant:
case Table.CustomAttribute:
case Table.FieldMarshal:
case Table.DeclSecurity:
case Table.ClassLayout:
case Table.FieldLayout:
case Table.EventMap:
case Table.PropertyMap:
case Table.MethodSemantics:
case Table.MethodImpl:
case Table.ImplMap:
case Table.FieldRVA:
case Table.NestedClass:
case Table.GenericParam:
case Table.GenericParamConstraint:
return true;
case Table.Module:
case Table.TypeRef:
case Table.TypeDef:
case Table.FieldPtr:
case Table.Field:
case Table.MethodPtr:
case Table.Method:
case Table.ParamPtr:
case Table.Param:
case Table.MemberRef:
case Table.StandAloneSig:
case Table.EventPtr:
case Table.Event:
case Table.PropertyPtr:
case Table.Property:
case Table.ModuleRef:
case Table.TypeSpec:
case Table.ENCLog:
case Table.ENCMap:
case Table.Assembly:
case Table.AssemblyProcessor:
case Table.AssemblyOS:
case Table.AssemblyRef:
case Table.AssemblyRefProcessor:
case Table.AssemblyRefOS:
case Table.File:
case Table.ExportedType:
case Table.ManifestResource:
case Table.MethodSpec:
default:
return false;
}
}
static TableInfo CreateTableInfo(TableInfo info) {
var newCols = new List<ColumnInfo>(info.Columns.Count + 1);
int offs = 0;
for (int i = 0, coli = 0; i < info.Columns.Count; i++, coli++) {
var col = info.Columns[i];
newCols.Add(new ColumnInfo((byte)coli, col.Name, col.ColumnSize, (byte)offs, (byte)col.Size));
offs += col.Size;
int nextOffs = i + 1 >= info.Columns.Count ? info.RowSize : info.Columns[i + 1].Offset;
int padding = nextOffs - (col.Offset + col.Size);
for (int j = 0; j < padding; j++) {
newCols.Add(new ColumnInfo((byte)(coli++ + 1), dnSpy_AsmEditor_Resources.Padding, ColumnSize.Byte, (byte)offs, 1));
offs++;
}
}
return new TableInfo(info.Table, info.Name, newCols.ToArray(), offs);
}
protected MetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable)
: base(owner) {
this.doc = doc;
this.startOffset = startOffset;
this.endOffset = startOffset + (mdTable.Rows == 0 ? 0 : (ulong)mdTable.Rows * mdTable.RowSize - 1);
this.numRows = mdTable.Rows;
this.tableInfo = CreateTableInfo(mdTable.TableInfo);
this.virtList = new VirtualizedList<MetaDataTableRecordVM>((int)numRows, CreateItem);
}
protected MetaDataTableRecordVM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
{
this.mdVM = mdVM;
this.name = string.Format("{0}[{1:X6}]", mdToken.Table, mdToken.Rid);
this.doc = doc;
this.startOffset = startOffset;
this.endOffset = startOffset + (uint)tableInfo.RowSize - 1;
this.mdToken = mdToken;
this.tableInfo = tableInfo;
this.hexFields = new HexField[tableInfo.Columns.Count];
for (int i = 0; i < this.hexFields.Length; i++)
this.hexFields[i] = CreateField(tableInfo.Columns[i]);
}
public MemberRefMetaDataTableRecordVM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
: base(mdVM, doc, startOffset, mdToken, tableInfo)
{
}
public ManifestResourceMetaDataTableRecordVM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
: base(mdVM, doc, startOffset, mdToken, tableInfo)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="table">The table</param>
/// <param name="numRows">Number of rows in this table</param>
/// <param name="tableInfo">Info about this table</param>
internal MDTable(Table table, uint numRows, TableInfo tableInfo) {
this.table = table;
this.numRows = numRows;
this.tableInfo = tableInfo;
}
public AssemblyRefProcessorMetaDataTableRecordVM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
: base(mdVM, doc, startOffset, mdToken, tableInfo)
{
}
public static void Sort(TableInfo table, byte[] data) {
Debug.Assert(data.Length % table.RowSize == 0);
var recs = new Record[data.Length / table.RowSize];
for (int i = 0, offs = 0; i < recs.Length; i++, offs += table.RowSize) {
var d = new byte[table.RowSize];
recs[i] = new Record(i, d);
Array.Copy(data, offs, d, 0, d.Length);
}
switch (table.Table) {
case Table.CustomAttribute:
case Table.FieldMarshal:
case Table.EventMap:
case Table.PropertyMap:
case Table.MethodImpl:
case Table.NestedClass:
case Table.GenericParamConstraint:
Array.Sort(recs, (a, b) => {
uint ac = Read(table, a.Data, 0);
uint bc = Read(table, b.Data, 0);
if (ac != bc)
return ac.CompareTo(bc);
return a.OrigIndex.CompareTo(b.OrigIndex);
});
break;
case Table.DeclSecurity:
case Table.FieldLayout:
case Table.ImplMap:
case Table.FieldRVA:
Array.Sort(recs, (a, b) => {
uint ac = Read(table, a.Data, 1);
uint bc = Read(table, b.Data, 1);
if (ac != bc)
return ac.CompareTo(bc);
return a.OrigIndex.CompareTo(b.OrigIndex);
});
break;
case Table.Constant:
case Table.ClassLayout:
case Table.MethodSemantics:
Array.Sort(recs, (a, b) => {
// Constant: Parent column is 2 and not 1 because a 'pad' column has been inserted
uint ac = Read(table, a.Data, 2);
uint bc = Read(table, b.Data, 2);
if (ac != bc)
return ac.CompareTo(bc);
return a.OrigIndex.CompareTo(b.OrigIndex);
});
break;
case Table.InterfaceImpl:
Array.Sort(recs, (a, b) => {
uint ac = Read(table, a.Data, 0);
uint bc = Read(table, b.Data, 0);
if (ac != bc)
return ac.CompareTo(bc);
ac = Read(table, a.Data, 1);
bc = Read(table, b.Data, 1);
if (ac != bc)
return ac.CompareTo(bc);
return a.OrigIndex.CompareTo(b.OrigIndex);
});
break;
case Table.GenericParam:
Array.Sort(recs, (a, b) => {
uint ac = Read(table, a.Data, 2);
uint bc = Read(table, b.Data, 2);
if (ac != bc)
return ac.CompareTo(bc);
ac = Read(table, a.Data, 0);
bc = Read(table, b.Data, 0);
if (ac != bc)
return ac.CompareTo(bc);
return a.OrigIndex.CompareTo(b.OrigIndex);
});
break;
default:
Debug.Fail("Can't sort it. Call CanSort() first");
return;
}
for (int i = 0, offs = 0; i < recs.Length; i++, offs += table.RowSize) {
var d = recs[i].Data;
Array.Copy(d, 0, data, offs, d.Length);
}
}
static uint Read(TableInfo table, byte[] rec, int colIndex) {
var col = table.Columns[colIndex];
if (col.Size == 2)
return BitConverter.ToUInt16(rec, col.Offset);
if (col.Size == 4)
return BitConverter.ToUInt32(rec, col.Offset);
throw new InvalidOperationException();
}
/// <inheritdoc/>
public void Dispose() {
var ims = imageStream;
if (ims != null)
ims.Dispose();
numRows = 0;
tableInfo = null;
imageStream = null;
}
public MetaDataTableRecordTreeNode(TableInfo tableInfo, int index, ulong startOffset, ulong endOffset)
: base(startOffset, endOffset) {
this.index = index;
this.infoTuple = GetInfoTuple(tableInfo);
}
public CustomAttributeMetaDataTableRecordVM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
: base(mdVM, doc, startOffset, mdToken, tableInfo)
{
}
public MetaDataTableRecordNode(TableInfo tableInfo, int index, HexPosition startOffset, HexPosition endOffset)
: base(HexSpan.FromBounds(startOffset, endOffset)) {
this.index = index;
infoTuple = GetInfoTuple(tableInfo);
}
public GenericParamMetaDataTableRecordV11VM(MetaDataTableVM mdVM, HexDocument doc, ulong startOffset, MDToken mdToken, TableInfo tableInfo)
: base(mdVM, doc, startOffset, mdToken, tableInfo)
{
}
/// <summary>
/// Creates the table infos
/// </summary>
/// <param name="majorVersion">Major table version</param>
/// <param name="minorVersion">Minor table version</param>
/// <param name="maxPresentTables">Initialized to max present tables (eg. 42 or 45)</param>
/// <returns>All table infos (not completely initialized)</returns>
public TableInfo[] CreateTables(byte majorVersion, byte minorVersion, out int maxPresentTables) {
// The three extra generics tables aren't used by CLR 1.x
maxPresentTables = (majorVersion == 1 && minorVersion == 0) ? (int)Table.NestedClass + 1 : (int)Table.GenericParamConstraint + 1;
var tableInfos = new TableInfo[(int)Table.GenericParamConstraint + 1];
tableInfos[(int)Table.Module] = new TableInfo(Table.Module, "Module", new ColumnInfo[] {
new ColumnInfo(0, "Generation", ColumnSize.UInt16),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Mvid", ColumnSize.GUID),
new ColumnInfo(3, "EncId", ColumnSize.GUID),
new ColumnInfo(4, "EncBaseId", ColumnSize.GUID),
});
tableInfos[(int)Table.TypeRef] = new TableInfo(Table.TypeRef, "TypeRef", new ColumnInfo[] {
new ColumnInfo(0, "ResolutionScope", ColumnSize.ResolutionScope),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Namespace", ColumnSize.Strings),
});
tableInfos[(int)Table.TypeDef] = new TableInfo(Table.TypeDef, "TypeDef", new ColumnInfo[] {
new ColumnInfo(0, "Flags", ColumnSize.UInt32),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Namespace", ColumnSize.Strings),
new ColumnInfo(3, "Extends", ColumnSize.TypeDefOrRef),
new ColumnInfo(4, "FieldList", ColumnSize.Field),
new ColumnInfo(5, "MethodList", ColumnSize.Method),
});
tableInfos[(int)Table.FieldPtr] = new TableInfo(Table.FieldPtr, "FieldPtr", new ColumnInfo[] {
new ColumnInfo(0, "Field", ColumnSize.Field),
});
tableInfos[(int)Table.Field] = new TableInfo(Table.Field, "Field", new ColumnInfo[] {
new ColumnInfo(0, "Flags", ColumnSize.UInt16),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Signature", ColumnSize.Blob),
});
tableInfos[(int)Table.MethodPtr] = new TableInfo(Table.MethodPtr, "MethodPtr", new ColumnInfo[] {
new ColumnInfo(0, "Method", ColumnSize.Method),
});
tableInfos[(int)Table.Method] = new TableInfo(Table.Method, "Method", new ColumnInfo[] {
new ColumnInfo(0, "RVA", ColumnSize.UInt32),
new ColumnInfo(1, "ImplFlags", ColumnSize.UInt16),
new ColumnInfo(2, "Flags", ColumnSize.UInt16),
new ColumnInfo(3, "Name", ColumnSize.Strings),
new ColumnInfo(4, "Signature", ColumnSize.Blob),
new ColumnInfo(5, "ParamList", ColumnSize.Param),
});
tableInfos[(int)Table.ParamPtr] = new TableInfo(Table.ParamPtr, "ParamPtr", new ColumnInfo[] {
new ColumnInfo(0, "Param", ColumnSize.Param),
});
tableInfos[(int)Table.Param] = new TableInfo(Table.Param, "Param", new ColumnInfo[] {
new ColumnInfo(0, "Flags", ColumnSize.UInt16),
new ColumnInfo(1, "Sequence", ColumnSize.UInt16),
new ColumnInfo(2, "Name", ColumnSize.Strings),
});
tableInfos[(int)Table.InterfaceImpl] = new TableInfo(Table.InterfaceImpl, "InterfaceImpl", new ColumnInfo[] {
new ColumnInfo(0, "Class", ColumnSize.TypeDef),
new ColumnInfo(1, "Interface", ColumnSize.TypeDefOrRef),
});
tableInfos[(int)Table.MemberRef] = new TableInfo(Table.MemberRef, "MemberRef", new ColumnInfo[] {
new ColumnInfo(0, "Class", ColumnSize.MemberRefParent),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Signature", ColumnSize.Blob),
});
tableInfos[(int)Table.Constant] = new TableInfo(Table.Constant, "Constant", new ColumnInfo[] {
new ColumnInfo(0, "Type", ColumnSize.Byte),
new ColumnInfo(1, "Parent", ColumnSize.HasConstant),
new ColumnInfo(2, "Value", ColumnSize.Blob),
});
tableInfos[(int)Table.CustomAttribute] = new TableInfo(Table.CustomAttribute, "CustomAttribute", new ColumnInfo[] {
new ColumnInfo(0, "Parent", ColumnSize.HasCustomAttribute),
new ColumnInfo(1, "Type", ColumnSize.CustomAttributeType),
new ColumnInfo(2, "Value", ColumnSize.Blob),
});
tableInfos[(int)Table.FieldMarshal] = new TableInfo(Table.FieldMarshal, "FieldMarshal", new ColumnInfo[] {
new ColumnInfo(0, "Parent", ColumnSize.HasFieldMarshal),
new ColumnInfo(1, "NativeType", ColumnSize.Blob),
});
tableInfos[(int)Table.DeclSecurity] = new TableInfo(Table.DeclSecurity, "DeclSecurity", new ColumnInfo[] {
new ColumnInfo(0, "Action", ColumnSize.Int16),
new ColumnInfo(1, "Parent", ColumnSize.HasDeclSecurity),
new ColumnInfo(2, "PermissionSet", ColumnSize.Blob),
});
tableInfos[(int)Table.ClassLayout] = new TableInfo(Table.ClassLayout, "ClassLayout", new ColumnInfo[] {
new ColumnInfo(0, "PackingSize", ColumnSize.UInt16),
new ColumnInfo(1, "ClassSize", ColumnSize.UInt32),
new ColumnInfo(2, "Parent", ColumnSize.TypeDef),
});
tableInfos[(int)Table.FieldLayout] = new TableInfo(Table.FieldLayout, "FieldLayout", new ColumnInfo[] {
new ColumnInfo(0, "OffSet", ColumnSize.UInt32),
new ColumnInfo(1, "Field", ColumnSize.Field),
});
tableInfos[(int)Table.StandAloneSig] = new TableInfo(Table.StandAloneSig, "StandAloneSig", new ColumnInfo[] {
new ColumnInfo(0, "Signature", ColumnSize.Blob),
});
tableInfos[(int)Table.EventMap] = new TableInfo(Table.EventMap, "EventMap", new ColumnInfo[] {
new ColumnInfo(0, "Parent", ColumnSize.TypeDef),
new ColumnInfo(1, "EventList", ColumnSize.Event),
});
tableInfos[(int)Table.EventPtr] = new TableInfo(Table.EventPtr, "EventPtr", new ColumnInfo[] {
new ColumnInfo(0, "Event", ColumnSize.Event),
});
tableInfos[(int)Table.Event] = new TableInfo(Table.Event, "Event", new ColumnInfo[] {
new ColumnInfo(0, "EventFlags", ColumnSize.UInt16),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "EventType", ColumnSize.TypeDefOrRef),
});
tableInfos[(int)Table.PropertyMap] = new TableInfo(Table.PropertyMap, "PropertyMap", new ColumnInfo[] {
new ColumnInfo(0, "Parent", ColumnSize.TypeDef),
new ColumnInfo(1, "PropertyList", ColumnSize.Property),
});
tableInfos[(int)Table.PropertyPtr] = new TableInfo(Table.PropertyPtr, "PropertyPtr", new ColumnInfo[] {
new ColumnInfo(0, "Property", ColumnSize.Property),
});
tableInfos[(int)Table.Property] = new TableInfo(Table.Property, "Property", new ColumnInfo[] {
new ColumnInfo(0, "PropFlags", ColumnSize.UInt16),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "Type", ColumnSize.Blob),
});
tableInfos[(int)Table.MethodSemantics] = new TableInfo(Table.MethodSemantics, "MethodSemantics", new ColumnInfo[] {
new ColumnInfo(0, "Semantic", ColumnSize.UInt16),
new ColumnInfo(1, "Method", ColumnSize.Method),
new ColumnInfo(2, "Association", ColumnSize.HasSemantic),
});
tableInfos[(int)Table.MethodImpl] = new TableInfo(Table.MethodImpl, "MethodImpl", new ColumnInfo[] {
new ColumnInfo(0, "Class", ColumnSize.TypeDef),
new ColumnInfo(1, "MethodBody", ColumnSize.MethodDefOrRef),
new ColumnInfo(2, "MethodDeclaration", ColumnSize.MethodDefOrRef),
});
tableInfos[(int)Table.ModuleRef] = new TableInfo(Table.ModuleRef, "ModuleRef", new ColumnInfo[] {
new ColumnInfo(0, "Name", ColumnSize.Strings),
});
tableInfos[(int)Table.TypeSpec] = new TableInfo(Table.TypeSpec, "TypeSpec", new ColumnInfo[] {
new ColumnInfo(0, "Signature", ColumnSize.Blob),
});
tableInfos[(int)Table.ImplMap] = new TableInfo(Table.ImplMap, "ImplMap", new ColumnInfo[] {
new ColumnInfo(0, "MappingFlags", ColumnSize.UInt16),
new ColumnInfo(1, "MemberForwarded", ColumnSize.MemberForwarded),
new ColumnInfo(2, "ImportName", ColumnSize.Strings),
new ColumnInfo(3, "ImportScope", ColumnSize.ModuleRef),
});
tableInfos[(int)Table.FieldRVA] = new TableInfo(Table.FieldRVA, "FieldRVA", new ColumnInfo[] {
new ColumnInfo(0, "RVA", ColumnSize.UInt32),
new ColumnInfo(1, "Field", ColumnSize.Field),
});
tableInfos[(int)Table.ENCLog] = new TableInfo(Table.ENCLog, "ENCLog", new ColumnInfo[] {
new ColumnInfo(0, "Token", ColumnSize.UInt32),
new ColumnInfo(1, "FuncCode", ColumnSize.UInt32),
});
tableInfos[(int)Table.ENCMap] = new TableInfo(Table.ENCMap, "ENCMap", new ColumnInfo[] {
new ColumnInfo(0, "Token", ColumnSize.UInt32),
});
tableInfos[(int)Table.Assembly] = new TableInfo(Table.Assembly, "Assembly", new ColumnInfo[] {
new ColumnInfo(0, "HashAlgId", ColumnSize.UInt32),
new ColumnInfo(1, "MajorVersion", ColumnSize.UInt16),
new ColumnInfo(2, "MinorVersion", ColumnSize.UInt16),
new ColumnInfo(3, "BuildNumber", ColumnSize.UInt16),
new ColumnInfo(4, "RevisionNumber", ColumnSize.UInt16),
new ColumnInfo(5, "Flags", ColumnSize.UInt32),
new ColumnInfo(6, "PublicKey", ColumnSize.Blob),
new ColumnInfo(7, "Name", ColumnSize.Strings),
new ColumnInfo(8, "Locale", ColumnSize.Strings),
});
tableInfos[(int)Table.AssemblyProcessor] = new TableInfo(Table.AssemblyProcessor, "AssemblyProcessor", new ColumnInfo[] {
new ColumnInfo(0, "Processor", ColumnSize.UInt32),
});
tableInfos[(int)Table.AssemblyOS] = new TableInfo(Table.AssemblyOS, "AssemblyOS", new ColumnInfo[] {
new ColumnInfo(0, "OSPlatformId", ColumnSize.UInt32),
new ColumnInfo(1, "OSMajorVersion", ColumnSize.UInt32),
new ColumnInfo(2, "OSMinorVersion", ColumnSize.UInt32),
});
tableInfos[(int)Table.AssemblyRef] = new TableInfo(Table.AssemblyRef, "AssemblyRef", new ColumnInfo[] {
new ColumnInfo(0, "MajorVersion", ColumnSize.UInt16),
new ColumnInfo(1, "MinorVersion", ColumnSize.UInt16),
new ColumnInfo(2, "BuildNumber", ColumnSize.UInt16),
new ColumnInfo(3, "RevisionNumber", ColumnSize.UInt16),
new ColumnInfo(4, "Flags", ColumnSize.UInt32),
new ColumnInfo(5, "PublicKeyOrToken", ColumnSize.Blob),
new ColumnInfo(6, "Name", ColumnSize.Strings),
new ColumnInfo(7, "Locale", ColumnSize.Strings),
new ColumnInfo(8, "HashValue", ColumnSize.Blob),
});
tableInfos[(int)Table.AssemblyRefProcessor] = new TableInfo(Table.AssemblyRefProcessor, "AssemblyRefProcessor", new ColumnInfo[] {
new ColumnInfo(0, "Processor", ColumnSize.UInt32),
new ColumnInfo(1, "AssemblyRef", ColumnSize.AssemblyRef),
});
tableInfos[(int)Table.AssemblyRefOS] = new TableInfo(Table.AssemblyRefOS, "AssemblyRefOS", new ColumnInfo[] {
new ColumnInfo(0, "OSPlatformId", ColumnSize.UInt32),
new ColumnInfo(1, "OSMajorVersion", ColumnSize.UInt32),
new ColumnInfo(2, "OSMinorVersion", ColumnSize.UInt32),
new ColumnInfo(3, "AssemblyRef", ColumnSize.AssemblyRef),
});
tableInfos[(int)Table.File] = new TableInfo(Table.File, "File", new ColumnInfo[] {
new ColumnInfo(0, "Flags", ColumnSize.UInt32),
new ColumnInfo(1, "Name", ColumnSize.Strings),
new ColumnInfo(2, "HashValue", ColumnSize.Blob),
});
tableInfos[(int)Table.ExportedType] = new TableInfo(Table.ExportedType, "ExportedType", new ColumnInfo[] {
new ColumnInfo(0, "Flags", ColumnSize.UInt32),
new ColumnInfo(1, "TypeDefId", ColumnSize.UInt32),
new ColumnInfo(2, "TypeName", ColumnSize.Strings),
new ColumnInfo(3, "TypeNamespace", ColumnSize.Strings),
new ColumnInfo(4, "Implementation", ColumnSize.Implementation),
});
tableInfos[(int)Table.ManifestResource] = new TableInfo(Table.ManifestResource, "ManifestResource", new ColumnInfo[] {
new ColumnInfo(0, "Offset", ColumnSize.UInt32),
new ColumnInfo(1, "Flags", ColumnSize.UInt32),
new ColumnInfo(2, "Name", ColumnSize.Strings),
new ColumnInfo(3, "Implementation", ColumnSize.Implementation),
});
tableInfos[(int)Table.NestedClass] = new TableInfo(Table.NestedClass, "NestedClass", new ColumnInfo[] {
new ColumnInfo(0, "NestedClass", ColumnSize.TypeDef),
new ColumnInfo(1, "EnclosingClass", ColumnSize.TypeDef),
});
if (majorVersion == 1 && minorVersion == 1) {
tableInfos[(int)Table.GenericParam] = new TableInfo(Table.GenericParam, "GenericParam", new ColumnInfo[] {
new ColumnInfo(0, "Number", ColumnSize.UInt16),
new ColumnInfo(1, "Flags", ColumnSize.UInt16),
new ColumnInfo(2, "Owner", ColumnSize.TypeOrMethodDef),
new ColumnInfo(3, "Name", ColumnSize.Strings),
new ColumnInfo(4, "Kind", ColumnSize.TypeDefOrRef),
});
}
else {
tableInfos[(int)Table.GenericParam] = new TableInfo(Table.GenericParam, "GenericParam", new ColumnInfo[] {
new ColumnInfo(0, "Number", ColumnSize.UInt16),
new ColumnInfo(1, "Flags", ColumnSize.UInt16),
new ColumnInfo(2, "Owner", ColumnSize.TypeOrMethodDef),
new ColumnInfo(3, "Name", ColumnSize.Strings),
});
}
tableInfos[(int)Table.MethodSpec] = new TableInfo(Table.MethodSpec, "MethodSpec", new ColumnInfo[] {
new ColumnInfo(0, "Method", ColumnSize.MethodDefOrRef),
new ColumnInfo(1, "Instantiation", ColumnSize.Blob),
});
tableInfos[(int)Table.GenericParamConstraint] = new TableInfo(Table.GenericParamConstraint, "GenericParamConstraint", new ColumnInfo[] {
new ColumnInfo(0, "Owner", ColumnSize.GenericParam),
new ColumnInfo(1, "Constraint", ColumnSize.TypeDefOrRef),
});
return this.tableInfos = tableInfos;
}
/// <inheritdoc/>
public void Dispose() {
if (imageStream != null)
imageStream.Dispose();
numRows = 0;
tableInfo = null;
imageStream = null;
}
