private int GetMethodsCount(uint typeRid, TypeDefRow typeRow)
{
var types = _reader.TypeDefTable;
var methods = _reader.MethodTable;
return((typeRid == types.Length)
? methods.Length - typeRow.MethodList
: types[typeRid + 1].MethodList - typeRow.MethodList);
}
private int GetFieldsCount(uint typeRid, TypeDefRow typeRow)
{
var types = _reader.TypeDefTable;
var fields = _reader.FieldTable;
return((typeRid == types.Length)
? fields.Length - typeRow.FieldList
: types[typeRid + 1].FieldList - typeRow.FieldList);
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new TypeDefRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += TypeDefRow.LogicalSize;
}
}
void DumpTypeDef(TypeDefRow row, int index)
{
Console.WriteLine("TypeDefRow#{0} {1} {2} {3} {4} {5} {6}",
index,
(uint)row.Flags,
row.Name,
row.Namespace,
row.Extends.ToUInt(),
row.FieldList,
row.MethodList);
}
/// <summary>
/// Reads the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="result">The result.</param>
public void Read(TokenTypes token, out TypeDefRow result)
{
if ((token & TokenTypes.TableMask) != TokenTypes.TypeDef)
{
throw new ArgumentException("Invalid token type for TypeDefRow.", "token");
}
using (BinaryReader reader = CreateReaderForToken(token))
{
result = new TypeDefRow((TypeAttributes)reader.ReadUInt32(), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.TypeDefOrRef), ReadIndexValue(reader, TokenTypes.Field), ReadIndexValue(reader, TokenTypes.MethodDef));
}
}
public Collection <FieldDefinition> GetFields(uint typeRid, TypeDefRow typeRow, TypeDefinition typeDef)
{
var start = typeRow.FieldList;
var count = GetFieldsCount(typeRid, typeRow);
var fields = new FieldDefinition[count];
for (uint offset = 0; offset < count; offset++)
{
var fieldRid = start + offset;
var fieldRow = _reader.FieldTable[fieldRid];
fields[offset] = FieldDefinitionResolver.Resolve(fieldRid, fieldRow, this, typeDef);
}
return(new Collection <FieldDefinition>(fields));
}
public Collection <MethodDefinition> GetMethods(uint typeRid, TypeDefRow typeRow, TypeDefinition typeDef)
{
var start = typeRow.MethodList;
var count = GetMethodsCount(typeRid, typeRow);
var methods = new MethodDefinition[count];
for (uint offset = 0; offset < count; offset++)
{
var methodRid = start + offset;
var methodRow = _reader.MethodTable[methodRid];
methods[offset] = MethodDefinitionResolver.Resolve(methodRid, methodRow, this, typeDef);
}
return(new Collection <MethodDefinition>(methods));
}
private TypeDefRow CreateTypeDefRow(TypeDefinition entity, MetadataBuilder metadata)
{
var row = new TypeDefRow(
entity.Attributes,
metadata.WriteString(entity.Name),
metadata.WriteString(entity.Namespace),
metadata.ResolveToken(entity.BaseType),
(ushort)(metadata.FieldTable.Length + 1),
(ushort)(metadata.MethodTable.Length + 1)
);
foreach (var field in entity.Fields)
{
metadata.ResolveToken(field);
}
foreach (var method in entity.Methods)
{
metadata.ResolveToken(method);
}
return(row);
}
/// <summary>
/// Initializes a new instance of the <see cref="CilRuntimeType"/> class.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="module">The module.</param>
/// <param name="typeDefRow">The type def row.</param>
/// <param name="maxField">The max field.</param>
/// <param name="maxMethod">The max method.</param>
/// <param name="packing">The packing.</param>
/// <param name="size">The size.</param>
public CilRuntimeType(TokenTypes token, IMetadataModule module, ref TypeDefRow typeDefRow, TokenTypes maxField, TokenTypes maxMethod, int packing, int size) : base((int)token, module)
{
this.baseTypeToken = typeDefRow.Extends;
this.module = module;
this.nameIdx = typeDefRow.TypeNameIdx;
this.namespaceIdx = typeDefRow.TypeNamespaceIdx;
base.Attributes = typeDefRow.Flags;
base.Pack = packing;
base.Size = size;
// Load all fields of the type
int members = maxField - typeDefRow.FieldList;
if (0 < members)
{
int i = (int)(typeDefRow.FieldList & TokenTypes.RowIndexMask) - 1 + RuntimeBase.Instance.TypeLoader.GetModuleOffset(module).FieldOffset;
base.Fields = new ReadOnlyRuntimeFieldListView(i, members);
}
else
{
base.Fields = ReadOnlyRuntimeFieldListView.Empty;
}
// Load all methods of the type
members = maxMethod - typeDefRow.MethodList;
if (0 < members)
{
int i = (int)(typeDefRow.MethodList & TokenTypes.RowIndexMask) - 1 + RuntimeBase.Instance.TypeLoader.GetModuleOffset(module).MethodOffset;
base.Methods = new ReadOnlyRuntimeMethodListView(i, members);
}
else
{
base.Methods = ReadOnlyRuntimeMethodListView.Empty;
}
}
public virtual void VisitTypeDefRow(TypeDefRow row)
{
}
// Caller should lock peFileToObjectModel
internal CoreTypes(PEFileToObjectModel peFileToObjectModel)
{
INameTable nameTable = peFileToObjectModel.NameTable;
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
PeReader peReader = peFileToObjectModel.ModuleReader;
Module module = peFileToObjectModel.Module;
AssemblyIdentity /*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity;
int systemName = nameTable.System.UniqueKey;
int voidName = nameTable.Void.UniqueKey;
int booleanName = nameTable.Boolean.UniqueKey;
int charName = nameTable.Char.UniqueKey;
int byteName = nameTable.Byte.UniqueKey;
int sByteName = nameTable.SByte.UniqueKey;
int int16Name = nameTable.Int16.UniqueKey;
int uint16Name = nameTable.UInt16.UniqueKey;
int int32Name = nameTable.Int32.UniqueKey;
int uint32Name = nameTable.UInt32.UniqueKey;
int int64Name = nameTable.Int64.UniqueKey;
int uint64Name = nameTable.UInt64.UniqueKey;
int stringName = nameTable.String.UniqueKey;
int intPtrName = nameTable.IntPtr.UniqueKey;
int uintPtrName = nameTable.UIntPtr.UniqueKey;
int objectName = nameTable.Object.UniqueKey;
int singleName = nameTable.Single.UniqueKey;
int doubleName = nameTable.Double.UniqueKey;
int decimalName = nameTable.Decimal.UniqueKey;
int typedReference = nameTable.TypedReference.UniqueKey;
int enumName = nameTable.Enum.UniqueKey;
int valueTypeName = nameTable.ValueType.UniqueKey;
int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey;
int typeName = nameTable.Type.UniqueKey;
int arrayName = nameTable.Array.UniqueKey;
int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey;
if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity))
{
peReader.RegisterCoreAssembly(module as Assembly);
uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows;
for (uint i = 1; i <= numberOfTypeDefs; ++i)
{
TypeDefRow typeDefRow = peFileReader.TypeDefTable[i];
if (!typeDefRow.IsNested)
{
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
this.SystemVoid = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
this.SystemChar = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
this.SystemByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
this.SystemString = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
this.SystemObject = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Double);
}
else if (typeDefName == decimalName)
{
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typedReference)
{
this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == arrayName)
{
this.SystemArray = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
}
}
else
{
uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows;
AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity);
if (coreAssemblyRef == null)
{
// Error...
coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 0, peReader.metadataReaderHost.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable);
}
uint coreAssemblyRefToken = coreAssemblyRef.TokenValue;
for (uint i = 1; i <= numberOfTypeRefs; ++i)
{
TypeRefRow typeRefRow = peFileReader.TypeRefTable[i];
if (typeRefRow.ResolutionScope != coreAssemblyRefToken)
{
continue;
}
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
this.SystemVoid = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
this.SystemChar = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
this.SystemByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
this.SystemString = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
this.SystemObject = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Double);
}
else if (typeDefName == decimalName)
{
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typedReference)
{
this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == arrayName)
{
this.SystemArray = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System);
if (this.SystemVoid == null)
{
this.SystemVoid = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Void, ModuleSignatureTypeCode.Void);
}
if (this.SystemBoolean == null)
{
this.SystemBoolean = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Boolean, ModuleSignatureTypeCode.Boolean);
}
if (this.SystemChar == null)
{
this.SystemChar = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Char, ModuleSignatureTypeCode.Char);
}
if (this.SystemByte == null)
{
this.SystemByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Byte, ModuleSignatureTypeCode.Byte);
}
if (this.SystemSByte == null)
{
this.SystemSByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.SByte, ModuleSignatureTypeCode.SByte);
}
if (this.SystemInt16 == null)
{
this.SystemInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int16, ModuleSignatureTypeCode.Int16);
}
if (this.SystemUInt16 == null)
{
this.SystemUInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt16, ModuleSignatureTypeCode.UInt16);
}
if (this.SystemInt32 == null)
{
this.SystemInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int32, ModuleSignatureTypeCode.Int32);
}
if (this.SystemUInt32 == null)
{
this.SystemUInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt32, ModuleSignatureTypeCode.UInt32);
}
if (this.SystemInt64 == null)
{
this.SystemInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int64, ModuleSignatureTypeCode.Int64);
}
if (this.SystemUInt64 == null)
{
this.SystemUInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt64, ModuleSignatureTypeCode.UInt64);
}
if (this.SystemString == null)
{
this.SystemString = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.String, ModuleSignatureTypeCode.String);
}
if (this.SystemIntPtr == null)
{
this.SystemIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.IntPtr, ModuleSignatureTypeCode.IntPtr);
}
if (this.SystemUIntPtr == null)
{
this.SystemUIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UIntPtr, ModuleSignatureTypeCode.UIntPtr);
}
if (this.SystemObject == null)
{
this.SystemObject = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Object, ModuleSignatureTypeCode.Object);
}
if (this.SystemSingle == null)
{
this.SystemSingle = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Single, ModuleSignatureTypeCode.Single);
}
if (this.SystemDouble == null)
{
this.SystemDouble = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Double, ModuleSignatureTypeCode.Double);
}
if (this.SystemDecimal == null)
{
this.SystemDecimal = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Decimal, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemTypedReference == null)
{
this.SystemTypedReference = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.TypedReference, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemEnum == null)
{
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Enum, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemValueType == null)
{
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.ValueType, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemMulticastDelegate == null)
{
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemType == null)
{
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Type, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemArray == null)
{
this.SystemArray = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Array, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemParamArrayAttribute == null)
{
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
// Caller should lock peFileToObjectModel
internal CoreTypes(PEFileToObjectModel peFileToObjectModel)
{
INameTable nameTable = peFileToObjectModel.NameTable;
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
PeReader peReader = peFileToObjectModel.ModuleReader;
Module module = peFileToObjectModel.Module;
AssemblyIdentity /*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity;
//This does more than just initialize the five types exposed above, since it is also
//necessary to initialize any typedefs and typerefs to types with short forms
//in such a way that they have the correct type codes.
int systemName = nameTable.System.UniqueKey;
int voidName = nameTable.Void.UniqueKey;
int booleanName = nameTable.Boolean.UniqueKey;
int charName = nameTable.Char.UniqueKey;
int byteName = nameTable.Byte.UniqueKey;
int sByteName = nameTable.SByte.UniqueKey;
int int16Name = nameTable.Int16.UniqueKey;
int uint16Name = nameTable.UInt16.UniqueKey;
int int32Name = nameTable.Int32.UniqueKey;
int uint32Name = nameTable.UInt32.UniqueKey;
int int64Name = nameTable.Int64.UniqueKey;
int uint64Name = nameTable.UInt64.UniqueKey;
int stringName = nameTable.String.UniqueKey;
int intPtrName = nameTable.IntPtr.UniqueKey;
int uintPtrName = nameTable.UIntPtr.UniqueKey;
int objectName = nameTable.Object.UniqueKey;
int singleName = nameTable.Single.UniqueKey;
int doubleName = nameTable.Double.UniqueKey;
int decimalName = nameTable.Decimal.UniqueKey;
int typedReference = nameTable.TypedReference.UniqueKey;
int enumName = nameTable.Enum.UniqueKey;
int valueTypeName = nameTable.ValueType.UniqueKey;
int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey;
int typeName = nameTable.Type.UniqueKey;
int arrayName = nameTable.Array.UniqueKey;
int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey;
if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity))
{
peReader.RegisterCoreAssembly(module as Assembly);
uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows;
for (uint i = 1; i <= numberOfTypeDefs; ++i)
{
TypeDefRow typeDefRow = peFileReader.TypeDefTable[i];
if (!typeDefRow.IsNested)
{
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
}
else if (typeDefName == typedReference)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
}
}
else
{
uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows;
AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peFileToObjectModel.CoreAssemblySymbolicIdentity);
if (coreAssemblyRef == null)
{
// Error...
coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 1, peFileToObjectModel.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable);
}
uint coreAssemblyRefToken = coreAssemblyRef.TokenValue;
for (uint i = 1; i <= numberOfTypeRefs; ++i)
{
TypeRefRow typeRefRow = peFileReader.TypeRefTable[i];
if (typeRefRow.ResolutionScope != coreAssemblyRefToken)
{
continue;
}
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
}
else if (typeDefName == typedReference)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System);
if (this.SystemEnum == null || (peFileToObjectModel.SystemEnumAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemEnumAssembly))
{
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemEnumAssembly ?? coreAssemblyRef, systemNSR, nameTable.Enum, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemValueType == null || (peFileToObjectModel.SystemValueTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemValueTypeAssembly))
{
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemValueTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.ValueType, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemMulticastDelegate == null || (peFileToObjectModel.SystemMulticastDelegateAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemMulticastDelegateAssembly))
{
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemMulticastDelegateAssembly ?? coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemType == null || (peFileToObjectModel.SystemTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemTypeAssembly))
{
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.Type, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemParamArrayAttribute == null || (peFileToObjectModel.SystemParamArrayAttributeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemParamArrayAttributeAssembly))
{
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemParamArrayAttributeAssembly ?? coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
public override void VisitTypeDefinitionCollection(TypeDefinitionCollection types)
{
// type def reading
TypeDefTable typesTable = m_tableReader.GetTypeDefTable();
m_typeDefs = new TypeDefinition [typesTable.Rows.Count];
for (int i = 0; i < typesTable.Rows.Count; i++)
{
TypeDefRow type = typesTable [i];
TypeDefinition t = new TypeDefinition(
m_root.Streams.StringsHeap [type.Name],
m_root.Streams.StringsHeap [type.Namespace],
type.Flags);
t.MetadataToken = MetadataToken.FromMetadataRow(TokenType.TypeDef, i);
m_typeDefs [i] = t;
}
// nested types
if (m_tHeap.HasTable(NestedClassTable.RId))
{
NestedClassTable nested = m_tableReader.GetNestedClassTable();
for (int i = 0; i < nested.Rows.Count; i++)
{
NestedClassRow row = nested [i];
TypeDefinition parent = GetTypeDefAt(row.EnclosingClass);
TypeDefinition child = GetTypeDefAt(row.NestedClass);
parent.NestedTypes.Add(child);
}
}
foreach (TypeDefinition type in m_typeDefs)
{
types.Add(type);
}
// type ref reading
if (m_tHeap.HasTable(TypeRefTable.RId))
{
TypeRefTable typesRef = m_tableReader.GetTypeRefTable();
m_typeRefs = new TypeReference [typesRef.Rows.Count];
for (int i = 0; i < typesRef.Rows.Count; i++)
{
AddTypeRef(typesRef, i);
}
}
else
{
m_typeRefs = new TypeReference [0];
}
ReadTypeSpecs();
ReadMethodSpecs();
ReadMethods();
ReadGenericParameters();
// set base types
for (int i = 0; i < typesTable.Rows.Count; i++)
{
TypeDefRow type = typesTable [i];
TypeDefinition child = m_typeDefs [i];
child.BaseType = GetTypeDefOrRef(type.Extends, new GenericContext(child));
}
CompleteMethods();
ReadAllFields();
ReadMemberReferences();
}
void IMetadataProvider.Read(TokenTypes token, out TypeDefRow result)
{
TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables];
theap.Read(token, out result);
}
/// <summary>
/// Loads all types from the given metadata module.
/// </summary>
private void LoadTypes()
{
List <TypeInfo> typeInfos = new List <TypeInfo>(GetTableRows(TableType.TypeDef));
Token maxTypeDef = GetMaxTokenValue(TableType.TypeDef);
Token maxMethod = GetMaxTokenValue(TableType.MethodDef);
Token maxField = GetMaxTokenValue(TableType.Field);
Token maxLayout = GetMaxTokenValue(TableType.ClassLayout);
Token maxNestedClass = GetMaxTokenValue(TableType.NestedClass);
Token tokenLayout = new Token(TableType.ClassLayout, 1);
ClassLayoutRow layoutRow = (maxLayout.RID != 0) ? metadataProvider.ReadClassLayoutRow(tokenLayout) : new ClassLayoutRow();
Token tokenNested = new Token(TableType.NestedClass, 1);
NestedClassRow nestedRow = (maxNestedClass.RID != 0) ? metadataProvider.ReadNestedClassRow(tokenNested) : new NestedClassRow();
TypeDefRow nextTypeDefRow = new TypeDefRow();
TypeDefRow typeDefRow = metadataProvider.ReadTypeDefRow(new Token(TableType.TypeDef, 1));
foreach (Token token in new Token(TableType.TypeDef, 1).Upto(maxTypeDef))
{
TypeInfo info = new TypeInfo();
info.TypeDefRow = typeDefRow;
info.NestedClass = (nestedRow.NestedClass == token) ? nestedRow.NestedClass : Token.Zero;
info.EnclosingClass = (nestedRow.NestedClass == token) ? nestedRow.EnclosingClass : Token.Zero;
info.Size = (layoutRow.Parent == token) ? layoutRow.ClassSize : 0;
info.PackingSize = (layoutRow.Parent == token) ? layoutRow.PackingSize : (short)0;
if (token.RID < maxTypeDef.RID)
{
nextTypeDefRow = metadataProvider.ReadTypeDefRow(token.NextRow);
info.MaxField = nextTypeDefRow.FieldList;
info.MaxMethod = nextTypeDefRow.MethodList;
if (info.MaxMethod.RID > maxMethod.RID)
{
info.MaxMethod = maxMethod.NextRow;
}
if (info.MaxField.RID > maxField.RID)
{
info.MaxField = maxField.NextRow;
}
}
else
{
info.MaxMethod = maxMethod.NextRow;
info.MaxField = maxField.NextRow;
}
typeInfos.Add(info);
if (layoutRow.Parent == token)
{
tokenLayout = tokenLayout.NextRow;
if (tokenLayout.RID <= maxLayout.RID)
{
layoutRow = metadataProvider.ReadClassLayoutRow(tokenLayout);
}
}
if (nestedRow.NestedClass == token)
{
tokenNested = tokenNested.NextRow;
if (tokenNested.RID <= maxNestedClass.RID)
{
nestedRow = metadataProvider.ReadNestedClassRow(tokenNested);
}
}
typeDefRow = nextTypeDefRow;
}
foreach (Token token in new Token(TableType.TypeDef, 1).Upto(maxTypeDef))
{
LoadType(token, typeInfos);
}
}
static void ReadPeInfo2(String dll, Boolean showDllName, Boolean pauseOnDir)
{
if (showDllName)
{
Console.WriteLine("Reading file: {0}", dll);
}
using (PEFile info = new PEFile(StreamLoader.FromFile(dll)))
{
if (info.Header.IsValid) //Проверка на валидность загруженного файла
{
foreach (var section in info.Sections)
{
Utils.ConsoleWriteMembers(section);
}
if (info.Header.SymbolTable != null)
{
Utils.ConsoleWriteMembers(info.Header.SymbolTable.Value);
}
if (!info.Resource.IsEmpty)
{
Console.WriteLine("===Resources===");
Int32 directoriesCount = 0;
foreach (var dir in info.Resource)
{
directoriesCount++;
//Console.WriteLine("dir: {0}", dir.NameAddress);
Console.WriteLine("Resource dir: {0}", dir.Name);
foreach (var dir1 in dir)
{
Console.WriteLine("----- {0}", dir1.Name);
foreach (var dir2 in dir1)
{
Console.WriteLine("-------- {0}", dir2.Name);
if (dir2.DirectoryEntry.IsDataEntry)
{
switch (dir.DirectoryEntry.NameType)
{
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_VERSION:
var version1 = new AlphaOmega.Debug.NTDirectory.Resources.ResourceVersion(dir2);
var strFileInfo = version1.GetFileInfo();
Utils.ConsoleWriteMembers(version1.FileInfo.Value);
//WinNT.StringFileInfo fInfo = NativeMethods.BytesToStructure<WinNT.StringFileInfo>(bytesV, ptr);
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_STRING:
var strings = new AlphaOmega.Debug.NTDirectory.Resources.ResourceString(dir2);
foreach (var entry in strings)
{
Utils.ConsoleWriteMembers(entry);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_ACCELERATOR:
var acc = new AlphaOmega.Debug.NTDirectory.Resources.ResourceAccelerator(dir2).ToArray();
String testAcc = String.Empty;
foreach (var a in acc)
{
Utils.ConsoleWriteMembers(a);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MANIFEST:
Byte[] bytesM = dir2.GetData(); //http://msdn.microsoft.com/ru-ru/library/eew13bza.aspx
String xml = System.Text.Encoding.GetEncoding((Int32)dir2.DataEntry.Value.CodePage).GetString(bytesM);
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MESSAGETABLE:
var messageTable = new AlphaOmega.Debug.NTDirectory.Resources.ResourceMessageTable(dir2);
foreach (var entry in messageTable)
{
Utils.ConsoleWriteMembers(entry);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_MENU:
var resMenu = new AlphaOmega.Debug.NTDirectory.Resources.ResourceMenu(dir2);
foreach (var entry in resMenu.GetMenuTemplate())
{
Utils.ConsoleWriteMembers(entry);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_TOOLBAR:
var resToolbar = new AlphaOmega.Debug.NTDirectory.Resources.ResourceToolBar(dir2);
Utils.ConsoleWriteMembers(resToolbar.Header);
foreach (var entry in resToolbar.GetToolBarTemplate())
{
Utils.ConsoleWriteMembers(entry);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_FONTDIR:
var resFontDir = new AlphaOmega.Debug.NTDirectory.Resources.ResourceFontDir(dir2);
foreach (var fontItem in resFontDir)
{
Utils.ConsoleWriteMembers(fontItem);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_FONT:
var resFont = new AlphaOmega.Debug.NTDirectory.Resources.ResourceFont(dir2);
Utils.ConsoleWriteMembers(resFont.Font);
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_BITMAP:
//TODO:
// http://www.vbdotnetforums.com/graphics-gdi/49563-i-need-help-converting-bitmap-dib-intptr.html
// http://snipplr.com/view/36593/
// http://www.codeproject.com/Articles/16268/DIB-to-System-Bitmap
// http://ebersys.blogspot.com/2009/06/how-to-convert-dib-to-bitmap.html
// http://hecgeek.blogspot.com/2007/04/converting-from-dib-to.html
// http://objectmix.com/dotnet/101391-dib-bitmap-system-drawing-bitmap.html
var resBitmap = new AlphaOmega.Debug.NTDirectory.Resources.ResourceBitmap(dir2);
try
{
Utils.ConsoleWriteMembers(resBitmap.Header);
} catch (ArgumentOutOfRangeException exc)
{
Console.WriteLine("!!!ArgumentOutOfRangeException (Corrupt bitmap): {0}", exc.Message);
Console.ReadKey();
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_ICON:
var resIcon = new AlphaOmega.Debug.NTDirectory.Resources.ResourceIcon(dir2);
/*WinGdi.ICONDIR icoHeader = new WinGdi.ICONDIR() { idReserved = 0, idType = 1, idCount = 1 };
* List<Byte> bytes = new List<Byte>();
* bytes.AddRange(PinnedBufferReader.StructureToArray<WinGdi.ICONDIR>(icoHeader));
*
* var resHeader=resIcon.Header;
* Byte[] payload = resIcon.Directory.GetData().Skip(Marshal.SizeOf(typeof(WinGdi.GRPICONDIRENTRY))).ToArray();
* WinGdi.ICONDIRENTRY icoEntry = new WinGdi.ICONDIRENTRY()
* {
* bWidth = resHeader.bWidth,
* bHeight = resHeader.bHeight,
* bColorCount = resHeader.bColorCount,
* bReserved = resHeader.bReserved,
* wPlanes = resHeader.wPlanes,
* wBitCount = resHeader.wBitCount,
* dwBytesInRes = (UInt32)payload.Length,
* dwImageOffset = (UInt32)(Marshal.SizeOf(typeof(WinGdi.ICONDIR)) + Marshal.SizeOf(typeof(WinGdi.ICONDIRENTRY))),
* };
* bytes.AddRange(PinnedBufferReader.StructureToArray<WinGdi.ICONDIRENTRY>(icoEntry));
* bytes.AddRange(payload);
* File.WriteAllBytes(@"C:\Visual Studio Projects\C++\DBaseTool\DBaseTool_src\res\RT_ICON.ico", bytes.ToArray());*/
Utils.ConsoleWriteMembers(resIcon.Header);
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_DLGINIT:
var dlgInit = new AlphaOmega.Debug.NTDirectory.Resources.ResourceDialogInit(dir2);
foreach (var initData in dlgInit)
{
Utils.ConsoleWriteMembers(initData);
}
break;
case WinNT.Resource.RESOURCE_DIRECTORY_TYPE.RT_DIALOG:
var dialog = new AlphaOmega.Debug.NTDirectory.Resources.ResourceDialog(dir2);
try
{
var template = dialog.GetDialogTemplate();
foreach (var ctrl in template.Controls)
{
if (ctrl.CX < 0 || ctrl.CY < 0 || ctrl.X < 0 || ctrl.Y < 0)
{
Console.WriteLine("???Invalid position? ({0}) CX: {1} CY: {2} X: {3} Y: {4}", template.Title, ctrl.CX, ctrl.CY, ctrl.X, ctrl.Y);
Console.ReadKey();
}
else
{
Utils.ConsoleWriteMembers(ctrl);
}
}
} catch (IndexOutOfRangeException exc)
{
Console.WriteLine("!!!IndexOutOfRangeException (Corrupt dialog): {0}", exc.Message);
Console.ReadKey();
} catch (ArgumentException exc)
{
Console.WriteLine("!!!ArgumentException (Corrupt dialog): {0}", exc.Message);
Console.ReadKey();
}
break;
}
}
}
}
}
Console.WriteLine("Total dirs: {0}", directoriesCount);
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (info.ComDescriptor != null)
{ //.NET Framework
if (info.ComDescriptor.Resources != null)
{
if (info.ComDescriptor.Resources.Header.IsValid)
{
foreach (var item in info.ComDescriptor.Resources)
{
Console.WriteLine("Resource Item: {0}", item.Name);
if (item.CanRead)
{
foreach (var row in item)
{
Console.WriteLine("\tResource row: {0} {1}", row.Name, row.Type);
}
}
else
{
Console.WriteLine("\t---Some object---");
}
}
}
else
{
Console.WriteLine("INVALID. MetaData Address: {0} Resources Address: {1}", info.ComDescriptor.MetaData.Directory.VirtualAddress, info.ComDescriptor.Resources.Directory.VirtualAddress);
Console.ReadKey();
}
}
var meta = info.ComDescriptor.MetaData;
Utils.ConsoleWriteMembers("MetaData", meta.Header.Value);
foreach (var header in meta)
{
Console.WriteLine(Utils.GetReflectedMembers(header.Header));
switch (header.Header.Type)
{
case Cor.StreamHeaderType.StreamTable:
var table = (StreamTables)header;
Console.WriteLine(Utils.GetReflectedMembers(table.StreamTableHeader));
Array enums = Enum.GetValues(typeof(Cor.MetaTableType));
foreach (Cor.MetaTableType type in enums)
{
//Пробежка по всем именованным таблицам
PropertyInfo property = table.GetType().GetProperty(type.ToString(), BindingFlags.Instance | BindingFlags.Public);
foreach (var row in ((IEnumerable)property.GetValue(table, null)))
{
switch (type)
{
case Cor.MetaTableType.NestedClass:
{
NestedClassRow nestedClassRow = (NestedClassRow)row;
TypeDefRow parentTypeRow = nestedClassRow.EnclosingClass;
TypeDefRow childTypeRow = nestedClassRow.NestedClass;
String typeName = parentTypeRow.TypeNamespace + "." + parentTypeRow.TypeName + " {\r\n";
typeName += "\tclass " + childTypeRow.TypeName + " {...}\r\n";
typeName += "}";
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.FieldRVA:
{
FieldRVARow fieldRVARow = (FieldRVARow)row;
FieldRow fieldRow = fieldRVARow.Field;
String fieldName = fieldRow.Name + " -> 0x" + fieldRVARow.RVA.ToString("X8");
Console.WriteLine("{0}: {1}", type, fieldName);
}
break;
case Cor.MetaTableType.ImplMap:
{
ImplMapRow implMapRow = (ImplMapRow)row;
ModuleRefRow moduleRow = implMapRow.ImportScope;
String moduleName = moduleRow.Name + "-> " + implMapRow.ImportName;
Console.WriteLine("{0}: {1}", type, moduleName);
}
break;
case Cor.MetaTableType.MethodImpl:
{
MethodImplRow methodImplRow = (MethodImplRow)row;
TypeDefRow typeRow = methodImplRow.Class;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName;
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.PropertyMap:
{
PropertyMapRow propertyMapRow = (PropertyMapRow)row;
TypeDefRow typeRow = propertyMapRow.Parent;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n";
foreach (PropertyRow propertyRow in propertyMapRow.Properties)
{
typeName += "\t" + propertyRow.Name + ";\r\n";
}
typeName += "}";
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.EventMap:
{ //TODO: Не тестировано
EventMapRow eventMapRow = (EventMapRow)row;
TypeDefRow typeRow = eventMapRow.Parent;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n";
foreach (EventRow eventRow in eventMapRow.EventList)
{
typeName += "\tevent " + eventRow.Name + ";\r\n";
}
typeName += "}";
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.FieldLayout:
{
FieldLayoutRow fieldLayoutRow = (FieldLayoutRow)row;
FieldRow fieldRow = fieldLayoutRow.Field;
String fieldName = fieldRow.Name;
Console.WriteLine("{0}: {1}", type, fieldName);
}
break;
case Cor.MetaTableType.ClassLayout:
{
ClassLayoutRow classLayoutRow = (ClassLayoutRow)row;
TypeDefRow typeRow = classLayoutRow.Parent;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName;
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.InterfaceImpl:
{
InterfaceImplRow interfaceRow = (InterfaceImplRow)row;
TypeDefRow typeRow = interfaceRow.Class;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName;
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.TypeDef:
{
TypeDefRow typeRow = (TypeDefRow)row;
String typeName = typeRow.TypeNamespace + "." + typeRow.TypeName + " {\r\n";
foreach (var fieldRow in typeRow.FieldList)
{
typeName += "\t" + fieldRow.Name + ";\r\n";
}
foreach (var methodRow in typeRow.MethodList)
{
typeName += "\t" + methodRow.Name + "(";
foreach (var paramRow in methodRow.ParamList)
{
typeName += paramRow.Name + ", ";
}
typeName = typeName.TrimEnd(',', '"', ' ') + ");\r\n";
}
typeName += "}";
Console.WriteLine("{0}: {1}", type, typeName);
}
break;
case Cor.MetaTableType.MethodDef:
{
MethodDefRow methodRow = (MethodDefRow)row;
String methodName = methodRow.Name + "(";
foreach (var paramRow in methodRow.ParamList)
{
methodName += paramRow.Name + ", ";
}
methodName = methodName.TrimEnd(',', '"', ' ') + ")";
Console.WriteLine("{0}: {1}", type, methodName);
//TODO: Быстрый набросок чтения тела метода
UInt32 methodLength = 0;
UInt32 rva = methodRow.RVA;
Byte flags = info.Header.PtrToStructure <Byte>(rva);
rva += sizeof(Byte);
Boolean CorILMethod_FatFormat = (UInt16)(flags & 0x3) == 0x3;
Boolean CorILMethod_TinyFormat = (UInt16)(flags & 0x2) == 0x2;
Boolean CorILMethod_MoreSects = (UInt16)(flags & 0x8) == 0x8;
Boolean CorILMethod_InitLocals = (UInt16)(flags & 0x10) == 0x10;
if (CorILMethod_FatFormat)
{
Byte flags2 = info.Header.PtrToStructure <Byte>(rva);
rva += sizeof(Byte);
Byte headerSize = Convert.ToByte((flags2 >> 4) * 4);
UInt16 maxStack = info.Header.PtrToStructure <UInt16>(rva);
rva += sizeof(UInt16);
methodLength = info.Header.PtrToStructure <UInt32>(rva);
rva += sizeof(UInt32);
UInt32 localVarSigTok = info.Header.PtrToStructure <UInt32>(rva);
rva += sizeof(UInt32);
}
else
{
methodLength = ((UInt32)flags >> 2);
}
try
{
Byte[] methodBody = info.Header.ReadBytes(rva, methodLength);
Byte[] methodBody2 = methodRow.Body.GetMethodBody();
for (Int32 loop = 0; loop < methodLength; loop++)
{
if (methodBody[loop] != methodBody2[loop])
{
throw new ArgumentException("Method not equals");
}
}
} catch (Exception exc)
{
Console.WriteLine("!!!Error while reading method body!!!");
Console.WriteLine(exc.Message);
Console.ReadLine();
}
}
break;
default:
Utils.ConsoleWriteMembers(row);
break;
}
}
//Пробежка по всем таблицам
MetaTable moduleTable = table[type];
Console.WriteLine(String.Format("==MetaTableType.{0} Contents:", type));
foreach (MetaRow row in moduleTable.Rows)
{
StringBuilder result = new StringBuilder();
foreach (MetaCell cell in row)
{
result.AppendFormat("{0}:\t{1}", cell.Column.Name, cell.Value);
}
result.AppendLine();
Console.WriteLine(result.ToString());
}
Console.WriteLine(String.Format("==MetaTableType.{0} End", type));
}
break;
case Cor.StreamHeaderType.Guid:
var gHeap = (GuidHeap)header;
Guid[] guids = gHeap.Data.ToArray();
break;
case Cor.StreamHeaderType.Blob:
var bHeap = (BlobHeap)header;
Byte[][] bytes = bHeap.Data.ToArray();
break;
case Cor.StreamHeaderType.String:
var sHeap = (StringHeap)header;
String[] strings = sHeap.Data.ToArray();
break;
case Cor.StreamHeaderType.UnicodeSting:
var usHeap = (USHeap)header;
String[] usStrings = usHeap.DataString;
break;
}
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.ExceptionTable.IsEmpty)
{ //TODO: Ошибка при чтении
Console.WriteLine("===Exception Table===");
try
{
foreach (var entry in info.ExceptionTable)
{
Utils.ConsoleWriteMembers(entry);
}
} catch (ArgumentOutOfRangeException exc)
{
Console.WriteLine("Exception: " + exc.Message);
Console.WriteLine("========================");
Console.WriteLine(exc.StackTrace);
Console.ReadKey();
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Iat.IsEmpty)
{
Console.WriteLine("===Import Address Table===");
foreach (UInt32 addr in info.Iat)
{
Console.WriteLine("Addr: {0:X8}", addr);
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Tls.IsEmpty)
{
Console.WriteLine("===Thread Local Storage===");
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Certificate.IsEmpty)
{
try
{
var cert = info.Certificate.Certificate.Value;
var x509 = info.Certificate.X509;
Console.WriteLine("===Security===");
Utils.ConsoleWriteMembers(cert);
Console.WriteLine("Certificate: {0}", x509 == null ? "NULL" : x509.ToString());
} catch (ArgumentOutOfRangeException exc)
{
Console.WriteLine("!!!OverflowException (Corrupted section): {0}", exc.Message);
Console.ReadKey();
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.DelayImport.IsEmpty)
{
Console.WriteLine("===Delay Import===");
foreach (var module in info.DelayImport)
{
Console.WriteLine(String.Format("Module Name: {0}\tCount: {1}", module.ModuleName, module.Count()));
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Relocations.IsEmpty)
{ //File contains relocation table
Console.WriteLine("===Relocations===");
foreach (var block in info.Relocations)
{
Utils.ConsoleWriteMembers(block.Block);
foreach (var section in block)
{
Utils.ConsoleWriteMembers(section);
/*if(!Enum.IsDefined(typeof(WinNT.IMAGE_REL_BASED), section.Type))
* {
* Console.WriteLine(String.Format("Enum {0} not defined", section.Type));
* Console.ReadKey();
* }*/
}
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Debug.IsEmpty)
{ //В файле есть инормация для дебага
Console.WriteLine("===Debug info===");
foreach (var debug in info.Debug)
{
Utils.ConsoleWriteMembers(debug);
}
var pdb7 = info.Debug.Pdb7CodeView;
if (pdb7.HasValue)
{
Utils.ConsoleWriteMembers(pdb7.Value);
}
var pdb2 = info.Debug.Pdb2CodeView;
if (pdb2.HasValue)
{
Utils.ConsoleWriteMembers(pdb2.Value);
}
var misc = info.Debug.Misc;
if (misc.HasValue)
{
Utils.ConsoleWriteMembers(misc.Value);
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.LoadConfig.IsEmpty)
{
Console.WriteLine("===Load Config===");
if (info.LoadConfig.Directory32.HasValue)
{
var directory = info.LoadConfig.Directory32.Value;
Utils.ConsoleWriteMembers(directory);
}
else if (info.LoadConfig.Directory64.HasValue)
{
var directory = info.LoadConfig.Directory64.Value;
Utils.ConsoleWriteMembers(directory);
}
else
{
throw new NotImplementedException();
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.BoundImport.IsEmpty)
{
Console.WriteLine("===Bound Import===");
Console.WriteLine("ModuleName: {0}", info.BoundImport.ModuleName);
foreach (var ffRef in info.BoundImport)
{
Utils.ConsoleWriteMembers(ffRef);
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Export.IsEmpty)
{ //В файле есть информация о экспортируемых функциях
Console.WriteLine("===Export Functions===");
Console.WriteLine("Module name: {0}", info.Export.DllName);
foreach (var func in info.Export.GetExportFunctions())
{
Utils.ConsoleWriteMembers(func);
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
if (!info.Import.IsEmpty)
{ //В файле есть информация о импортиуемых модулях
Console.WriteLine("===Import Modules===");
foreach (var module in info.Import)
{
Console.WriteLine("Module name: {0}", module.ModuleName);
foreach (var func in module)
{
Utils.ConsoleWriteMembers(func);
}
}
if (pauseOnDir)
{
Console.ReadKey();
}
}
}
}
}
public static TypeDefinition Resolve(uint rid, TypeDefRow row, MetadataSystem metadata)
{
var resolver = new TypeDefinitionResolver(rid, row, metadata);
return(new TypeDefinition(resolver));
}
private TypeDefinitionResolver(uint rid, TypeDefRow row, MetadataSystem metadata)
{
_token = new MetadataToken(MetadataTokenType.TypeDef, rid);
_row = row;
_metadata = metadata;
}
public TypeDefRowExt(IMetadataProvider metadata, TypeDefRow row)
: base(metadata)
{
this.row = row;
}
public virtual void VisitTypeDefRow(TypeDefRow row)
{
}
/// <summary>
/// Loads all types From the given metadata module.
/// </summary>
/// <param name="module">The metadata module to load the types From.</param>
/// <param name="moduleOffsets">The offsets into the metadata arrays, of the current module.</param>
private void LoadTypes(IMetadataModule module, ModuleOffsets moduleOffsets)
{
TokenTypes maxTypeDef, maxField, maxMethod, maxLayout, tokenLayout = TokenTypes.ClassLayout + 1;
TypeDefRow typeDefRow, nextTypeDefRow = new TypeDefRow();
ClassLayoutRow layoutRow = new ClassLayoutRow();
IMetadataProvider md = module.Metadata;
int size = 0x0, packing = 0;
int typeOffset = moduleOffsets.TypeOffset;
int methodOffset = moduleOffsets.MethodOffset;
int fieldOffset = moduleOffsets.FieldOffset;
RuntimeType rt;
maxTypeDef = md.GetMaxTokenValue(TokenTypes.TypeDef);
maxLayout = md.GetMaxTokenValue(TokenTypes.ClassLayout);
if (TokenTypes.ClassLayout < maxLayout)
{
md.Read(tokenLayout, out layoutRow);
}
TokenTypes token = TokenTypes.TypeDef + 2;
md.Read(token, out typeDefRow);
do
{
/*
* string name;
* md.Read(typeDefRow.TypeNameIdx, out name);
* Debug.WriteLine(name);
*/
if (token < maxTypeDef)
{
md.Read(token + 1, out nextTypeDefRow);
maxField = nextTypeDefRow.FieldList;
maxMethod = nextTypeDefRow.MethodList;
}
else
{
maxMethod = md.GetMaxTokenValue(TokenTypes.MethodDef) + 1;
maxField = md.GetMaxTokenValue(TokenTypes.Field) + 1;
}
// Is this our layout info?
if ((layoutRow.ParentTypeDefIdx + 1) == token)
{
size = layoutRow.ClassSize;
packing = layoutRow.PackingSize;
tokenLayout++;
if (tokenLayout <= maxLayout)
{
md.Read(tokenLayout, out layoutRow);
}
}
// Create and populate the runtime type
rt = new CilRuntimeType(token, module, ref typeDefRow, maxField, maxMethod, packing, size);
LoadMethods(module, rt, typeDefRow.MethodList, maxMethod, ref methodOffset);
LoadFields(module, rt, typeDefRow.FieldList, maxField, ref fieldOffset);
_types[typeOffset++] = rt;
if (rtCallTypeAttribute == null)
{
if (rt.Name == "InternalCallTypeAttribute" && rt.Namespace == "Mosa.Runtime.Vm")
{
rtCallTypeAttribute = rt;
}
}
packing = size = 0;
typeDefRow = nextTypeDefRow;
}while (token++ < maxTypeDef);
}
