protected override HexField CreateField(ColumnInfo colInfo) {
if (colInfo.Index == 0)
return CreateTypeAttributesField(colInfo, mdVM.Buffer, Name, Span.Start);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("NoMangle", 0));
field.Add(new IntegerHexBitField("CharSet", 1, 2, CharSetInfos));
field.Add(new IntegerHexBitField("BestFit", 4, 2, BestFitInfos));
field.Add(new BooleanHexBitField("SupportsLastError", 6));
field.Add(new IntegerHexBitField("CallConv", 8, 3, CallConvInfos));
field.Add(new IntegerHexBitField("ThrowOnUnmappableChar", 12, 2, ThrowOnUnmappableCharInfos));
return field;
}
return base.CreateField(colInfo);
}
internal static UInt32FlagsHexField CreateAssemblyAttributesField(ColumnInfo colInfo, HexDocument doc, string name, ulong startOffset)
{
var field = new UInt32FlagsHexField(doc, name, colInfo.Name, startOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("PublicKey", 0));
field.Add(new IntegerHexBitField("Processor Arch", 4, 3, PAInfos));
field.Add(new BooleanHexBitField("Processor Arch Specified", 7));
field.Add(new BooleanHexBitField("Retargetable", 8));
field.Add(new IntegerHexBitField("ContentType", 9, 3, ContentTypeInfos));
field.Add(new BooleanHexBitField("DisableJITcompileOptimizer", 14));
field.Add(new BooleanHexBitField("EnableJITcompileTracking", 15));
return field;
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Access", 0, 3, AccessInfos));
field.Add(new BooleanHexBitField("Static", 4));
field.Add(new BooleanHexBitField("InitOnly", 5));
field.Add(new BooleanHexBitField("Literal", 6));
field.Add(new BooleanHexBitField("NotSerialized", 7));
field.Add(new BooleanHexBitField("HasFieldRVA", 8));
field.Add(new BooleanHexBitField("SpecialName", 9));
field.Add(new BooleanHexBitField("RTSpecialName", 10));
field.Add(new BooleanHexBitField("HasFieldMarshal", 12));
field.Add(new BooleanHexBitField("PinvokeImpl", 13));
field.Add(new BooleanHexBitField("HasDefault", 15));
return field;
}
return base.CreateField(colInfo);
}
internal static UInt16FlagsHexField CreateGenericParamAttributesField(ColumnInfo colInfo, HexDocument doc, string name, ulong startOffset)
{
var field = new UInt16FlagsHexField(doc, name, colInfo.Name, startOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Variance", 0, 2, VarianceInfos));
field.Add(new BooleanHexBitField("Reference", 2));
field.Add(new BooleanHexBitField("Struct", 3));
field.Add(new BooleanHexBitField("Default ctor", 4));
return field;
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (1 <= colInfo.Index && colInfo.Index <= 2)
return new UInt32HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset, true);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("SpecialName", 9));
field.Add(new BooleanHexBitField("RTSpecialName", 10));
return field;
}
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0)
return CreateTypeAttributesField(colInfo, doc, Name, startOffset);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 1)
return GenericParamMetaDataTableRecordVM.CreateGenericParamAttributesField(colInfo, doc, Name, startOffset);
return base.CreateField(colInfo);
}
/// <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>
internal bool ReadColumn_NoLock(MDTable table, uint rid, ColumnInfo column, out uint value) {
if (table.IsInvalidRID(rid)) {
value = 0;
return false;
}
var cr = columnReader;
if (cr != null && cr.ReadColumn(table, rid, column, out value))
return true;
var reader = GetReader_NoLock(table, rid);
reader.Position += column.Offset;
value = column.Read(reader);
return true;
}
string GetCodedTokenDescription(CodedToken codedToken, string codedTokenName, ColumnInfo col, HexField field)
{
MDToken token;
if (!codedToken.Decode(ReadFieldValue(field), out token))
return string.Empty;
return string.Format("{0} Coded Token: {1}[{2}] (0x{3:X8})", codedTokenName, token.Table, token.Rid, token.Raw);
}
/// <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.IsInvalidRID(rid)) {
value = 0;
return false;
}
var cr = columnReader;
if (cr != null && cr.ReadColumn(table, rid, column, out value))
return true;
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
var reader = GetReader_NoLock(table, rid);
reader.Position += column.Offset;
value = column.Read(reader);
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
return true;
}
static object GetDescription(IMetaData metadata, MDTable table, ColumnInfo column, uint rowValue) {
if (ColumnSize.Module <= column.ColumnSize && column.ColumnSize <= ColumnSize.GenericParamConstraint) {
Table targetTable = (Table)(column.ColumnSize - ColumnSize.Module);
if (rowValue == 0)
return "";
return new MDToken(targetTable, rowValue).ToDescription();
}
if (ColumnSize.TypeDefOrRef <= column.ColumnSize && column.ColumnSize <= ColumnSize.TypeOrMethodDef) {
CodedToken info;
switch (column.ColumnSize) {
case ColumnSize.TypeDefOrRef:
info = CodedToken.TypeDefOrRef;
break;
case ColumnSize.HasConstant:
info = CodedToken.HasConstant;
break;
case ColumnSize.HasCustomAttribute:
info = CodedToken.HasCustomAttribute;
break;
case ColumnSize.HasFieldMarshal:
info = CodedToken.HasFieldMarshal;
break;
case ColumnSize.HasDeclSecurity:
info = CodedToken.HasDeclSecurity;
break;
case ColumnSize.MemberRefParent:
info = CodedToken.MemberRefParent;
break;
case ColumnSize.HasSemantic:
info = CodedToken.HasSemantic;
break;
case ColumnSize.MethodDefOrRef:
info = CodedToken.MethodDefOrRef;
break;
case ColumnSize.MemberForwarded:
info = CodedToken.MemberForwarded;
break;
case ColumnSize.Implementation:
info = CodedToken.Implementation;
break;
case ColumnSize.CustomAttributeType:
info = CodedToken.CustomAttributeType;
break;
case ColumnSize.ResolutionScope:
info = CodedToken.ResolutionScope;
break;
case ColumnSize.TypeOrMethodDef:
info = CodedToken.TypeOrMethodDef;
break;
default:
throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", column.ColumnSize));
}
MDToken decodedToken;
if (!info.Decode(rowValue, out decodedToken))
return InvalidValue;
if (decodedToken.Rid == 0)
return "";
return decodedToken.ToDescription();
}
if (column.ColumnSize == ColumnSize.Strings) {
if (rowValue == 0)
return "";
var value = metadata.StringsStream.Read(rowValue);
if (value == (UTF8String)null)
return InvalidValue;
return value;
}
if (column.ColumnSize == ColumnSize.Blob) {
if (rowValue == 0)
return "";
if (!metadata.BlobStream.IsValidOffset(rowValue))
return InvalidValue;
var reader = metadata.BlobStream.GetClonedImageStream();
reader.Position = rowValue;
return reader.ReadCompressedUInt32();
}
if (column.ColumnSize == ColumnSize.GUID) {
if (rowValue == 0)
return "";
var value = metadata.GuidStream.Read(rowValue);
if (value == null)
return InvalidValue;
return value.Value.ToString("D");
}
return GetLiteralDescription(table.Table, column, rowValue);
}
static string GetLiteralDescription(Table table, ColumnInfo column, uint rowValue) {
object enumValue = null;
switch (table) {
case Table.TypeDef:
if (column.Name == "Flags")
enumValue = (TypeAttributes)rowValue;
break;
case Table.Field:
if (column.Name == "Flags")
enumValue = (FieldAttributes)rowValue;
break;
case Table.Method:
if (column.Name == "ImplFlags")
enumValue = (MethodImplAttributes)rowValue;
else if (column.Name == "Flags")
enumValue = (MethodAttributes)rowValue;
break;
case Table.Param:
if (column.Name == "Flags")
enumValue = (ParamAttributes)rowValue;
break;
case Table.Constant:
if (column.Name == "Type")
enumValue = (ElementType)rowValue;
break;
case Table.DeclSecurity:
if (column.Name == "Action")
enumValue = (SecurityAction)rowValue;
break;
case Table.Event:
if (column.Name == "EventFlags")
enumValue = (EventAttributes)rowValue;
break;
case Table.Property:
if (column.Name == "Flags")
enumValue = (PropertyAttributes)rowValue;
break;
case Table.MethodSemantics:
if (column.Name == "Semantic")
enumValue = (MethodSemanticsAttributes)rowValue;
break;
case Table.ImplMap:
if (column.Name == "MappingFlags")
enumValue = (PInvokeAttributes)rowValue;
break;
case Table.Assembly:
if (column.Name == "HashAlgId")
enumValue = (AssemblyHashAlgorithm)rowValue;
else if (column.Name == "Flags")
enumValue = (AssemblyAttributes)rowValue;
break;
case Table.AssemblyRef:
if (column.Name == "Flags")
enumValue = (AssemblyAttributes)rowValue;
break;
case Table.File:
if (column.Name == "Flags")
enumValue = (FileAttributes)rowValue;
break;
case Table.ExportedType:
if (column.Name == "Flags")
enumValue = (TypeAttributes)rowValue;
break;
case Table.ManifestResource:
if (column.Name == "Flags")
enumValue = (ManifestResourceAttributes)rowValue;
break;
case Table.GenericParam:
if (column.Name == "Flags")
enumValue = (GenericParamAttributes)rowValue;
break;
}
if (enumValue == null)
return "";
return enumValue.ToString();
}
internal static UInt32FlagsHexField CreateTypeAttributesField(ColumnInfo colInfo, HexDocument doc, string name, ulong startOffset)
{
var field = new UInt32FlagsHexField(doc, name, colInfo.Name, startOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Visibility", 0, 3, VisibilityInfos));
field.Add(new IntegerHexBitField("Layout", 3, 2, LayoutInfos));
field.Add(new IntegerHexBitField("Semantics", 5, 1, SemanticsInfos));
field.Add(new BooleanHexBitField("Abstract", 7));
field.Add(new BooleanHexBitField("Sealed", 8));
field.Add(new BooleanHexBitField("SpecialName", 10));
field.Add(new BooleanHexBitField("RTSpecialName", 11));
field.Add(new BooleanHexBitField("Import", 12));
field.Add(new BooleanHexBitField("Serializable", 13));
field.Add(new BooleanHexBitField("WindowsRuntime", 14));
field.Add(new IntegerHexBitField("String", 16, 2, StringFormatInfos));
field.Add(new BooleanHexBitField("HasSecurity", 18));
field.Add(new BooleanHexBitField("BeforeFieldInit", 20));
field.Add(new BooleanHexBitField("Forwarder", 21));
field.Add(new IntegerHexBitField("Custom", 22, 2, CustomFormatInfos));
return field;
}
uint ReadFieldValue(HexDocument doc, ColumnInfo col) {
ulong start = StartOffset + (ulong)col.Offset;
if (col.Size == 2)
return doc.ReadUInt16(start);
else if (col.Size == 4)
return doc.ReadUInt32(start);
throw new InvalidOperationException();
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (0 <= colInfo.Index && colInfo.Index <= 3)
return new UInt16HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset, true);
else if (colInfo.Index == 4)
return AssemblyMetaDataTableRecordVM.CreateAssemblyAttributesField(colInfo, mdVM.Document, Name, StartOffset);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt32FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Hash Algorithm", 0, 32, HashAlgoInfos));
return field;
}
else if (1 <= colInfo.Index && colInfo.Index <= 4)
return new UInt16HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset, true);
else if (colInfo.Index == 5)
return CreateAssemblyAttributesField(colInfo, mdVM.Document, Name, StartOffset);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new Int16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Action", 0, 16, SecurityActionInfos));
return field;
}
return base.CreateField(colInfo);
}
protected virtual HexField CreateField(ColumnInfo colInfo)
{
switch (colInfo.ColumnSize) {
case ColumnSize.Int16: return new Int16HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
case ColumnSize.Int32: return new Int32HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
}
switch (colInfo.Size) {
case 1: return new ByteHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
case 2: return new UInt16HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
case 4: return new UInt32HexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
default: throw new InvalidOperationException();
}
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0)
return TypeDefMetaDataTableRecordVM.CreateTypeAttributesField(colInfo, mdVM.Document, Name, StartOffset);
return base.CreateField(colInfo);
}
string GetCodedTokenDescription(CodedToken codedToken, string codedTokenName, ColumnInfo col, HexField field)
{
MDToken token;
if (!codedToken.Decode(ReadFieldValue(field), out token))
return string.Format("Invalid {0} Coded Token", codedTokenName);
var info = GetInfo(token.Table, token.Rid);
if (string.IsNullOrEmpty(info))
return string.Format("{0}: {1}[{2}], 0x{3:X8})", codedTokenName, token.Table, token.Rid, token.Raw);
return string.Format("{0} ({1}: {2}[{3}], 0x{4:X8})", info, codedTokenName, token.Table, token.Rid, token.Raw);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt32FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("ContainsNoMetaData", 0));
return field;
}
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 1) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("CodeType", 0, 2, CodeTypeInfos));
field.Add(new IntegerHexBitField("ManagedType", 2, 1, ManagedInfos));
field.Add(new BooleanHexBitField("NoInlining", 3));
field.Add(new BooleanHexBitField("ForwardRef", 4));
field.Add(new BooleanHexBitField("Synchronized", 5));
field.Add(new BooleanHexBitField("NoOptimization", 6));
field.Add(new BooleanHexBitField("PreserveSig", 7));
field.Add(new BooleanHexBitField("AggressiveInlining", 8));
field.Add(new BooleanHexBitField("InternalCall", 12));
return field;
}
else if (colInfo.Index == 2) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Access", 0, 3, AccessInfos));
field.Add(new BooleanHexBitField("UnmanagedExport", 3));
field.Add(new BooleanHexBitField("Static", 4));
field.Add(new BooleanHexBitField("Final", 5));
field.Add(new BooleanHexBitField("Virtual", 6));
field.Add(new BooleanHexBitField("HideBySig", 7));
field.Add(new IntegerHexBitField("VtableLayout", 8, 1, VtableLayoutInfos));
field.Add(new BooleanHexBitField("CheckAccessOnOverride", 9));
field.Add(new BooleanHexBitField("Abstract", 10));
field.Add(new BooleanHexBitField("SpecialName", 11));
field.Add(new BooleanHexBitField("RTSpecialName", 12));
field.Add(new BooleanHexBitField("PinvokeImpl", 13));
field.Add(new BooleanHexBitField("HasSecurity", 14));
field.Add(new BooleanHexBitField("RequireSecObject", 15));
return field;
}
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 1)
return CreateGenericParamAttributesField(colInfo, mdVM.Document, Name, StartOffset);
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("Setter", 0));
field.Add(new BooleanHexBitField("Getter", 1));
field.Add(new BooleanHexBitField("Other", 2));
field.Add(new BooleanHexBitField("AddOn", 3));
field.Add(new BooleanHexBitField("RemoveOn", 4));
field.Add(new BooleanHexBitField("Fire", 5));
return field;
}
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 1) {
var field = new UInt32FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new IntegerHexBitField("Visibility", 0, 3, VisibilityInfos));
return field;
}
return base.CreateField(colInfo);
}
protected override HexField CreateField(ColumnInfo colInfo)
{
if (colInfo.Index == 0) {
var field = new UInt16FlagsHexField(mdVM.Document, Name, colInfo.Name, StartOffset + (uint)colInfo.Offset);
field.Add(new BooleanHexBitField("In", 0));
field.Add(new BooleanHexBitField("Out", 1));
field.Add(new BooleanHexBitField("Optional", 4));
field.Add(new BooleanHexBitField("HasDefault", 12));
field.Add(new BooleanHexBitField("HasFieldMarshal", 13));
return field;
}
return base.CreateField(colInfo);
}
uint ReadFieldValue(HexBuffer buffer, ColumnInfo col) {
var start = Span.Start + (ulong)col.Offset;
if (col.Size == 2)
return buffer.ReadUInt16(start);
else if (col.Size == 4)
return buffer.ReadUInt32(start);
throw new InvalidOperationException();
}
protected override HexField CreateField(ColumnInfo colInfo) {
if (colInfo.Index == 1)
return GenericParamMetaDataTableRecordVM.CreateGenericParamAttributesField(colInfo, mdVM.Buffer, Name, Span.Start);
return base.CreateField(colInfo);
}
