public void RedirectedRangeMultipleItems()
{
var stream = new TablesStream();
var redirectTable = stream.GetTable <MethodPointerRow>();
redirectTable.Add(new MethodPointerRow(1));
redirectTable.Add(new MethodPointerRow(2));
redirectTable.Add(new MethodPointerRow(5));
redirectTable.Add(new MethodPointerRow(4));
redirectTable.Add(new MethodPointerRow(3));
redirectTable.Add(new MethodPointerRow(9));
redirectTable.Add(new MethodPointerRow(8));
redirectTable.Add(new MethodPointerRow(10));
var range = new RedirectedMetadataRange(redirectTable, TableIndex.Method, 3, 8);
Assert.Equal(5, range.Count);
Assert.Equal(new[]
{
new MetadataToken(TableIndex.Method, 5),
new MetadataToken(TableIndex.Method, 4),
new MetadataToken(TableIndex.Method, 3),
new MetadataToken(TableIndex.Method, 9),
new MetadataToken(TableIndex.Method, 8)
}, range);
}
private static FieldRvaRow FindFieldRvaRow(TablesStream tablesStream, MetadataToken cctorToken, MetadataToken fieldToken)
{
var reader = tablesStream
.GetTable <MethodDefinitionRow>(TableIndex.Method)
.GetByRid(cctorToken.Rid)
.Body.CreateReader();
var body = CilRawMethodBody.FromReader(ThrowErrorListener.Instance, reader);
var disassembler = new CilDisassembler(new ByteArrayReader(body.Code));
var initialValueFieldToken = MetadataToken.Zero;
var instructions = disassembler.ReadAllInstructions();
for (int i = 0; i < instructions.Count; i++)
{
if (instructions[i].OpCode.Code == CilCode.Ldtoken &&
instructions[i + 2].OpCode.Code == CilCode.Stsfld &&
(MetadataToken)instructions[i + 2].Operand == fieldToken)
{
initialValueFieldToken = (MetadataToken)instructions[i].Operand;
break;
}
}
Assert.NotEqual(MetadataToken.Zero, initialValueFieldToken);
Assert.True(tablesStream
.GetTable <FieldRvaRow>(TableIndex.FieldRva)
.TryGetRowByKey(1, initialValueFieldToken.Rid, out var fieldRvaRow));
return(fieldRvaRow);
}
public TablesMDHeap(MetadataEditor mdEditor, TablesStream tablesStream)
{
this.mdEditor = mdEditor ?? throw new ArgumentNullException(nameof(mdEditor));
this.tablesStream = tablesStream ?? throw new ArgumentNullException(nameof(tablesStream));
allTableInfos = new TableInfo[64];
allTableInfos[(int)Table.Module] = ModuleTable = new TableInfo <RawModuleRow>(mdEditor.ModuleData, tablesStream.ModuleTable, rid => { this.tablesStream.TryReadModuleRow(rid, out var row); return(row); });
allTableInfos[(int)Table.TypeRef] = TypeRefTable = new TableInfo <RawTypeRefRow>(mdEditor.ModuleData, tablesStream.TypeRefTable, rid => { this.tablesStream.TryReadTypeRefRow(rid, out var row); return(row); });
allTableInfos[(int)Table.TypeDef] = TypeDefTable = new TableInfo <RawTypeDefRow>(mdEditor.ModuleData, tablesStream.TypeDefTable, rid => { this.tablesStream.TryReadTypeDefRow(rid, out var row); return(row); });
allTableInfos[(int)Table.FieldPtr] = FieldPtrTable = new TableInfo <RawFieldPtrRow>(mdEditor.ModuleData, tablesStream.FieldPtrTable, rid => { this.tablesStream.TryReadFieldPtrRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Field] = FieldTable = new TableInfo <RawFieldRow>(mdEditor.ModuleData, tablesStream.FieldTable, rid => { this.tablesStream.TryReadFieldRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MethodPtr] = MethodPtrTable = new TableInfo <RawMethodPtrRow>(mdEditor.ModuleData, tablesStream.MethodPtrTable, rid => { this.tablesStream.TryReadMethodPtrRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Method] = MethodTable = new TableInfo <RawMethodRow>(mdEditor.ModuleData, tablesStream.MethodTable, rid => { this.tablesStream.TryReadMethodRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ParamPtr] = ParamPtrTable = new TableInfo <RawParamPtrRow>(mdEditor.ModuleData, tablesStream.ParamPtrTable, rid => { this.tablesStream.TryReadParamPtrRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Param] = ParamTable = new TableInfo <RawParamRow>(mdEditor.ModuleData, tablesStream.ParamTable, rid => { this.tablesStream.TryReadParamRow(rid, out var row); return(row); });
allTableInfos[(int)Table.InterfaceImpl] = InterfaceImplTable = new TableInfo <RawInterfaceImplRow>(mdEditor.ModuleData, tablesStream.InterfaceImplTable, rid => { this.tablesStream.TryReadInterfaceImplRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MemberRef] = MemberRefTable = new TableInfo <RawMemberRefRow>(mdEditor.ModuleData, tablesStream.MemberRefTable, rid => { this.tablesStream.TryReadMemberRefRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Constant] = ConstantTable = new TableInfo <RawConstantRow>(mdEditor.ModuleData, tablesStream.ConstantTable, rid => { this.tablesStream.TryReadConstantRow(rid, out var row); return(row); });
allTableInfos[(int)Table.CustomAttribute] = CustomAttributeTable = new TableInfo <RawCustomAttributeRow>(mdEditor.ModuleData, tablesStream.CustomAttributeTable, rid => { this.tablesStream.TryReadCustomAttributeRow(rid, out var row); return(row); });
allTableInfos[(int)Table.FieldMarshal] = FieldMarshalTable = new TableInfo <RawFieldMarshalRow>(mdEditor.ModuleData, tablesStream.FieldMarshalTable, rid => { this.tablesStream.TryReadFieldMarshalRow(rid, out var row); return(row); });
allTableInfos[(int)Table.DeclSecurity] = DeclSecurityTable = new TableInfo <RawDeclSecurityRow>(mdEditor.ModuleData, tablesStream.DeclSecurityTable, rid => { this.tablesStream.TryReadDeclSecurityRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ClassLayout] = ClassLayoutTable = new TableInfo <RawClassLayoutRow>(mdEditor.ModuleData, tablesStream.ClassLayoutTable, rid => { this.tablesStream.TryReadClassLayoutRow(rid, out var row); return(row); });
allTableInfos[(int)Table.FieldLayout] = FieldLayoutTable = new TableInfo <RawFieldLayoutRow>(mdEditor.ModuleData, tablesStream.FieldLayoutTable, rid => { this.tablesStream.TryReadFieldLayoutRow(rid, out var row); return(row); });
allTableInfos[(int)Table.StandAloneSig] = StandAloneSigTable = new TableInfo <RawStandAloneSigRow>(mdEditor.ModuleData, tablesStream.StandAloneSigTable, rid => { this.tablesStream.TryReadStandAloneSigRow(rid, out var row); return(row); });
allTableInfos[(int)Table.EventMap] = EventMapTable = new TableInfo <RawEventMapRow>(mdEditor.ModuleData, tablesStream.EventMapTable, rid => { this.tablesStream.TryReadEventMapRow(rid, out var row); return(row); });
allTableInfos[(int)Table.EventPtr] = EventPtrTable = new TableInfo <RawEventPtrRow>(mdEditor.ModuleData, tablesStream.EventPtrTable, rid => { this.tablesStream.TryReadEventPtrRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Event] = EventTable = new TableInfo <RawEventRow>(mdEditor.ModuleData, tablesStream.EventTable, rid => { this.tablesStream.TryReadEventRow(rid, out var row); return(row); });
allTableInfos[(int)Table.PropertyMap] = PropertyMapTable = new TableInfo <RawPropertyMapRow>(mdEditor.ModuleData, tablesStream.PropertyMapTable, rid => { this.tablesStream.TryReadPropertyMapRow(rid, out var row); return(row); });
allTableInfos[(int)Table.PropertyPtr] = PropertyPtrTable = new TableInfo <RawPropertyPtrRow>(mdEditor.ModuleData, tablesStream.PropertyPtrTable, rid => { this.tablesStream.TryReadPropertyPtrRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Property] = PropertyTable = new TableInfo <RawPropertyRow>(mdEditor.ModuleData, tablesStream.PropertyTable, rid => { this.tablesStream.TryReadPropertyRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MethodSemantics] = MethodSemanticsTable = new TableInfo <RawMethodSemanticsRow>(mdEditor.ModuleData, tablesStream.MethodSemanticsTable, rid => { this.tablesStream.TryReadMethodSemanticsRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MethodImpl] = MethodImplTable = new TableInfo <RawMethodImplRow>(mdEditor.ModuleData, tablesStream.MethodImplTable, rid => { this.tablesStream.TryReadMethodImplRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ModuleRef] = ModuleRefTable = new TableInfo <RawModuleRefRow>(mdEditor.ModuleData, tablesStream.ModuleRefTable, rid => { this.tablesStream.TryReadModuleRefRow(rid, out var row); return(row); });
allTableInfos[(int)Table.TypeSpec] = TypeSpecTable = new TableInfo <RawTypeSpecRow>(mdEditor.ModuleData, tablesStream.TypeSpecTable, rid => { this.tablesStream.TryReadTypeSpecRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ImplMap] = ImplMapTable = new TableInfo <RawImplMapRow>(mdEditor.ModuleData, tablesStream.ImplMapTable, rid => { this.tablesStream.TryReadImplMapRow(rid, out var row); return(row); });
allTableInfos[(int)Table.FieldRVA] = FieldRVATable = new TableInfo <RawFieldRVARow>(mdEditor.ModuleData, tablesStream.FieldRVATable, rid => { this.tablesStream.TryReadFieldRVARow(rid, out var row); return(row); });
allTableInfos[(int)Table.ENCLog] = ENCLogTable = new TableInfo <RawENCLogRow>(mdEditor.ModuleData, tablesStream.ENCLogTable, rid => { this.tablesStream.TryReadENCLogRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ENCMap] = ENCMapTable = new TableInfo <RawENCMapRow>(mdEditor.ModuleData, tablesStream.ENCMapTable, rid => { this.tablesStream.TryReadENCMapRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Assembly] = AssemblyTable = new TableInfo <RawAssemblyRow>(mdEditor.ModuleData, tablesStream.AssemblyTable, rid => { this.tablesStream.TryReadAssemblyRow(rid, out var row); return(row); });
allTableInfos[(int)Table.AssemblyProcessor] = AssemblyProcessorTable = new TableInfo <RawAssemblyProcessorRow>(mdEditor.ModuleData, tablesStream.AssemblyProcessorTable, rid => { this.tablesStream.TryReadAssemblyProcessorRow(rid, out var row); return(row); });
allTableInfos[(int)Table.AssemblyOS] = AssemblyOSTable = new TableInfo <RawAssemblyOSRow>(mdEditor.ModuleData, tablesStream.AssemblyOSTable, rid => { this.tablesStream.TryReadAssemblyOSRow(rid, out var row); return(row); });
allTableInfos[(int)Table.AssemblyRef] = AssemblyRefTable = new TableInfo <RawAssemblyRefRow>(mdEditor.ModuleData, tablesStream.AssemblyRefTable, rid => { this.tablesStream.TryReadAssemblyRefRow(rid, out var row); return(row); });
allTableInfos[(int)Table.AssemblyRefProcessor] = AssemblyRefProcessorTable = new TableInfo <RawAssemblyRefProcessorRow>(mdEditor.ModuleData, tablesStream.AssemblyRefProcessorTable, rid => { this.tablesStream.TryReadAssemblyRefProcessorRow(rid, out var row); return(row); });
allTableInfos[(int)Table.AssemblyRefOS] = AssemblyRefOSTable = new TableInfo <RawAssemblyRefOSRow>(mdEditor.ModuleData, tablesStream.AssemblyRefOSTable, rid => { this.tablesStream.TryReadAssemblyRefOSRow(rid, out var row); return(row); });
allTableInfos[(int)Table.File] = FileTable = new TableInfo <RawFileRow>(mdEditor.ModuleData, tablesStream.FileTable, rid => { this.tablesStream.TryReadFileRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ExportedType] = ExportedTypeTable = new TableInfo <RawExportedTypeRow>(mdEditor.ModuleData, tablesStream.ExportedTypeTable, rid => { this.tablesStream.TryReadExportedTypeRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ManifestResource] = ManifestResourceTable = new TableInfo <RawManifestResourceRow>(mdEditor.ModuleData, tablesStream.ManifestResourceTable, rid => { this.tablesStream.TryReadManifestResourceRow(rid, out var row); return(row); });
allTableInfos[(int)Table.NestedClass] = NestedClassTable = new TableInfo <RawNestedClassRow>(mdEditor.ModuleData, tablesStream.NestedClassTable, rid => { this.tablesStream.TryReadNestedClassRow(rid, out var row); return(row); });
allTableInfos[(int)Table.GenericParam] = GenericParamTable = new TableInfo <RawGenericParamRow>(mdEditor.ModuleData, tablesStream.GenericParamTable, rid => { this.tablesStream.TryReadGenericParamRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MethodSpec] = MethodSpecTable = new TableInfo <RawMethodSpecRow>(mdEditor.ModuleData, tablesStream.MethodSpecTable, rid => { this.tablesStream.TryReadMethodSpecRow(rid, out var row); return(row); });
allTableInfos[(int)Table.GenericParamConstraint] = GenericParamConstraintTable = new TableInfo <RawGenericParamConstraintRow>(mdEditor.ModuleData, tablesStream.GenericParamConstraintTable, rid => { this.tablesStream.TryReadGenericParamConstraintRow(rid, out var row); return(row); });
allTableInfos[(int)Table.Document] = DocumentTable = new TableInfo <RawDocumentRow>(mdEditor.ModuleData, tablesStream.DocumentTable, rid => { this.tablesStream.TryReadDocumentRow(rid, out var row); return(row); });
allTableInfos[(int)Table.MethodDebugInformation] = MethodDebugInformationTable = new TableInfo <RawMethodDebugInformationRow>(mdEditor.ModuleData, tablesStream.MethodDebugInformationTable, rid => { this.tablesStream.TryReadMethodDebugInformationRow(rid, out var row); return(row); });
allTableInfos[(int)Table.LocalScope] = LocalScopeTable = new TableInfo <RawLocalScopeRow>(mdEditor.ModuleData, tablesStream.LocalScopeTable, rid => { this.tablesStream.TryReadLocalScopeRow(rid, out var row); return(row); });
allTableInfos[(int)Table.LocalVariable] = LocalVariableTable = new TableInfo <RawLocalVariableRow>(mdEditor.ModuleData, tablesStream.LocalVariableTable, rid => { this.tablesStream.TryReadLocalVariableRow(rid, out var row); return(row); });
allTableInfos[(int)Table.LocalConstant] = LocalConstantTable = new TableInfo <RawLocalConstantRow>(mdEditor.ModuleData, tablesStream.LocalConstantTable, rid => { this.tablesStream.TryReadLocalConstantRow(rid, out var row); return(row); });
allTableInfos[(int)Table.ImportScope] = ImportScopeTable = new TableInfo <RawImportScopeRow>(mdEditor.ModuleData, tablesStream.ImportScopeTable, rid => { this.tablesStream.TryReadImportScopeRow(rid, out var row); return(row); });
allTableInfos[(int)Table.StateMachineMethod] = StateMachineMethodTable = new TableInfo <RawStateMachineMethodRow>(mdEditor.ModuleData, tablesStream.StateMachineMethodTable, rid => { this.tablesStream.TryReadStateMachineMethodRow(rid, out var row); return(row); });
allTableInfos[(int)Table.CustomDebugInformation] = CustomDebugInformationTable = new TableInfo <RawCustomDebugInformationRow>(mdEditor.ModuleData, tablesStream.CustomDebugInformationTable, rid => { this.tablesStream.TryReadCustomDebugInformationRow(rid, out var row); return(row); });
}
/*
* private static UInt32 PadTo4(UInt32 RVA)
* {
* UInt32 Cleared = RVA & ~0x3U;
* return (RVA == Cleared) ? RVA : RVA + 0x4U;
* }
*/
internal void InitMetaData()
{
if (B == null)
{
throw new ObjectDisposedException(null);
}
if (parsedMetaData)
{
return;
}
SeekToRVA(MetaDataDDRVA);
UInt32 MetaDataRVA = B.ReadUInt32();
UInt32 MetaDataSize = B.ReadUInt32();
if ((MetaDataRVA == 0) || (MetaDataSize == 0))
{
throw new BadImageFormatException();
}
MetadataRoot = RVAToFileAddress(MetaDataRVA);
UInt32 VersionLengthRVA = MetaDataRVA + 12;
UInt32 VersionStringRVA = VersionLengthRVA + 4;
SeekToRVA(VersionLengthRVA);
UInt32 VersionLength = B.ReadUInt32();
String Version = ReadUTF8String(VersionLength);
UInt32 FlagsRVA = VersionStringRVA + VersionLength;
UInt32 NStreamsRVA = FlagsRVA + 2;
SeekToRVA(NStreamsRVA);
UInt16 NStreams = B.ReadUInt16();
Streams = new StreamDesc[NStreams];
for (int i = 0; i < NStreams; i++)
{
Streams[i] = new StreamDesc(B, MetadataRoot);
}
StreamDesc stringStream, blobStream, TablesStream;
if (!FindStream("#~", out TablesStream))
{
if (!FindStream("#-", out TablesStream))
{
throw new BadImageFormatException();
}
}
if (!FindStream("#Strings", out stringStream))
{
throw new BadImageFormatException();
}
if (!FindStream("#Blob", out blobStream))
{
throw new BadImageFormatException();
}
TablesStream.SeekTo(B, 0);
metaData = new MDTables(B, stringStream, blobStream);
// metaData.DumpStringHeap();
parsedMetaData = true;
}
public MDTableModel(MDTableHeapModel parent, IMetaData metadata, TablesStream stream, MDTable table)
{
Parent = parent;
MetaData = metadata;
Tables = stream;
MDTable = table;
Text = string.Format("{0:x2}: {1} (0x{2:x})", (byte)table.Table, table.Name, table.Rows);
}
public void RedirectedRangeEmpty()
{
var stream = new TablesStream();
var redirectTable = stream.GetTable <MethodPointerRow>();
var range = new RedirectedMetadataRange(redirectTable, TableIndex.Method, 3, 3);
Assert.Equal(0, range.Count);
Assert.Empty(range);
}
public TablesStreamTreeNode(HexDocument doc, TablesStream tblStream, IMetaData md)
: base((ulong)tblStream.StartOffset, (ulong)tblStream.MDTables[0].StartOffset - 1)
{
this.tablesStreamVM = new TablesStreamVM(this, doc, tblStream);
foreach (var mdTable in tblStream.MDTables)
{
if (mdTable.Rows != 0)
{
this.Children.Add(new MetaDataTableTreeNode(doc, mdTable, md));
}
}
}
public static void AssertWriteThenReadIsSame <TRow>(TRow expected,
SerializedMetadataTable <TRow> .ReadRowExtendedDelegate readRow)
where TRow : struct, IMetadataRow
{
var tablesStream = new TablesStream();
var table = tablesStream.GetTable <TRow>();
using var tempStream = new MemoryStream();
expected.Write(new BinaryStreamWriter(tempStream), table.Layout);
var newRow = readRow(new PEReaderContext(new PEFile()), new ByteArrayReader(tempStream.ToArray()), table.Layout);
Assert.Equal(expected, newRow);
}
public TablesStreamNode(HexBuffer buffer, TablesStream tblStream, IMetaData md)
: base(HexSpan.FromBounds((ulong)tblStream.StartOffset, (ulong)tblStream.MDTables[0].StartOffset))
{
tablesStreamVM = new TablesStreamVM(this, buffer, tblStream);
newChildren = new List <TreeNodeData>();
foreach (var mdTable in tblStream.MDTables)
{
if (mdTable.Rows != 0)
{
newChildren.Add(new MetaDataTableNode(buffer, mdTable, md));
}
}
}
public static void AssertWriteThenReadIsSame <TRow>(TRow expected,
SerializedMetadataTable <TRow> .ReadRowDelegate readRow)
where TRow : struct, IMetadataRow
{
var tablesStream = new TablesStream();
var table = tablesStream.GetTable <TRow>();
using var tempStream = new MemoryStream();
expected.Write(new BinaryStreamWriter(tempStream), table.Layout);
var reader = ByteArrayDataSource.CreateReader(tempStream.ToArray());
var newRow = readRow(ref reader, table.Layout);
Assert.Equal(expected, newRow);
}
void UpdateTreeView(IMetaData metadata, TablesStream stream)
{
for (int i = 0; i < 0x40; i++)
{
var table = (Table)i;
if (stream.HasTable(table))
{
var mdTable = stream.Get(table);
if (mdTable.Rows > 0)
{
treeView.Nodes.Add(new MDTableModel(Model, metadata, stream, mdTable).ToNode());
}
}
}
}
public void RedirectedRangeSingleItem()
{
var stream = new TablesStream();
var redirectTable = stream.GetTable <MethodPointerRow>();
redirectTable.Add(new MethodPointerRow(1));
redirectTable.Add(new MethodPointerRow(2));
redirectTable.Add(new MethodPointerRow(5));
redirectTable.Add(new MethodPointerRow(4));
redirectTable.Add(new MethodPointerRow(3));
var range = new RedirectedMetadataRange(redirectTable, TableIndex.Method, 3, 4);
Assert.Equal(1, range.Count);
Assert.Single(range);
Assert.Equal(new MetadataToken(TableIndex.Method, 5), range.First());
}
public TablesStreamVM(object owner, HexDocument doc, TablesStream tblStream)
: base(owner)
{
ulong startOffset = (ulong)tblStream.StartOffset;
this.m_ulReservedVM = new UInt32HexField(doc, Name, "m_ulReserved", startOffset + 0);
this.m_majorVM = new ByteHexField(doc, Name, "m_major", startOffset + 4, true);
this.m_minorVM = new ByteHexField(doc, Name, "m_minor", startOffset + 5, true);
this.m_heapsVM = new ByteFlagsHexField(doc, Name, "m_heaps", startOffset + 6);
this.m_heapsVM.Add(new BooleanHexBitField("BigStrings", 0));
this.m_heapsVM.Add(new BooleanHexBitField("BigGUID", 1));
this.m_heapsVM.Add(new BooleanHexBitField("BigBlob", 2));
this.m_heapsVM.Add(new BooleanHexBitField("Padding", 3));
this.m_heapsVM.Add(new BooleanHexBitField("Reserved", 4));
this.m_heapsVM.Add(new BooleanHexBitField("DeltaOnly", 5));
this.m_heapsVM.Add(new BooleanHexBitField("ExtraData", 6));
this.m_heapsVM.Add(new BooleanHexBitField("HasDelete", 7));
this.m_ridVM = new ByteHexField(doc, Name, "m_rid", startOffset + 7);
this.m_maskvalidVM = new UInt64FlagsHexField(doc, Name, "m_maskvalid", startOffset + 8);
AddTableFlags(this.m_maskvalidVM);
this.m_sortedVM = new UInt64FlagsHexField(doc, Name, "m_sorted", startOffset + 0x10);
AddTableFlags(this.m_sortedVM);
var list = new List <HexField> {
m_ulReservedVM,
m_majorVM,
m_minorVM,
m_heapsVM,
m_ridVM,
m_maskvalidVM,
m_sortedVM,
};
this.rowsVM = new UInt32HexField[64];
ulong valid = tblStream.ValidMask;
ulong offs = startOffset + 0x18;
for (int i = 0; i < this.rowsVM.Length; i++)
{
this.rowsVM[i] = new UInt32HexField(doc, Name, string.Format("rows[{0:X2}]", i), offs);
if ((valid & 1) != 0)
{
list.Add(this.rowsVM[i]);
offs += 4;
}
else
{
this.rowsVM[i].IsVisible = false;
}
valid >>= 1;
}
this.m_ulExtraVM = new UInt32HexField(doc, Name, "m_ulExtra", offs);
this.m_ulExtraVM.IsVisible = tblStream.HasExtraData;
if (tblStream.HasExtraData)
{
list.Add(this.m_ulExtraVM);
}
Debug.Assert(offs == (ulong)tblStream.MDTables[0].StartOffset);
this.hexFields = list.ToArray();
}
public MDTableHeapModel(dnModule module, TablesStream stream)
{
Module = module;
Stream = stream;
Text = "Tables";
}
public MDTablesStreamModel(dnModule module, TablesStream stream)
{
Module = module;
Stream = stream;
Text = stream.Name;
}
