public CorStandAloneSig(CorModuleDef readerModule, uint rid, GenericParamContext gpContext) {
this.readerModule = readerModule;
this.rid = rid;
this.origRid = rid;
this.gpContext = gpContext;
Initialize_NoLock();
}
public CorTypeSpec(CorModuleDef readerModule, uint rid, GenericParamContext gpContext)
{
this.readerModule = readerModule;
this.rid = rid;
this.origRid = rid;
this.gpContext = gpContext;
}
public CorMethodSpec(CorModuleDef readerModule, uint rid, GenericParamContext gpContext) {
this.readerModule = readerModule;
this.rid = rid;
origRid = rid;
this.gpContext = gpContext;
Initialize_NoLock();
}
public CorInterfaceImpl(CorModuleDef readerModule, uint rid, GenericParamContext gpContext) {
this.readerModule = readerModule;
this.rid = rid;
this.origRid = rid;
this.gpContext = gpContext;
Initialize_NoLock();
}
protected override void InitializeSecurityAttributes() {
var mdi = readerModule.MetaDataImport;
uint token = OriginalToken.Raw;
var data = MDAPI.GetPermissionSetBlob(mdi, token) ?? new byte[0];
var gpContext = new GenericParamContext();
var tmp = DeclSecurityReader.Read(readerModule, data, gpContext);
Interlocked.CompareExchange(ref securityAttributes, tmp, null);
}
public void Read(MethodDef method) {
this.gpContext = GenericParamContext.Create(method);
this.parameters = method.Parameters;
SetLocals(GetLocals(method));
maxStackSize = (ushort)reader.ReadInt32();
ReadInstructionsNumBytes(reader.ReadUInt32());
ReadExceptionHandlers();
}
CustomAttributeReader(ModuleDefMD readerModule, uint offset, GenericParamContext gpContext)
{
this.module = readerModule;
this.reader = readerModule.BlobStream.CreateStream(offset);
this.ownReader = true;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
CustomAttributeReader(ModuleDef module, IBinaryReader reader, bool ownRerader, GenericParamContext gpContext)
{
this.module = module;
this.reader = reader;
this.ownReader = ownRerader;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
public ITypeDefOrRef ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext) {
uint token;
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.TypeDef: return new TypeDefDndbg(mdi, rid);
case Table.TypeRef: return new TypeRefDndbg(mdi, rid);
case Table.TypeSpec: return new TypeSpecDndbg(mdi, rid, this);
}
return null;
}
static Instruction arithmetic_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) {
switch (reader.ReadByte()) {
case 0: return OpCodes.Add.ToInstruction();
case 1: return OpCodes.Add_Ovf.ToInstruction();
case 2: return OpCodes.Add_Ovf_Un.ToInstruction();
case 3: return OpCodes.Sub.ToInstruction();
case 4: return OpCodes.Sub_Ovf.ToInstruction();
case 5: return OpCodes.Sub_Ovf_Un.ToInstruction();
case 6: return OpCodes.Mul.ToInstruction();
case 7: return OpCodes.Mul_Ovf.ToInstruction();
case 8: return OpCodes.Mul_Ovf_Un.ToInstruction();
case 9: return OpCodes.Div.ToInstruction();
case 10: return OpCodes.Div_Un.ToInstruction();
case 11: return OpCodes.Rem.ToInstruction();
case 12: return OpCodes.Rem_Un.ToInstruction();
default: throw new ApplicationException("Invalid opcode");
}
}
/// <summary>
/// Reads custom attribute named arguments
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="stream">A stream positioned at the the first byte of the CA blob</param>
/// <param name="numNamedArgs">Number of named arguments to read from <paramref name="stream"/></param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A list of <see cref="CANamedArgument"/>s or <c>null</c> if some error
/// occurred.</returns>
internal static List <CANamedArgument> ReadNamedArguments(ModuleDef module, IBinaryReader stream, int numNamedArgs, GenericParamContext gpContext)
{
try {
using (var reader = new CustomAttributeReader(module, stream, false, gpContext))
return(reader.ReadNamedArguments(numNamedArgs));
}
catch (CABlobParserException) {
return(null);
}
catch (IOException) {
return(null);
}
}
/// <summary>
/// Reads a custom attribute
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="stream">A stream positioned at the the first byte of the CA blob</param>
/// <param name="ctor">Custom attribute constructor</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CustomAttribute"/> instance or <c>null</c> if one of the
/// args is <c>null</c> or if we failed to parse the CA blob</returns>
public static CustomAttribute Read(ModuleDef module, IBinaryReader stream, ICustomAttributeType ctor, GenericParamContext gpContext)
{
if (stream == null || ctor == null)
{
return(null);
}
try {
using (var reader = new CustomAttributeReader(module, stream, gpContext))
return(reader.Read(ctor));
}
catch (CABlobParserException) {
return(null);
}
catch (IOException) {
return(null);
}
}
/// <summary>
/// Reads a custom attribute
/// </summary>
/// <param name="readerModule">Reader module</param>
/// <param name="ctor">Custom attribute constructor</param>
/// <param name="offset">Offset of custom attribute in the #Blob stream</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CustomAttribute"/> instance</returns>
public static CustomAttribute Read(ModuleDefMD readerModule, ICustomAttributeType ctor, uint offset, GenericParamContext gpContext)
{
using (var reader = new CustomAttributeReader(readerModule, offset, gpContext)) {
try {
if (ctor == null)
{
return(reader.CreateRaw(ctor));
}
return(reader.Read(ctor));
}
catch (CABlobParserException) {
return(reader.CreateRaw(ctor));
}
catch (IOException) {
return(reader.CreateRaw(ctor));
}
}
}
/// <summary>
/// Reads a <c>DeclSecurity</c> blob
/// </summary>
/// <param name="module">Module that will own the returned list</param>
/// <param name="signature"><c>DeclSecurity</c> stream that will be owned by us</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A list of <see cref="SecurityAttribute"/>s</returns>
public static IList <SecurityAttribute> Read(ModuleDef module, DataReader signature, GenericParamContext gpContext)
{
var reader = new DeclSecurityReader(module, signature, gpContext);
return(reader.Read());
}
/// <summary> /// Reads a <c>DeclSecurity</c> blob /// </summary> /// <param name="module">Module that will own the returned list</param> /// <param name="sig"><c>#Blob</c> offset of <c>DeclSecurity</c> signature</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A list of <see cref="SecurityAttribute"/>s</returns> public static IList <SecurityAttribute> Read(ModuleDefMD module, uint sig, GenericParamContext gpContext) => Read(module, module.BlobStream.CreateReader(sig), gpContext);
/// <summary>
/// Reads a method body
/// </summary>
/// <param name="method">Method</param>
/// <param name="rva">Method RVA</param>
/// <param name="implAttrs">Method impl attrs</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="MethodBody"/> or <c>null</c> if none</returns>
internal MethodBody ReadMethodBody(MethodDefMD method, RVA rva, MethodImplAttributes implAttrs, GenericParamContext gpContext)
{
MethodBody mb;
var mDec = methodDecrypter;
if (mDec != null && mDec.GetMethodBody(method.OrigRid, rva, method.Parameters, gpContext, out mb)) {
var cilBody = mb as CilBody;
if (cilBody != null)
return InitializeBodyFromPdb(cilBody, method.OrigRid);
return mb;
}
if (rva == 0)
return null;
var codeType = implAttrs & MethodImplAttributes.CodeTypeMask;
if (codeType == MethodImplAttributes.IL)
return InitializeBodyFromPdb(ReadCilBody(method.Parameters, rva, gpContext), method.OrigRid);
if (codeType == MethodImplAttributes.Native)
return new NativeMethodBody(rva);
return null;
}
/// <summary>
/// Reads a <see cref="MarshalType"/> from <see cref="reader"/>
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="reader">A reader that will be owned by us</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="MarshalType"/> instance</returns>
public static MarshalType Read(ModuleDef module, DataReader reader, GenericParamContext gpContext)
{
var marshalReader = new MarshalBlobReader(module, ref reader, gpContext);
return(marshalReader.Read());
}
private MarshalBlobReader(ModuleDef module, IBinaryReader reader, GenericParamContext gpContext)
{
this.module = module;
this.reader = reader;
this.gpContext = gpContext;
}
/// <summary> /// Reads a <see cref="MarshalType"/> from the <c>#Blob</c> heap /// </summary> /// <param name="module">Module</param> /// <param name="sig">Blob offset</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="MarshalType"/> instance</returns> public static MarshalType Read(ModuleDefMD module, uint sig, GenericParamContext gpContext) => Read(module, module.BlobStream.CreateReader(sig), gpContext);
/// <summary>
/// Reads a <see cref="MarshalType" /> from <paramref name="data" />
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="data">Marshal data</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="MarshalType" /> instance</returns>
public static MarshalType Read(ModuleDef module, byte[] data, GenericParamContext gpContext)
{
return(Read(module, MemoryImageStream.Create(data), gpContext));
}
/// <summary>
/// Reads a <see cref="MarshalType" /> from the <c>#Blob</c> heap
/// </summary>
/// <param name="module">Module</param>
/// <param name="sig">Blob offset</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="MarshalType" /> instance</returns>
public static MarshalType Read(ModuleDefMD module, uint sig, GenericParamContext gpContext)
{
return(Read(module, module.BlobStream.CreateStream(sig), gpContext));
}
MarshalBlobReader(ModuleDef module, ref DataReader reader, GenericParamContext gpContext)
{
this.module = module;
this.reader = reader;
this.gpContext = gpContext;
}
/// <summary>
/// Resolves a token
/// </summary>
/// <param name="token">The metadata token</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="IMDTokenProvider"/> or <c>null</c> if <paramref name="token"/> is invalid</returns>
public override IMDTokenProvider ResolveToken(uint token, GenericParamContext gpContext)
{
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.Module: return ResolveModule(rid);
case Table.TypeRef: return ResolveTypeRef(rid);
case Table.TypeDef: return ResolveTypeDef(rid);
case Table.Field: return ResolveField(rid);
case Table.Method: return ResolveMethod(rid);
case Table.Param: return ResolveParam(rid);
case Table.InterfaceImpl: return ResolveInterfaceImpl(rid, gpContext);
case Table.MemberRef: return ResolveMemberRef(rid, gpContext);
case Table.Constant: return ResolveConstant(rid);
case Table.DeclSecurity: return ResolveDeclSecurity(rid);
case Table.ClassLayout: return ResolveClassLayout(rid);
case Table.StandAloneSig: return ResolveStandAloneSig(rid, gpContext);
case Table.Event: return ResolveEvent(rid);
case Table.Property: return ResolveProperty(rid);
case Table.ModuleRef: return ResolveModuleRef(rid);
case Table.TypeSpec: return ResolveTypeSpec(rid, gpContext);
case Table.ImplMap: return ResolveImplMap(rid);
case Table.Assembly: return ResolveAssembly(rid);
case Table.AssemblyRef: return ResolveAssemblyRef(rid);
case Table.File: return ResolveFile(rid);
case Table.ExportedType: return ResolveExportedType(rid);
case Table.ManifestResource:return ResolveManifestResource(rid);
case Table.GenericParam: return ResolveGenericParam(rid);
case Table.MethodSpec: return ResolveMethodSpec(rid, gpContext);
case Table.GenericParamConstraint: return ResolveGenericParamConstraint(rid, gpContext);
}
return null;
}
/// <summary>
/// Reads a type signature from the #Blob stream
/// </summary>
/// <param name="sig">#Blob stream offset of signature</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="sig"/> is invalid.</returns>
public TypeSig ReadTypeSignature(uint sig, GenericParamContext gpContext)
{
return SignatureReader.ReadTypeSig(this, sig, gpContext);
}
/// <summary>
/// Reads a new <see cref="GenericParamConstraintMD"/> instance. This one is not cached.
/// </summary>
/// <param name="rid">Row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="GenericParamConstraintMD"/> instance</returns>
internal GenericParamConstraintMD ReadGenericParamConstraint(uint rid, GenericParamContext gpContext)
{
return new GenericParamConstraintMD(this, rid, gpContext);
}
/// <summary> /// Reads a <see cref="MarshalType"/> from <paramref name="data"/> /// </summary> /// <param name="module">Owner module</param> /// <param name="data">Marshal data</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="MarshalType"/> instance</returns> public static MarshalType Read(ModuleDef module, byte[] data, GenericParamContext gpContext) => Read(module, ByteArrayDataReaderFactory.CreateReader(data), gpContext);
/// <summary>
/// Reads a <see cref="CustomAttribute"/>
/// </summary>
/// <param name="caRid">Custom attribute rid</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CustomAttribute"/> instance or <c>null</c> if
/// <paramref name="caRid"/> is invalid</returns>
public CustomAttribute ReadCustomAttribute(uint caRid, GenericParamContext gpContext)
{
var caRow = TablesStream.ReadCustomAttributeRow(caRid);
if (caRow == null)
return null;
return CustomAttributeReader.Read(this, ResolveCustomAttributeType(caRow.Type, gpContext), caRow.Value, gpContext);
}
/// <summary> /// Reads a <see cref="CallingConventionSig"/> signature /// </summary> /// <param name="module">The module where the signature is located in</param> /// <param name="signature">The signature reader</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static CallingConventionSig ReadSig(ModuleDefMD module, DataReader signature, GenericParamContext gpContext) => ReadSig(module, module.CorLibTypes, signature, gpContext);
/// <summary>
/// Resolves a <see cref="ICustomAttributeType"/>
/// </summary>
/// <param name="codedToken">A <c>CustomAttributeType</c> coded token</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="ICustomAttributeType"/> or <c>null</c> if <paramref name="codedToken"/> is invalid</returns>
public ICustomAttributeType ResolveCustomAttributeType(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.CustomAttributeType.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.Method: return ResolveMethod(rid);
case Table.MemberRef: return ResolveMemberRef(rid, gpContext);
}
return null;
}
/// <summary> /// Reads a <see cref="CallingConventionSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature data</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, byte[] signature, GenericParamContext gpContext) => ReadSig(helper, corLibTypes, ByteArrayDataReaderFactory.CreateReader(signature), gpContext);
/// <summary>
/// Parses a Reflection type name and creates a <see cref="ITypeDefOrRef"/>
/// </summary>
/// <param name="ownerModule">Module that will own the returned <see cref="ITypeDefOrRef"/> or <c>null</c></param>
/// <param name="typeFullName">Full name of type</param>
/// <param name="typeNameParserHelper">Helper class</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="ITypeDefOrRef"/> instance</returns>
/// <exception cref="TypeNameParserException">If parsing failed</exception>
public static ITypeDefOrRef ParseReflectionThrow(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
{
using (var parser = new ReflectionTypeNameParser(ownerModule, typeFullName, typeNameParserHelper, gpContext))
return(parser.Parse());
}
/// <summary>
/// Reads a <see cref="CallingConventionSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="signature">The signature reader</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, DataReader signature, GenericParamContext gpContext)
{
try {
var reader = new SignatureReader(helper, corLibTypes, ref signature, gpContext);
if (reader.reader.Length == 0)
{
return(null);
}
return(reader.ReadSig());
}
catch {
return(null);
}
}
/// <summary> /// Reads a <c>DeclSecurity</c> blob /// </summary> /// <param name="module">Module that will own the returned list</param> /// <param name="blob"><c>DeclSecurity</c> blob</param> /// <param name="gpContext">Generic parameter context</param>/// /// <returns>A list of <see cref="SecurityAttribute"/>s</returns> public static IList <SecurityAttribute> Read(ModuleDef module, byte[] blob, GenericParamContext gpContext) => Read(module, ByteArrayDataReaderFactory.CreateReader(blob), gpContext);
/// <summary>
/// Constructor
/// </summary>
/// <param name="readerModule">The module which contains this <c>MemberRef</c> row</param>
/// <param name="rid">Row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <exception cref="ArgumentNullException">If <paramref name="readerModule"/> is <c>null</c></exception>
/// <exception cref="ArgumentException">If <paramref name="rid"/> is invalid</exception>
public MemberRefMD(ModuleDefMD readerModule, uint rid, GenericParamContext gpContext) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.MemberRefTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("MemberRef rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
this.module = readerModule;
uint @class, name;
uint signature = readerModule.TablesStream.ReadMemberRefRow(origRid, out @class, out name);
this.name = readerModule.StringsStream.ReadNoNull(name);
this.@class = readerModule.ResolveMemberRefParent(@class, gpContext);
this.signature = readerModule.ReadSignature(signature, gpContext);
}
/// <summary>
/// Resolves a <see cref="IHasCustomAttribute"/>
/// </summary>
/// <param name="codedToken">A <c>HasCustomAttribute</c> coded token</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="IHasCustomAttribute"/> or <c>null</c> if <paramref name="codedToken"/> is invalid</returns>
public IHasCustomAttribute ResolveHasCustomAttribute(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.HasCustomAttribute.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.Method: return ResolveMethod(rid);
case Table.Field: return ResolveField(rid);
case Table.TypeRef: return ResolveTypeRef(rid);
case Table.TypeDef: return ResolveTypeDef(rid);
case Table.Param: return ResolveParam(rid);
case Table.InterfaceImpl: return ResolveInterfaceImpl(rid, gpContext);
case Table.MemberRef: return ResolveMemberRef(rid, gpContext);
case Table.Module: return ResolveModule(rid);
case Table.DeclSecurity:return ResolveDeclSecurity(rid);
case Table.Property: return ResolveProperty(rid);
case Table.Event: return ResolveEvent(rid);
case Table.StandAloneSig: return ResolveStandAloneSig(rid, gpContext);
case Table.ModuleRef: return ResolveModuleRef(rid);
case Table.TypeSpec: return ResolveTypeSpec(rid, gpContext);
case Table.Assembly: return ResolveAssembly(rid);
case Table.AssemblyRef: return ResolveAssemblyRef(rid);
case Table.File: return ResolveFile(rid);
case Table.ExportedType:return ResolveExportedType(rid);
case Table.ManifestResource: return ResolveManifestResource(rid);
case Table.GenericParam:return ResolveGenericParam(rid);
case Table.MethodSpec: return ResolveMethodSpec(rid, gpContext);
case Table.GenericParamConstraint: return ResolveGenericParamConstraint(rid, gpContext);
}
return null;
}
/// <summary>
/// Resolves a <see cref="MemberRef"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="MemberRef"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public MemberRef ResolveMemberRef(uint rid, GenericParamContext gpContext)
{
return listMemberRefMD[rid - 1, gpContext];
}
DeclSecurityReader(ModuleDef module, DataReader reader, GenericParamContext gpContext)
{
this.reader = reader;
this.module = module;
this.gpContext = gpContext;
}
/// <summary>
/// Resolves a <see cref="MethodSpec"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="MethodSpec"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public MethodSpec ResolveMethodSpec(uint rid, GenericParamContext gpContext)
{
return listMethodSpecMD[rid - 1, gpContext];
}
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="module">The module where the signature is located in</param> /// <param name="signature">The signature data</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ModuleDefMD module, byte[] signature, GenericParamContext gpContext) => ReadTypeSig(module, module.CorLibTypes, ByteArrayDataReaderFactory.CreateReader(signature), gpContext);
CustomAttributeReader(ModuleDef module, IBinaryReader reader, bool ownRerader, GenericParamContext gpContext)
{
this.module = module;
this.reader = reader;
this.ownReader = ownRerader;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
/// <summary>
/// Resolves a <see cref="GenericParamConstraint"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="GenericParamConstraint"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public GenericParamConstraint ResolveGenericParamConstraint(uint rid, GenericParamContext gpContext)
{
return listGenericParamConstraintMD[rid - 1, gpContext];
}
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="module">The module where the signature is located in</param> /// <param name="signature">The signature reader</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ModuleDefMD module, DataReader signature, GenericParamContext gpContext) => ReadTypeSig(module, module.CorLibTypes, signature, gpContext);
/// <summary>
/// Resolves an <see cref="InterfaceImpl"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="InterfaceImpl"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public InterfaceImpl ResolveInterfaceImpl(uint rid, GenericParamContext gpContext)
{
return listInterfaceImplMD[rid - 1, gpContext];
}
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature reader</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, DataReader signature, GenericParamContext gpContext) => ReadTypeSig(helper, corLibTypes, signature, gpContext, out var extraData);
/// <summary>
/// Resolves a <see cref="IMemberRefParent"/>
/// </summary>
/// <param name="codedToken">A <c>MemberRefParent</c> coded token</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="IMemberRefParent"/> or <c>null</c> if <paramref name="codedToken"/> is invalid</returns>
public IMemberRefParent ResolveMemberRefParent(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.MemberRefParent.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.TypeDef: return ResolveTypeDef(rid);
case Table.TypeRef: return ResolveTypeRef(rid);
case Table.ModuleRef: return ResolveModuleRef(rid);
case Table.Method: return ResolveMethod(rid);
case Table.TypeSpec: return ResolveTypeSpec(rid, gpContext);
}
return null;
}
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature data</param> /// <param name="gpContext">Generic parameter context</param> /// <param name="extraData">If there's any extra data after the signature, it's saved /// here, else this will be <c>null</c></param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, byte[] signature, GenericParamContext gpContext, out byte[] extraData) => ReadTypeSig(helper, corLibTypes, ByteArrayDataReaderFactory.CreateReader(signature), gpContext, out extraData);
/// <summary>
/// Resolves a <see cref="StandAloneSig"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="StandAloneSig"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public StandAloneSig ResolveStandAloneSig(uint rid, GenericParamContext gpContext)
{
return listStandAloneSigMD[rid - 1, gpContext];
}
/// <summary>
/// Reads a <see cref="TypeSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="signature">The signature reader</param>
/// <param name="gpContext">Generic parameter context</param>
/// <param name="extraData">If there's any extra data after the signature, it's saved
/// here, else this will be <c>null</c></param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, DataReader signature, GenericParamContext gpContext, out byte[] extraData)
{
try {
var reader = new SignatureReader(helper, corLibTypes, ref signature, gpContext);
TypeSig ts;
try {
ts = reader.ReadType();
}
catch (IOException) {
reader.reader.Position = 0;
ts = null;
}
extraData = reader.GetExtraData();
return(ts);
}
catch {
extraData = null;
return(null);
}
}
/// <summary>
/// Resolves a <see cref="TypeSpec"/>
/// </summary>
/// <param name="rid">The row ID</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="TypeSpec"/> instance or <c>null</c> if <paramref name="rid"/> is invalid</returns>
public TypeSpec ResolveTypeSpec(uint rid, GenericParamContext gpContext)
{
return listTypeSpecMD[rid - 1, gpContext];
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="reader">The signature data</param>
/// <param name="gpContext">Generic parameter context</param>
SignatureReader(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, ref DataReader reader, GenericParamContext gpContext)
{
this.helper = helper;
this.corLibTypes = corLibTypes;
this.reader = reader;
this.gpContext = gpContext;
recursionCounter = new RecursionCounter();
}
/// <summary>
/// Reads a <see cref="MarshalType"/> from the blob
/// </summary>
/// <param name="table">Table of owner</param>
/// <param name="rid">Row ID of owner</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="MarshalType"/> instance or <c>null</c> if there's no field
/// marshal for this owner.</returns>
internal MarshalType ReadMarshalType(Table table, uint rid, GenericParamContext gpContext)
{
var row = TablesStream.ReadFieldMarshalRow(MetaData.GetFieldMarshalRid(table, rid));
if (row == null)
return null;
return MarshalBlobReader.Read(this, row.NativeType, gpContext);
}
/// <summary>
/// Reads a signature from the #Blob stream
/// </summary>
/// <param name="readerModule">Reader module</param>
/// <param name="sig">#Blob stream offset of signature</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if
/// <paramref name="sig"/> is invalid.</returns>
public static CallingConventionSig ReadSig(ModuleDefMD readerModule, uint sig, GenericParamContext gpContext)
{
try {
var reader = new SignatureReader(readerModule, sig, gpContext);
if (reader.reader.Length == 0)
{
return(null);
}
var csig = reader.ReadSig();
if (!(csig is null))
{
csig.ExtraData = reader.GetExtraData();
}
return(csig);
}
catch {
return(null);
}
}
/// <summary>
/// Reads a CIL method body
/// </summary>
/// <param name="parameters">Method parameters</param>
/// <param name="rva">RVA</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CilBody"/> instance. It's empty if RVA is invalid (eg. 0 or
/// it doesn't point to a CIL method body)</returns>
public CilBody ReadCilBody(IList<Parameter> parameters, RVA rva, GenericParamContext gpContext)
{
if (rva == 0)
return new CilBody();
// Create a full stream so position will be the real position in the file. This
// is important when reading exception handlers since those must be 4-byte aligned.
// If we create a partial stream starting from rva, then position will be 0 and always
// 4-byte aligned. All fat method bodies should be 4-byte aligned, but the CLR doesn't
// seem to verify it. We must parse the method exactly the way the CLR parses it.
using (var reader = metaData.PEImage.CreateFullStream()) {
reader.Position = (long)metaData.PEImage.ToFileOffset(rva);
return MethodBodyReader.CreateCilBody(this, reader, parameters, gpContext);
}
}
/// <inheritdoc/>
protected override MarshalType GetMarshalType_NoLock()
{
return(readerModule.ReadMarshalType(Table.Param, origRid, GenericParamContext.Create(declaringMethod)));
}
/// <summary>
/// Reads a signature from the #Blob stream
/// </summary>
/// <param name="sig">#Blob stream offset of signature</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if
/// <paramref name="sig"/> is invalid.</returns>
public CallingConventionSig ReadSignature(uint sig, GenericParamContext gpContext)
{
return SignatureReader.ReadSig(this, sig, gpContext);
}
/// <summary>
/// Parses a Reflection type name and creates a <see cref="TypeSig"/>
/// </summary>
/// <param name="ownerModule">Module that will own the returned <see cref="TypeSig"/> or <c>null</c></param>
/// <param name="typeFullName">Full name of type</param>
/// <param name="typeNameParserHelper">Helper class</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if parsing failed</returns>
public static TypeSig ParseAsTypeSigReflection(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
{
try {
return(ParseAsTypeSigReflectionThrow(ownerModule, typeFullName, typeNameParserHelper, gpContext));
}
catch (TypeNameParserException) {
return(null);
}
}
/// <summary>
/// Reads a type signature from the #Blob stream
/// </summary>
/// <param name="sig">#Blob stream offset of signature</param>
/// <param name="extraData">If there's any extra data after the signature, it's saved
/// here, else this will be <c>null</c></param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="sig"/> is invalid.</returns>
public TypeSig ReadTypeSignature(uint sig, GenericParamContext gpContext, out byte[] extraData)
{
return SignatureReader.ReadTypeSig(this, sig, gpContext, out extraData);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
/// <param name="typeFullName">Full name of type</param>
/// <param name="typeNameParserHelper">Helper class</param>
/// <param name="gpContext">Generic parameter context</param>
protected TypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
{
this.ownerModule = ownerModule;
this.reader = new StringReader(typeFullName ?? string.Empty);
this.typeNameParserHelper = typeNameParserHelper;
this.gpContext = gpContext;
}
public ITypeDefOrRef ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.TypeDef: return new TypeDefUser(UTF8String.Empty) { Rid = rid };
case Table.TypeRef: return new TypeRefUser(null, UTF8String.Empty) { Rid = rid };
case Table.TypeSpec: return new TypeSpecUser() { Rid = rid };
}
return null;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
/// <param name="typeFullName">Full name of type</param>
/// <param name="typeNameParserHelper">Helper class</param>
/// <param name="gpContext">Generic parameter context</param>
public ReflectionTypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
: base(ownerModule, typeFullName, typeNameParserHelper, gpContext)
{
}
