internal FieldSignatureConverter(PEFileToObjectModel peFileToObjectModel, MetadataObject moduleField, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleField)
{
//^ base;
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
this.FirstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsFieldSignature(this.FirstByte)) {
// Error...
}
bool isPinned;
this.customModifiers = this.GetCustomModifiers(out isPinned);
this.TypeReference = this.GetTypeReference();
}
internal MethodDefSignatureConverter(PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethod, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleMethod) {
// TODO: Check minimum required size of the signature...
this.FirstByte = this.SignatureMemoryReader.ReadByte();
if (SignatureHeader.IsGeneric(this.FirstByte)) {
this.GenericParamCount = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
}
this.paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
byte retByte = this.SignatureMemoryReader.PeekByte(0);
bool isReturnByReference = false;
if (retByte == ElementType.Void) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemVoid;
this.SignatureMemoryReader.SkipBytes(1);
} else if (retByte == ElementType.TypedReference) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemTypedReference;
this.SignatureMemoryReader.SkipBytes(1);
} else {
if (retByte == ElementType.ByReference) {
isReturnByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.ReturnTypeReference = this.GetTypeReference();
}
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
uint paramRowCount;
uint paramRowStart = peFileReader.GetParamInformation(moduleMethod.MethodDefRowId, out paramRowCount);
uint paramRowEnd = paramRowStart + paramRowCount;
ParamInfo[] paramInfoArray = new ParamInfo[paramRowCount];
if (peFileReader.UseParamPtrTable) {
for (uint paramRowIter = paramRowStart; paramRowIter < paramRowEnd; ++paramRowIter) {
uint paramRowId = peFileReader.ParamPtrTable.GetParamFor(paramRowIter);
ParamRow paramRow = peFileReader.ParamTable[paramRowId];
// TODO: Error check if seqence is in proper range...
paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
}
} else {
for (uint paramRowId = paramRowStart; paramRowId < paramRowEnd; ++paramRowId) {
ParamRow paramRow = peFileReader.ParamTable[paramRowId];
// TODO: Error check if seqence is in proper range...
paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
}
}
if (paramRowCount > 0 && paramInfoArray[0].ParamSequence == 0) {
ParamFlags paramFlag = paramInfoArray[0].ParamFlags;
if (isReturnByReference) {
paramFlag |= ParamFlags.ByReference;
}
this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, paramInfoArray[0].ParamName, paramFlag, paramInfoArray[0].ParamRowId);
} else {
this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, Dummy.Name, isReturnByReference ? ParamFlags.ByReference : 0, 0);
}
this.ParamInfoArray = paramInfoArray;
if (this.paramCount > 0) {
IParameterDefinition[] moduleParamArr = this.GetModuleParameters(true, moduleMethod, this.paramCount);
this.paramCount = moduleParamArr.Length;
if (this.paramCount > 0) this.Parameters = moduleParamArr;
}
}
internal PropertySignatureConverter(PEFileToObjectModel peFileToObjectModel, PropertyDefinition moduleProperty, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleProperty) {
this.parameters = Enumerable<IParameterDefinition>.Empty;
// TODO: Check minimum required size of the signature...
this.firstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsPropertySignature(this.firstByte)) {
// Error...
}
int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.returnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
if (this.SignatureMemoryReader.PeekByte(0) == ElementType.ByReference) {
this.returnValueIsByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.type = this.GetTypeReference();
if (paramCount > 0) {
IParameterDefinition[] moduleParamArr = this.GetModuleParameters(false, moduleProperty, paramCount);
if (moduleParamArr.Length > 0) this.parameters = IteratorHelper.GetReadonly(moduleParamArr);
}
}
internal SignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader,
MetadataObject metadataOwnerObject
)
//^ requires signatureMemoryReader.Length > 0;
{
this.PEFileToObjectModel = peFileToObjectModel;
this.SignatureMemoryReader = signatureMemoryReader;
this.MetadataOwnerObject = metadataOwnerObject;
this.ModuleMethodReference = metadataOwnerObject as IMethodReference;
this.ModuleMemberReference = metadataOwnerObject as ITypeMemberReference;
TypeMember/*?*/ moduleTypeMember = metadataOwnerObject as TypeMember;
if (moduleTypeMember != null) {
this.ModuleGenericType = moduleTypeMember.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = moduleTypeMember as GenericMethod;
return;
}
var moduleGenericType = metadataOwnerObject as TypeBase;
if (moduleGenericType != null) {
this.ModuleGenericType = moduleGenericType;
return;
}
GenericTypeParameter/*?*/ genericTypeParam = metadataOwnerObject as GenericTypeParameter;
if (genericTypeParam != null) {
this.ModuleGenericType = genericTypeParam.OwningGenericType;
return;
}
GenericMethodParameter/*?*/ genericMethodParam = metadataOwnerObject as GenericMethodParameter;
if (genericMethodParam != null) {
this.ModuleGenericType = genericMethodParam.OwningGenericMethod.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = genericMethodParam.OwningGenericMethod;
return;
}
}
/// <summary>
/// Method to open the module in the MetadataReader. This method loads the module and returns the object corresponding to the opened module.
/// Also returns the ModuleIDentifier corresponding to the module as the out parameter. Modules are opened as if they are not contained in any assembly.
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
/// <param name="moduleIdentity">Contains the module identity of the binary document in case it is an module.</param>
/// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
public IModule OpenModule(
IBinaryDocument binaryDocument,
out ModuleIdentity/*?*/ moduleIdentity
) {
moduleIdentity = null;
lock (GlobalLock.LockingObject) {
IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null) {
// Error...
return Dummy.Module;
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata) {
// Error...
return Dummy.Module;
}
//^ assert peFileReader.ReaderState >= ReaderState.Metadata;
if (peFileReader.IsAssembly) {
AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
moduleIdentity = assemblyIdentity;
Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null) {
return lookupAssembly;
}
} else {
moduleIdentity = this.GetModuleIdentifier(peFileReader);
Module/*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
if (lookupModule != null) {
return lookupModule;
}
}
try {
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
this.LoadedModule(peFileToObjectModel.Module);
Assembly/*?*/ assembly = peFileToObjectModel.Module as Assembly;
if (assembly != null) {
this.OpenMemberModules(binaryDocument, assembly);
}
return peFileToObjectModel.Module;
} catch (MetadataReaderException) {
// Error...
}
}
return Dummy.Module;
}
// Changes the name of any method that's defined in a winmd that implements IClosable.Close() to 'Dispose'
// so that managed consumers can call type.Dispose() directly (without casting to IDisposable).
// This is identical to the behavior one sees when one uses ildasm's "/project" option to view the contents
// of a winmd.
void IWindowsRuntimeMetadataReaderHost.FixUpNameForMethodThatImplementsIClosable(
PEFileToObjectModel peFileToObjectModel,
uint methodDefRowId,
MethodFlags flags,
TypeBase parentModuleType,
ref IName methodName
) {
if (projectToCLRTypes) {
INamespaceTypeDefinition parentNamespaceType = parentModuleType as INamespaceTypeDefinition;
if (parentNamespaceType != null && IsWinMD(parentNamespaceType.ContainingUnitNamespace.Unit) && parentNamespaceType.IsClass) {
// Is the method part of a class that is defined in a winmd?
// Note: We don't care about structs since WinRT structs can't implement interfaces.
uint paramCount;
peFileToObjectModel.PEFileReader.GetParamInformation(methodDefRowId, out paramCount);
if (paramCount == 0) {
// Is this a method that takes 0 parameters?
// Note: Desktop CLR doesn't check whether the method is public (or whether it is named Close) - so we don't either.
uint methodImplStart, methodImplEnd;
peFileToObjectModel.GetMethodImplInfoForType(parentModuleType, out methodImplStart, out methodImplEnd);
// Does this method implement IClosable.Close()?
for (uint methodImplIter = methodImplStart; methodImplIter < methodImplEnd; ++methodImplIter) {
MethodImplRow methodImplRow = peFileToObjectModel.PEFileReader.MethodImplTable[methodImplIter];
uint tokenKind = methodImplRow.MethodBody & TokenTypeIds.TokenTypeMask;
uint rowId = methodImplRow.MethodBody & TokenTypeIds.RIDMask;
IMethodReference implementedMethod = peFileToObjectModel.GetMethodReferenceForToken(parentModuleType, methodImplRow.MethodDeclaration);
INamespaceTypeReference implementedInterface = implementedMethod.ContainingType as INamespaceTypeReference;
if (implementedInterface != null &&
tokenKind == TokenTypeIds.MethodDef && rowId == methodDefRowId) {
string implementedInterfaceName = TypeHelper.GetTypeName(implementedInterface);
// Note: We will see redirected type IDisposable here (instead of IClosable) since projection support is enabled.
if (implementedInterfaceName == "System.IDisposable") {
// Note: We have a bug here. We should be checking whether the class (or one of its base classes) already has a method
// named Dispose before we introduce a new one with the same signature. However, CLR has the same bug - in this case,
// the class ends up with two methods named Dispose with the same signature. If someone were to try calling class.Dispose()
// in this case, they would see an error from the C# compiler (i.e. C# cannot resolve the ambiguity between the two identical
// methods) - but calling either of the Dispose() methods via their respective interfaces (e.g. ((IDisposable)class).Dispose())
// should work. The case where we would end up with two Dispose() methods as described above should be very rare for a winmd
// class. For now, we replicate the buggy CLR behavior since we want to avoid looking at all methods in the class / in all its
// base classes (some of which may be in a different assembly) here.
methodName = NameTable.GetNameFor("Dispose");
break;
}
}
}
}
}
}
}
internal CustomAttributeDecoder(PEFileToObjectModel peFileToObjectModel, MemoryReader signatureMemoryReader, uint customAttributeRowId,
IMethodReference attributeConstructor)
: base(peFileToObjectModel, signatureMemoryReader) {
this.CustomAttribute = Dummy.CustomAttribute;
ushort prolog = this.SignatureMemoryReader.ReadUInt16();
if (prolog != SerializationType.CustomAttributeStart) return;
int len = attributeConstructor.ParameterCount;
IMetadataExpression[]/*?*/ exprList = len == 0 ? null : new IMetadataExpression[len];
int i = 0;
foreach (var parameter in attributeConstructor.Parameters) {
var parameterType = parameter.Type;
if (parameterType is Dummy) {
// Error...
return;
}
ExpressionBase/*?*/ argument = this.ReadSerializedValue(parameterType);
if (argument == null) {
// Error...
this.decodeFailed = true;
return;
}
exprList[i++] = argument;
}
IMetadataNamedArgument[]/*?*/ namedArgumentArray = null;
if (2 <= (int)this.SignatureMemoryReader.RemainingBytes) {
ushort numOfNamedArgs = this.SignatureMemoryReader.ReadUInt16();
if (numOfNamedArgs > 0) {
namedArgumentArray = new IMetadataNamedArgument[numOfNamedArgs];
for (i = 0; i < numOfNamedArgs; ++i) {
if (0 >= (int)this.SignatureMemoryReader.RemainingBytes) break;
bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
ITypeReference/*?*/ memberType = this.GetFieldOrPropType();
if (memberType == null) {
// Error...
return;
}
string/*?*/ memberStr = this.GetSerializedString();
if (memberStr == null)
return;
IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
if (value == null) {
// Error...
return;
}
ITypeReference/*?*/ moduleTypeRef = attributeConstructor.ContainingType;
if (moduleTypeRef == null) {
// Error...
return;
}
FieldOrPropertyNamedArgumentExpression namedArg = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeRef, isField, memberType, value);
namedArgumentArray[i] = namedArg;
}
}
}
this.CustomAttribute = peFileToObjectModel.ModuleReader.metadataReaderHost.Rewrite(peFileToObjectModel.Module,
new CustomAttribute(peFileToObjectModel, customAttributeRowId, attributeConstructor, exprList, namedArgumentArray));
}
//^ [NotDelayed]
internal MethodSpecSignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MetadataObject owningObject,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, owningObject) {
//^ this.GenericTypeArguments = TypeCache.EmptyTypeArray;
//^ this.SignatureMemoryReader = signatureMemoryReader;
//^ base;
byte firstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsGenericInstanceSignature(firstByte)) {
// MDError
}
int typeArgCount = this.SignatureMemoryReader.ReadCompressedUInt32();
ITypeReference/*?*/[] typeRefArr = new ITypeReference/*?*/[typeArgCount];
for (int i = 0; i < typeArgCount; ++i) {
typeRefArr[i] = this.GetTypeReference();
}
this.GenericTypeArguments = new EnumerableArrayWrapper<ITypeReference/*?*/, ITypeReference>(typeRefArr, Dummy.TypeReference);
}
//^ [NotDelayed]
internal MethodRefSignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MethodReference moduleMethodRef,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, moduleMethodRef) {
//^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray;
this.RequiredParameters = TypeCache.EmptyParameterInfoArray;
this.VarArgParameters = TypeCache.EmptyParameterInfoArray;
//^ base;
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
// TODO: Check minimum required size of the signature...
byte firstByte = this.SignatureMemoryReader.ReadByte();
if (SignatureHeader.IsGeneric(firstByte)) {
this.GenericParamCount = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32();
}
int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
byte retByte = this.SignatureMemoryReader.PeekByte(0);
if (retByte == ElementType.Void) {
this.ReturnTypeReference = peFileToObjectModel.SystemVoid;
this.SignatureMemoryReader.SkipBytes(1);
} else if (retByte == ElementType.TypedReference) {
this.ReturnTypeReference = peFileToObjectModel.SystemTypedReference;
this.SignatureMemoryReader.SkipBytes(1);
} else {
if (retByte == ElementType.ByReference) {
this.IsReturnByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.ReturnTypeReference = this.GetTypeReference();
}
if (paramCount > 0) {
IModuleParameterTypeInformation[] reqModuleParamArr = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount);
if (reqModuleParamArr.Length > 0)
this.RequiredParameters = new EnumerableArrayWrapper<IModuleParameterTypeInformation, IParameterTypeInformation>(reqModuleParamArr, Dummy.ParameterTypeInformation);
IModuleParameterTypeInformation[] varArgModuleParamArr = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount - reqModuleParamArr.Length);
if (varArgModuleParamArr.Length > 0)
this.VarArgParameters = new EnumerableArrayWrapper<IModuleParameterTypeInformation, IParameterTypeInformation>(varArgModuleParamArr, Dummy.ParameterTypeInformation);
}
}
//^ [NotDelayed]
internal PropertySignatureConverter(
PEFileToObjectModel peFileToObjectModel,
PropertyDefinition moduleProperty,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, moduleProperty) {
//^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray;
this.Parameters = TypeCache.EmptyParameterArray;
//^ base;
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
// TODO: Check minimum required size of the signature...
this.FirstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsPropertySignature(this.FirstByte)) {
// Error...
}
int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
if (this.SignatureMemoryReader.PeekByte(0) == ElementType.ByReference) {
this.ReturnValueIsByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.ReturnTypeReference = this.GetTypeReference();
if (paramCount > 0) {
IModuleParameter[] moduleParamArr = this.GetModuleParameters(false, moduleProperty, paramCount);
if (moduleParamArr.Length > 0)
this.Parameters = new EnumerableArrayWrapper<IModuleParameter, IParameterDefinition>(moduleParamArr, Dummy.ParameterDefinition);
}
}
//^ [NotDelayed]
internal SecurityAttributeDecoder20(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader,
SecurityAttribute securityAttribute
)
: base(peFileToObjectModel, signatureMemoryReader) {
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
this.SecurityAttributes = TypeCache.EmptySecurityAttributes;
//^ base;
byte prolog = this.SignatureMemoryReader.ReadByte();
if (prolog != SerializationType.SecurityAttribute20Start) {
return;
}
int numberOfAttributes = this.SignatureMemoryReader.ReadCompressedUInt32();
SecurityCustomAttribute[] securityCustomAttributes = new SecurityCustomAttribute[numberOfAttributes];
for (int i = 0; i < numberOfAttributes; ++i) {
SecurityCustomAttribute/*?*/ secAttr = this.ReadSecurityAttribute(securityAttribute);
if (secAttr == null) {
// MDError...
return;
}
securityCustomAttributes[i] = secAttr;
}
//^ NonNullType.AssertInitialized(securityCustomAttributes);
this.SecurityAttributes = new EnumerableArrayWrapper<SecurityCustomAttribute, ICustomAttribute>(securityCustomAttributes, Dummy.CustomAttribute);
}
//^ [NotDelayed]
internal CustomAttributeDecoder(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader,
uint customAttributeRowId,
IModuleMethodReference attributeConstructor
)
: base(peFileToObjectModel, signatureMemoryReader) {
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
this.CustomAttribute = Dummy.CustomAttribute;
//^ base;
ushort prolog = this.SignatureMemoryReader.ReadUInt16();
if (prolog != SerializationType.CustomAttributeStart) {
return;
}
List<ExpressionBase> exprList = new List<ExpressionBase>();
IModuleParameterTypeInformation[] modParams = attributeConstructor.RequiredModuleParameterInfos.RawArray;
int len = modParams.Length;
for (int i = 0; i < len; ++i) {
IModuleTypeReference/*?*/ moduleTypeRef = modParams[i].ModuleTypeReference;
if (moduleTypeRef == null) {
// Error...
return;
}
ExpressionBase/*?*/ argument = this.ReadSerializedValue(moduleTypeRef);
if (argument == null) {
// Error...
this.decodeFailed = true;
return;
}
exprList.Add(argument);
}
ushort numOfNamedArgs = this.SignatureMemoryReader.ReadUInt16();
FieldOrPropertyNamedArgumentExpression[]/*?*/ namedArgumentArray = null;
if (numOfNamedArgs > 0) {
namedArgumentArray = new FieldOrPropertyNamedArgumentExpression[numOfNamedArgs];
for (ushort i = 0; i < numOfNamedArgs; ++i) {
bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
IModuleTypeReference/*?*/ memberType = this.GetFieldOrPropType();
if (memberType == null) {
// Error...
return;
}
string/*?*/ memberStr = this.GetSerializedString();
if (memberStr == null)
return;
IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
if (value == null) {
// Error...
return;
}
IModuleTypeReference/*?*/ moduleTypeRef = attributeConstructor.OwningTypeReference;
if (moduleTypeRef == null) {
// Error...
return;
}
FieldOrPropertyNamedArgumentExpression namedArg = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeRef, isField, memberType, value);
namedArgumentArray[i] = namedArg;
}
}
EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> arguments = TypeCache.EmptyExpressionList;
if (exprList.Count > 0)
arguments = new EnumerableArrayWrapper<ExpressionBase, IMetadataExpression>(exprList.ToArray(), Dummy.Expression);
EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument> namedArguments = TypeCache.EmptyNamedArgumentList;
if (namedArgumentArray != null)
namedArguments = new EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument>(namedArgumentArray, Dummy.NamedArgument);
this.CustomAttribute = new CustomAttribute(this.PEFileToObjectModel, customAttributeRowId, attributeConstructor, arguments, namedArguments);
}
/// <summary>
/// This method loads a module from a file containing only the metadata section of a PE file. (No headers and no IL.)
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
/// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
public IModule OpenSnapshot(IBinaryDocument binaryDocument) {
ModuleIdentity moduleIdentity;
lock (GlobalLock.LockingObject) {
IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null) {
// Error...
return Dummy.Module;
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock, snapshot: true);
if (peFileReader.ReaderState < ReaderState.Metadata) {
// Error...
return Dummy.Module;
}
if (peFileReader.IsAssembly) {
AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
moduleIdentity = assemblyIdentity;
Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null) {
return lookupAssembly;
}
} else {
moduleIdentity = this.GetModuleIdentifier(peFileReader);
Module/*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
if (lookupModule != null) {
return lookupModule;
}
}
if (peFileReader.ReaderState < ReaderState.Metadata) {
// Error...
return Dummy.Module;
}
try {
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
this.LoadedModule(peFileToObjectModel.Module);
CciEventSource.Log.ModuleOpened(peFileToObjectModel.Module, moduleIdentity, binaryDocument.Length);
return peFileToObjectModel.Module;
} catch (MetadataReaderException) {
// Error...
}
}
return Dummy.Module;
}
// 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, MetadataReaderSignatureTypeCode.Void);
else if (typeDefName == booleanName)
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
else if (typeDefName == charName)
this.SystemChar = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
else if (typeDefName == byteName)
this.SystemByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
else if (typeDefName == sByteName)
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
else if (typeDefName == int16Name)
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
else if (typeDefName == uint16Name)
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
else if (typeDefName == int32Name)
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
else if (typeDefName == uint32Name)
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
else if (typeDefName == int64Name)
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
else if (typeDefName == uint64Name)
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
else if (typeDefName == stringName)
this.SystemString = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
else if (typeDefName == intPtrName)
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
else if (typeDefName == uintPtrName)
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
else if (typeDefName == objectName)
this.SystemObject = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
else if (typeDefName == singleName)
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
else if (typeDefName == doubleName)
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
else if (typeDefName == decimalName)
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == typedReference)
this.SystemTypedReference = 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 == arrayName)
this.SystemArray = 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(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, MetadataReaderSignatureTypeCode.Void);
else if (typeDefName == booleanName)
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
else if (typeDefName == charName)
this.SystemChar = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
else if (typeDefName == byteName)
this.SystemByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
else if (typeDefName == sByteName)
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
else if (typeDefName == int16Name)
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
else if (typeDefName == uint16Name)
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
else if (typeDefName == int32Name)
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
else if (typeDefName == uint32Name)
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
else if (typeDefName == int64Name)
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
else if (typeDefName == uint64Name)
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
else if (typeDefName == stringName)
this.SystemString = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
else if (typeDefName == intPtrName)
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
else if (typeDefName == uintPtrName)
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
else if (typeDefName == objectName)
this.SystemObject = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
else if (typeDefName == singleName)
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
else if (typeDefName == doubleName)
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
else if (typeDefName == decimalName)
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == typedReference)
this.SystemTypedReference = 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 == arrayName)
this.SystemArray = 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.SystemVoid == null)
this.SystemVoid = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Void, MetadataReaderSignatureTypeCode.Void);
if (this.SystemBoolean == null)
this.SystemBoolean = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Boolean, MetadataReaderSignatureTypeCode.Boolean);
if (this.SystemChar == null)
this.SystemChar = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Char, MetadataReaderSignatureTypeCode.Char);
if (this.SystemByte == null)
this.SystemByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Byte, MetadataReaderSignatureTypeCode.Byte);
if (this.SystemSByte == null)
this.SystemSByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.SByte, MetadataReaderSignatureTypeCode.SByte);
if (this.SystemInt16 == null)
this.SystemInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int16, MetadataReaderSignatureTypeCode.Int16);
if (this.SystemUInt16 == null)
this.SystemUInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt16, MetadataReaderSignatureTypeCode.UInt16);
if (this.SystemInt32 == null)
this.SystemInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int32, MetadataReaderSignatureTypeCode.Int32);
if (this.SystemUInt32 == null)
this.SystemUInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt32, MetadataReaderSignatureTypeCode.UInt32);
if (this.SystemInt64 == null)
this.SystemInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int64, MetadataReaderSignatureTypeCode.Int64);
if (this.SystemUInt64 == null)
this.SystemUInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt64, MetadataReaderSignatureTypeCode.UInt64);
if (this.SystemString == null)
this.SystemString = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.String, MetadataReaderSignatureTypeCode.String);
if (this.SystemIntPtr == null)
this.SystemIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.IntPtr, MetadataReaderSignatureTypeCode.IntPtr);
if (this.SystemUIntPtr == null)
this.SystemUIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UIntPtr, MetadataReaderSignatureTypeCode.UIntPtr);
if (this.SystemObject == null)
this.SystemObject = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Object, MetadataReaderSignatureTypeCode.Object);
if (this.SystemSingle == null)
this.SystemSingle = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Single, MetadataReaderSignatureTypeCode.Single);
if (this.SystemDouble == null)
this.SystemDouble = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Double, MetadataReaderSignatureTypeCode.Double);
if (this.SystemDecimal == null)
this.SystemDecimal = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Decimal, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemTypedReference == null)
this.SystemTypedReference = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.TypedReference, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemEnum == null)
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Enum, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemValueType == null)
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.ValueType, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemMulticastDelegate == null)
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemType == null)
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Type, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemArray == null)
this.SystemArray = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Array, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemParamArrayAttribute == null)
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
//^ [NotDelayed]
internal TypeSpecSignatureConverter(
PEFileToObjectModel peFileToObjectModel,
TypeSpecReference moduleTypeSpecReference,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, moduleTypeSpecReference.TypeSpecOwner) {
//^ base;
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
byte firstByte = this.SignatureMemoryReader.ReadByte();
switch (firstByte) {
case ElementType.GenericTypeInstance:
this.TypeReference = this.GetModuleGenericTypeInstanceReference(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.ByReference:
this.TypeReference = this.GetModuleManagedPointerType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.Pointer:
this.TypeReference = this.GetModulePointerType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.Array:
this.TypeReference = this.GetModuleMatrixType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.SzArray:
this.TypeReference = this.GetModuleVectorType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.FunctionPointer:
this.TypeReference = this.GetModuleFuntionPointer(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId);
break;
case ElementType.Class:
case ElementType.ValueType: {
uint typeEncoded = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
uint typeToken = TypeDefOrRefTag.ConvertToToken(typeEncoded);
this.TypeReference = this.PEFileToObjectModel.GetTypeReferenceForToken(this.MetadataOwnerObject, typeToken, firstByte == ElementType.ValueType);
}
break;
case ElementType.GenericTypeParameter: {
ushort ordinal = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32();
if (this.ModuleGenericType == null) {
// TODO: Error
} else {
this.TypeReference = this.ModuleGenericType.GetGenericTypeParameterFromOrdinal(ordinal);
}
break;
}
case ElementType.GenericMethodParameter: {
ushort ordinal = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32();
if (this.ModuleGenericMethod == null) {
// TODO: Error
} else {
this.TypeReference = this.ModuleGenericMethod.GetGenericMethodParameterFromOrdinal(ordinal);
}
break;
}
case ElementType.RequiredModifier:
case ElementType.OptionalModifier: {
bool dummyPinned;
this.SignatureMemoryReader.SkipBytes(-1);
var customModifiers = this.GetCustomModifiers(out dummyPinned);
ITypeReference/*?*/ typeReference = this.GetTypeReference();
if (typeReference == null) {
// TODO: Error
} else {
this.TypeReference = new ModifiedTypeReference(this.PEFileToObjectModel, typeReference, customModifiers);
}
break;
}
case ElementType.Boolean:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemBoolean;
break;
case ElementType.Char:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemChar;
break;
case ElementType.Double:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemFloat64;
break;
case ElementType.Int16:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemInt16;
break;
case ElementType.Int32:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemInt32;
break;
case ElementType.Int64:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemInt64;
break;
case ElementType.Int8:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemInt8;
break;
case ElementType.IntPtr:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemIntPtr;
break;
case ElementType.Object:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemObject;
break;
case ElementType.Single:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemFloat32;
break;
case ElementType.String:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemString;
break;
case ElementType.UInt16:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemUInt16;
break;
case ElementType.UInt32:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemUInt32;
break;
case ElementType.UInt64:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemUInt64;
break;
case ElementType.UInt8:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemUInt8;
break;
case ElementType.UIntPtr:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemUIntPtr;
break;
case ElementType.Void:
this.TypeReference = this.PEFileToObjectModel.PlatformType.SystemVoid;
break;
default:
// Error...
break;
}
}
// 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);
}
}
internal MethodRefSignatureConverter(PEFileToObjectModel peFileToObjectModel, MethodReference moduleMethodRef, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleMethodRef) {
// TODO: Check minimum required size of the signature...
byte firstByte = this.SignatureMemoryReader.ReadByte();
if (SignatureHeader.IsGeneric(firstByte)) {
this.GenericParamCount = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32();
}
int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
byte retByte = this.SignatureMemoryReader.PeekByte(0);
if (retByte == ElementType.Void) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemVoid;
this.SignatureMemoryReader.SkipBytes(1);
} else if (retByte == ElementType.TypedReference) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemTypedReference;
this.SignatureMemoryReader.SkipBytes(1);
} else {
if (retByte == ElementType.ByReference) {
this.IsReturnByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.ReturnTypeReference = this.GetTypeReference();
}
if (paramCount > 0) {
this.RequiredParameters = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount);
if (this.RequiredParameters.Length < paramCount)
this.VarArgParameters = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount - this.RequiredParameters.Length);
}
}
/// <summary>
/// This method is called when an assembly is loaded. This makes sure that all the member modules of the assembly are loaded.
/// </summary>
/// <param name="binaryDocument"></param>
/// <param name="assembly"></param>
void OpenMemberModules(IBinaryDocument binaryDocument, Assembly assembly) {
List<Module> memberModuleList = new List<Module>();
AssemblyIdentity assemblyIdentity = assembly.AssemblyIdentity;
foreach (IFileReference fileRef in assembly.PEFileToObjectModel.GetFiles()) {
if (!fileRef.HasMetadata)
continue;
IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument, fileRef.FileName.Value);
if (binaryDocumentMemoryBlock == null) {
// Error...
continue;
}
try {
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata) {
// Error...
continue;
}
if (peFileReader.IsAssembly) {
// Error...
continue;
}
ModuleIdentity moduleIdentity = this.GetModuleIdentifier(peFileReader, assemblyIdentity);
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, assembly, this.metadataReaderHost.PointerSize);
memberModuleList.Add(peFileToObjectModel.Module);
} catch (MetadataReaderException) {
continue;
}
}
if (memberModuleList.Count == 0)
return;
assembly.SetMemberModules(new EnumerableArrayWrapper<Module, IModule>(memberModuleList.ToArray(), Dummy.Module));
}
protected AttributeDecoder(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader
) {
this.PEFileToObjectModel = peFileToObjectModel;
this.SignatureMemoryReader = signatureMemoryReader;
this.morePermutationsArePossible = true;
}
/// <summary>
/// Method to open the assembly in MetadataReader. This method loads the assembly and returns the object corresponding to the
/// opened assembly. Also returns the AssemblyIdentifier corresponding to the assembly as the out parameter.
/// Only assemblies that unify to themselves can be opened i.e. if the unification policy of the compilation host says that mscorlib 1.0 unifies to mscorlib 2.0
/// then only mscorlib 2.0 can be loaded.
/// </summary>
/// <param name="binaryDocument">The binary document that needes to be opened as an assembly.</param>
/// <param name="assemblyIdentity">Contains the assembly identifier of the binary document in case it is an assembly.</param>
/// <returns>Assembly that is loaded or Dummy.Assembly in case assembly could not be loaded.</returns>
public IAssembly OpenAssembly(
IBinaryDocument binaryDocument,
out AssemblyIdentity/*?*/ assemblyIdentity
) {
assemblyIdentity = null;
lock (GlobalLock.LockingObject) {
IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
if (binaryDocumentMemoryBlock == null) {
// Error...
return Dummy.Assembly;
}
PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
if (peFileReader.ReaderState < ReaderState.Metadata) {
// Error...
return Dummy.Assembly;
}
//^ assert peFileReader.ReaderState >= ReaderState.Metadata;
if (!peFileReader.IsAssembly) {
// Error...
return Dummy.Assembly;
}
assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
if (lookupAssembly != null) {
return lookupAssembly;
}
try {
PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, assemblyIdentity, null, this.metadataReaderHost.PointerSize);
Assembly/*?*/ assembly = peFileToObjectModel.Module as Assembly;
//^ assert assembly != null;
this.LoadedModule(assembly);
this.OpenMemberModules(binaryDocument, assembly);
return assembly;
} catch (MetadataReaderException) {
return Dummy.Assembly;
}
}
}
internal SecurityAttributeDecoder20(PEFileToObjectModel peFileToObjectModel, MemoryReader signatureMemoryReader, SecurityAttribute securityAttribute)
: base(peFileToObjectModel, signatureMemoryReader) {
this.SecurityAttributes = Enumerable<ICustomAttribute>.Empty;
byte prolog = this.SignatureMemoryReader.ReadByte();
if (prolog != SerializationType.SecurityAttribute20Start) return;
int numberOfAttributes = this.SignatureMemoryReader.ReadCompressedUInt32();
var securityCustomAttributes = new ICustomAttribute[numberOfAttributes];
for (int i = 0; i < numberOfAttributes; ++i) {
var secAttr = this.ReadSecurityAttribute(securityAttribute);
if (secAttr == null) {
// MDError...
return;
}
securityCustomAttributes[i] = secAttr;
}
this.SecurityAttributes = IteratorHelper.GetReadonly(securityCustomAttributes);
}
// Fixes up names and flags for managed winmd classes if projection support is enabled in the host.
// - CLR view classes and enums in managed winmds lose the '<CLR>' prefix in their name and become public.
// - WinRT view classes and enums in managed winmds get a '<WinRT>' prefix in their name and become private.
// This is identical to the behavior one sees when one uses ildasm's "/project" option to view the contents
// of a managed winmd.
void IWindowsRuntimeMetadataReaderHost.FixUpNameAndFlagsForManagedWinMDClassOrEnum(
PEFileToObjectModel peFileToObjectModel,
uint typeDefRowId,
IUnit containingUnit,
ref IName typeName,
ref TypeDefFlags flags
) {
IWindowsRuntimeMetadataReaderHost host = peFileToObjectModel.ModuleReader.metadataReaderHost as WindowsRuntimeMetadataReaderHost;
if (this.projectToCLRTypes) {
IName baseTypeNamespaceName = null;
IName baseTypeName = null;
uint baseTypeToken = peFileToObjectModel.PEFileReader.TypeDefTable.GetExtends(typeDefRowId);
uint baseTypeRowId = baseTypeToken & TokenTypeIds.RIDMask;
if (baseTypeRowId != 0) {
uint tokenType = baseTypeToken & TokenTypeIds.TokenTypeMask;
switch(tokenType) {
case TokenTypeIds.TypeDef:
TypeDefRow baseTypeDefRow = peFileToObjectModel.PEFileReader.TypeDefTable[baseTypeRowId];
baseTypeNamespaceName = peFileToObjectModel.GetNameFromOffset(baseTypeDefRow.Namespace);
baseTypeName = peFileToObjectModel.GetNameFromOffset(baseTypeDefRow.Name);
break;
case TokenTypeIds.TypeRef:
TypeRefRow baseTypeRefRow = peFileToObjectModel.PEFileReader.TypeRefTable[baseTypeRowId];
baseTypeNamespaceName = peFileToObjectModel.GetNameFromOffset(baseTypeRefRow.Namespace);
baseTypeName = peFileToObjectModel.GetNameFromOffset(baseTypeRefRow.Name);
break;
case TokenTypeIds.TypeSpec:
// We don't care about TypeSpecs because managed winmd types can never inherit generic types.
default:
break;
}
if (baseTypeName != null) {
IAssemblyReference containingUnitMscorlibReference = peFileToObjectModel.GetMscorlibReference();
this.FixUpNameAndFlagsForManagedWinMDClassOrEnum(containingUnit, containingUnitMscorlibReference, baseTypeNamespaceName, baseTypeName, ref typeName, ref flags);
}
}
}
}