public NestedClassMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
internal void AddToList(ArrayList list, MDTable tabIx) { Contract.Requires(list != null); switch (tabIx) { case (MDTable.Field): fields.AddRange(list); break; case (MDTable.Method): methods.AddRange(list); break; case (MDTable.TypeDef): nestedClasses.AddRange(list); break; default: throw new Exception("Unknown list type"); } }
internal void AddToTable(MDTable tableIx, MetaDataElement elem) { if (elem.Row > 0) { // Console.Out.WriteLine("ERROR - element already in table " + tableIx); return; } // updates Row field of the element // Console.WriteLine("Adding element to table " + (uint)tableIx); ArrayList table = GetTable(tableIx); elem.Row = (uint)table.Count + 1; table.Add(elem); }
internal uint GetTableSize(MDTable tabIx) { return (uint)tableLengths[(int)tabIx]; }
internal void AddToFeatureList(ArrayList list, MDTable tabIx) { if (tabIx == MDTable.Event) { events.AddRange(list); } else { properties.AddRange(list); } }
/*-------------------- Constructors ---------------------------------*/ internal MapElem(ClassDef classDef, uint elIx, MDTable tableIx) { theClass = classDef; elemIx = elIx; tabIx = tableIx; sortTable = tabIx == MDTable.NestedClass; }
internal static uint Size(MetaData md, MDTable tabIx) { return md.TableIndexSize(MDTable.TypeDef) + md.TableIndexSize(tabIx); }
void Add(Dictionary <uint, BlobDataInfoPosition> dict, MDTable mdTable, int column1, BlobDataKind kind1, int column2, BlobDataKind kind2) { var heapStart = Span.Span.Start; var heapEnd = Span.Span.End; var buffer = Span.Buffer; var recPos = mdTable.Span.Start; var rows = mdTable.Rows; var colInfo1 = mdTable.Columns[column1]; var colInfo2 = mdTable.Columns[column2]; Debug.Assert(colInfo1.ColumnSize == ColumnSize.Blob); Debug.Assert(colInfo2.ColumnSize == ColumnSize.Blob); uint recSize = mdTable.RowSize; bool bigBlob = colInfo1.Size == 4; uint tokenBase = new MDToken(mdTable.Table, 0).Raw; for (uint rid = 1; rid <= rows; rid++, recPos += recSize) { uint offs1 = bigBlob ? buffer.ReadUInt32(recPos + colInfo1.Offset) : buffer.ReadUInt16(recPos + colInfo1.Offset); uint offs2 = bigBlob ? buffer.ReadUInt32(recPos + colInfo2.Offset) : buffer.ReadUInt16(recPos + colInfo2.Offset); { List <uint>?tokens; if (offs1 == 0) { tokens = null; } else if (dict.TryGetValue(offs1, out var info)) { tokens = info.Tokens; } else { var pos = heapStart + offs1; if (pos < heapEnd) { dict[offs1] = info = new BlobDataInfoPosition(pos, kind1); tokens = info.Tokens; } else { tokens = null; } } tokens?.Add(tokenBase + rid); } { List <uint>?tokens; if (offs2 == 0) { tokens = null; } else if (dict.TryGetValue(offs2, out var info)) { tokens = info.Tokens; } else { var pos = heapStart + offs2; if (pos < heapEnd) { dict[offs2] = info = new BlobDataInfoPosition(pos, kind2); tokens = info.Tokens; } else { tokens = null; } } tokens?.Add(tokenBase + rid); } } }
void Initialize() { if (initialized) { return; } initialized = true; var buffer = Span.Buffer; var pos = Span.Span.Start; reserved1 = buffer.ReadUInt32(pos); majorVersion = buffer.ReadByte(pos + 4); minorVersion = buffer.ReadByte(pos + 5); flags = (MDStreamFlags)buffer.ReadByte(pos + 6); log2Rid = buffer.ReadByte(pos + 7); validMask = buffer.ReadUInt64(pos + 8); sortedMask = buffer.ReadUInt64(pos + 0x10); pos += 0x18; Debug.Assert(Span.Span.Start + MinimumSize == pos); Debug.Assert(Span.Span.Contains(pos - 1), "Creator should've verified this"); var dnTableSizes = new DotNetTableSizes(); var tableInfos = dnTableSizes.CreateTables(majorVersion, minorVersion, out int maxPresentTables); var rowsCount = new uint[tableInfos.Length]; ulong valid = validMask; var sizes = new uint[64]; int rowsFieldCount = 0; for (int i = 0; i < 64; valid >>= 1, i++) { uint rows; if ((valid & 1) == 0 || !Span.Span.Contains(pos + 3)) { rows = 0; } else { rowsFieldCount++; rows = buffer.ReadUInt32(pos); pos += 4; } if (i >= maxPresentTables) { rows = 0; } // Mono ignores the high byte rows &= 0x00FFFFFF; sizes[i] = rows; if (i < rowsCount.Length) { rowsCount[i] = rows; } } bool hasExtraData = false; if ((flags & MDStreamFlags.ExtraData) != 0 && Span.Span.Contains(pos + 3)) { hasExtraData = true; extraData = buffer.ReadUInt32(pos); pos += 4; } headerSpan = HexSpan.FromBounds(Span.Span.Start, pos); dnTableSizes.InitializeSizes((flags & MDStreamFlags.BigStrings) != 0, (flags & MDStreamFlags.BigGUID) != 0, (flags & MDStreamFlags.BigBlob) != 0, sizes); mdTables = new MDTable[tableInfos.Length]; mdTablesReadOnly = new ReadOnlyCollection <MDTable>(mdTables); tableRecordDataFactories = new TableRecordDataFactory[tableInfos.Length]; var tablesStartPos = pos; bool bad = !Span.Span.Contains(pos); for (int i = 0; i < rowsCount.Length; i++) { var rows = rowsCount[i]; var mdTable = new MDTable(pos, (Table)i, rows, tableInfos[i]); if (bad || mdTable.Span.End > Span.End.Position) { mdTable = new MDTable(pos, (Table)i, 0, tableInfos[i]); bad = true; } pos = mdTable.Span.End; mdTables[i] = mdTable; tableRecordDataFactories[i] = CreateFactory(mdTable); } tablesSpan = HexSpan.FromBounds(HexPosition.Min(Span.End.Position, tablesStartPos), HexPosition.Min(Span.End.Position, pos)); tablesHeaderData = new TablesHeaderDataImpl(new HexBufferSpan(buffer, headerSpan), hasExtraData, rowsFieldCount); }
public StateMachineMethodMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
public CustomDebugInformationMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
public ImportScopeMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
public LocalConstantMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
public GenericParamConstraintMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }
public ParamRow(MDTable parent) { table = parent; }
public TypeDefTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
/// <summary> /// Reads a column /// </summary> /// <param name="table">The table</param> /// <param name="rid">Row ID</param> /// <param name="column">Column</param> /// <param name="value">Result is put here or 0 if we return <c>false</c></param> /// <returns><c>true</c> if we could read the column, <c>false</c> otherwise</returns> public bool ReadColumn(MDTable table, uint rid, ColumnInfo column, out uint value) { if (table == null || table.IsInvalidRID(rid)) { value = 0; return false; } if (columnReader != null && columnReader.ReadColumn(table, rid, column, out value)) return true; var reader = table.ImageStream; reader.Position = (rid - 1) * table.TableInfo.RowSize + column.Offset; value = column.Read(reader); return true; }
public ConstantTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal MapElem(PEReader buff, MDTable tab) { tabIx = tab; classIx = buff.GetIndex(MDTable.TypeDef); elemIx = buff.GetIndex(tab); sortTable = tabIx == MDTable.NestedClass; }
public DeclSecurityTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal MetaDataElement GetElement(MDTable tabIx, uint ix) { if (ix == 0) return null; MetaDataElement elem = (MetaDataElement)tables[(int)tabIx][(int)ix-1]; if ((elem != null) && (elem.unresolved)) { elem.Resolve(this); elem = (MetaDataElement)tables[(int)tabIx][(int)ix-1]; } return elem; }
public PropertyTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal uint MakeCodedIndex(CIx code, MDTable tab, uint ix) { ix <<= MetaData.CIxShiftMap[(uint)code]; ix &= (uint)tab; return ix; }
public MethodSemanticsTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal void AddToTable(MDTable tableIx, MetaDataElement elem) { // Console.WriteLine("Adding element to table " + (uint)tableIx); ArrayList table = GetTable(tableIx); if (table.Contains(elem)) { Console.Out.WriteLine("ERROR - element already in table " + tableIx); return; } elem.Row = (uint)table.Count + 1; table.Add(elem); }
public ImplMapTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal MapElem(ClassDef par, uint elIx, MDTable elemTab) { parent = par; elemIx = elIx; elemTable = elemTab; }
public AssemblyRefTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal uint TableIndexSize(MDTable tabIx) { if (largeIx[(uint)tabIx]) return 4; return 2; }
public FileTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
public MethodRow(MDTable parent) { table = parent; }
public ExportedTypeTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
/// <summary> /// Reads a column /// </summary> /// <param name="table">The table</param> /// <param name="rid">Row ID</param> /// <param name="colIndex">Column index in <paramref name="table"/></param> /// <param name="value">Result is put here or 0 if we return <c>false</c></param> /// <returns><c>true</c> if we could read the column, <c>false</c> otherwise</returns> public bool ReadColumn(MDTable table, uint rid, int colIndex, out uint value) { return ReadColumn(table, rid, table.TableInfo.Columns[colIndex], out value); }
public ManifestResourceTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal void InsertInTable(MDTable tabIx, uint ix, MetaDataElement elem) { Contract.Requires(elem != null); tables[(int)tabIx][ix - 1] = elem; }
public GenericParamTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal MapElem(ClassDef classDef, ClassDef paren, MDTable tableIx) { theClass = classDef; parent = paren; tabIx = tableIx; sortTable = tabIx == MDTable.NestedClass; }
public LocalVariableTableRecordDataFactory(TablesHeap tablesHeap, MDTable mdTable) : base(tablesHeap, mdTable) { }
internal static void Read(PEReader buff, TableRow[] maps, MDTable tab) { if (tab == MDTable.NestedClass) { for (int i=0; i < maps.Length; i++) { //maps[i] = new MapElem(buff,tab); uint nestClassIx = buff.GetIndex(MDTable.TypeDef); uint enclClassIx = buff.GetIndex(MDTable.TypeDef); ClassDef parent = (ClassDef)buff.GetElement(MDTable.TypeDef,enclClassIx); ClassDef nestClass = ((ClassDef)buff.GetElement(MDTable.TypeDef,nestClassIx)).MakeNestedClass(parent); buff.InsertInTable(MDTable.TypeDef,nestClass.Row,nestClass); } } else { // event or property map MapElem prev = new MapElem(buff,tab); maps[0] = prev; for (int i=1; i < maps.Length; i++) { maps[i] = new MapElem(buff,tab); prev.endIx = ((MapElem)maps[i]).elemIx; prev = (MapElem)maps[i]; } switch (tab) { case MDTable.PropertyMap: prev.endIx = buff.GetTableSize(MDTable.Property) + 1; break; case MDTable.EventMap: prev.endIx = buff.GetTableSize(MDTable.Event) + 1; break; default: prev.endIx = buff.GetTableSize(tab)+1; break; } } }
public virtual void patchMethodTable(MDTable methodDefTable, IList <MethodInfo> methodInfos) { }
internal TableRow(PEReader buff, uint ix, MDTable tableIx) { buffer = buff; row = ix; tabIx = tableIx; }
List <CsHeaderVersion> getCsHeaderVersions(uint codeHeaderOffset, MDTable methodDefTable) { if (sigType == SigType.Old) { return new List <CsHeaderVersion> { CsHeaderVersion.V10 } } ; if (!isOldHeader(methodDefTable)) { return new List <CsHeaderVersion> { CsHeaderVersion.V52 } } ; if (csRtType.isAtLeastVersion50()) { return new List <CsHeaderVersion> { CsHeaderVersion.V50 } } ; if (isCsHeader40(codeHeaderOffset)) { return(new List <CsHeaderVersion> { CsHeaderVersion.V40, CsHeaderVersion.V30, }); } return(new List <CsHeaderVersion> { CsHeaderVersion.V45, CsHeaderVersion.V50, }); } bool isCsHeader40(uint codeHeaderOffset) { try { uint offset = codeHeaderOffset + codeHeader.totalCodeSize + 0x28; uint prevCodeOffs = 0; for (int i = 0; i < (int)codeHeader.numMethods; i++, offset += 4) { uint codeOffs = peImage.offsetReadUInt32(offset); if (prevCodeOffs != 0 && codeOffs != 0 && codeOffs < prevCodeOffs) { return(false); } if (codeOffs != 0) { prevCodeOffs = codeOffs; } } return(true); } catch (IOException) { return(false); } } bool isOldHeader(MDTable methodDefTable) { if (methodDefTable.RowSize != codeHeader.methodDefElemSize) { return(true); } if ((uint)methodDefTable.StartOffset - peImage.rvaToOffset((uint)peImage.Cor20Header.MetaData.VirtualAddress) != codeHeader.methodDefTableOffset) { return(true); } return(false); } ICsHeader createCsHeader(CsHeaderVersion version) { switch (version) { case CsHeaderVersion.V30: return(new CsHeader30(this)); case CsHeaderVersion.V40: return(new CsHeader40(this)); case CsHeaderVersion.V45: return(new CsHeader45(this)); case CsHeaderVersion.V50: return(new CsHeader5(this, 0x28)); case CsHeaderVersion.V52: return(new CsHeader5(this, 0x30)); default: throw new ApplicationException("Unknown CS header"); } }
internal uint GetIndex(MDTable tabIx) { if (md.largeIx[(int)tabIx]) return ReadUInt32(); return ReadUInt16(); }
public static MetaDataTableVM Create(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) { switch (mdTable.Table) { case Table.Module: return(new ModuleMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.TypeRef: return(new TypeRefMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.TypeDef: return(new TypeDefMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.FieldPtr: return(new FieldPtrMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Field: return(new FieldMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.MethodPtr: return(new MethodPtrMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Method: return(new MethodMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ParamPtr: return(new ParamPtrMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Param: return(new ParamMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.InterfaceImpl: return(new InterfaceImplMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.MemberRef: return(new MemberRefMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Constant: return(new ConstantMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.CustomAttribute: return(new CustomAttributeMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.FieldMarshal: return(new FieldMarshalMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.DeclSecurity: return(new DeclSecurityMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ClassLayout: return(new ClassLayoutMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.FieldLayout: return(new FieldLayoutMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.StandAloneSig: return(new StandAloneSigMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.EventMap: return(new EventMapMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.EventPtr: return(new EventPtrMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Event: return(new EventMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.PropertyMap: return(new PropertyMapMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.PropertyPtr: return(new PropertyPtrMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Property: return(new PropertyMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.MethodSemantics: return(new MethodSemanticsMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.MethodImpl: return(new MethodImplMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ModuleRef: return(new ModuleRefMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.TypeSpec: return(new TypeSpecMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ImplMap: return(new ImplMapMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.FieldRVA: return(new FieldRVAMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ENCLog: return(new ENCLogMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ENCMap: return(new ENCMapMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.Assembly: return(new AssemblyMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.AssemblyProcessor: return(new AssemblyProcessorMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.AssemblyOS: return(new AssemblyOSMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.AssemblyRef: return(new AssemblyRefMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.AssemblyRefProcessor: return(new AssemblyRefProcessorMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.AssemblyRefOS: return(new AssemblyRefOSMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.File: return(new FileMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ExportedType: return(new ExportedTypeMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.ManifestResource: return(new ManifestResourceMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.NestedClass: return(new NestedClassMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.GenericParam: return(mdTable.Columns.Count == 5 ? (MetaDataTableVM) new GenericParamMetaDataTableV11VM(owner, doc, startOffset, mdTable) : new GenericParamMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.MethodSpec: return(new MethodSpecMetaDataTableVM(owner, doc, startOffset, mdTable)); case Table.GenericParamConstraint: return(new GenericParamConstraintMetaDataTableVM(owner, doc, startOffset, mdTable)); default: throw new InvalidOperationException(); } }
internal void InsertInTable(MDTable tabIx, uint ix, MetaDataElement elem) { tables[(int)tabIx][ix-1] = elem; }
public InterfaceImplMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
internal void SetElementPosition(MDTable tabIx, uint ix) { BaseStream.Position = tableStarts[(int)tabIx] + (md.elemSize[(int)tabIx] * (ix-1)); }
public MemberRefMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
internal static string[] GetFeatureNames(PEReader buff, MDTable tabIx, MDTable mapTabIx, ClassDef theClass, uint classIx) { buff.SetElementPosition(mapTabIx,0); uint start = 0, end = 0, i = 0; for (; (i < buff.GetTableSize(tabIx)) && (start == 0); i++) { if (buff.GetIndex(MDTable.TypeDef) == classIx) { start = buff.GetIndex(tabIx); } } if (start == 0) return null; if (i < buff.GetTableSize(mapTabIx)) { uint junk = buff.GetIndex(MDTable.TypeDef); end = buff.GetIndex(tabIx); } else end = buff.GetTableSize(tabIx); if (tabIx == MDTable.Event) theClass.eventIx = start; else theClass.propIx = start; string[] names = new string[end-start]; buff.SetElementPosition(tabIx,start); for (i=start; i < end; i++) { uint junk = buff.ReadUInt16(); names[i] = buff.GetString(); if (tabIx == MDTable.Event) junk = buff.GetCodedIndex(CIx.TypeDefOrRef); else junk = buff.GetBlobIx(); } return names; }
public CustomAttributeMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
internal void AddToFeatureList(ArrayList list, MDTable tabIx) { Contract.Requires(list != null); if (tabIx == MDTable.Event) { events.AddRange(list); } else { properties.AddRange(list); } }
public FieldMarshalMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
internal void WriteIndex(MDTable tabIx,uint ix) { if (metaData.LargeIx(tabIx)) Write(ix); else Write((ushort)ix); }
public DeclSecurityMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
private ArrayList GetTable(MDTable tableIx) { int tabIx = (int)tableIx; if (metaDataTables[tabIx] == null) { metaDataTables[tabIx] = new ArrayList(); valid |= ((ulong)0x1 << tabIx); // Console.WriteLine("after creating table " + tableIx + "(" + tabIx + ") valid = " + valid); numTables++; } return metaDataTables[tabIx]; }
public ClassLayoutMetaDataTableVM(object owner, HexDocument doc, ulong startOffset, MDTable mdTable) : base(owner, doc, startOffset, mdTable) { }
internal uint TableIndex(MDTable tableIx) { if (metaDataTables[(int)tableIx] == null) return 1; return (uint)metaDataTables[(int)tableIx].Count+1; }
public FieldRow(MDTable parent) { table = parent; }
internal bool LargeIx(MDTable tabIx) { return largeIx[(uint)tabIx]; }
public ManifestResourceMetaDataTableVM(HexBuffer buffer, TablesStreamVM tablesStream, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) : base(buffer, tablesStream, mdTable, stringsHeapSpan, guidHeapSpan) { }