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)
{
}
