private void AssertIsImported(IMetadataMember member)
{
if (member.Image != _parentBuffer.Image)
{
throw new MemberNotImportedException(member);
}
}
public MetadataToken GetMetadataToken(IMetadataMember member)
{
switch (member)
{
case ITypeDefOrRef type:
return(_buffer.TableStreamBuffer.GetTypeToken(type));
case MemberReference reference:
return(_buffer.TableStreamBuffer.GetMemberReferenceToken(reference));
case IMethodDefOrRef method:
return(_buffer.TableStreamBuffer.GetMethodToken(method));
case FieldDefinition field:
return(_buffer.TableStreamBuffer.GetNewToken(field));
case MethodSpecification specification:
return(_buffer.TableStreamBuffer.GetMethodSpecificationToken(specification));
case StandAloneSignature standAlone:
return(_buffer.TableStreamBuffer.GetStandaloneSignatureToken(standAlone));
default:
throw new NotSupportedException("Invalid or unsupported operand " + member + ".");
}
}
public static string SafeToString(this IMetadataMember self)
{
if (self is null)
{
return("null");
}
try
{
string value = self.ToString();
if (value.Length > 200)
{
value = $"{value.Remove(197)}... (truncated)";
}
if (self.MetadataToken.Rid != 0)
{
value = $"{value} (0x{self.MetadataToken.ToString()})";
}
return(value);
}
catch (Exception)
{
return($"0x{self.MetadataToken.ToString()}");
}
}
internal void CacheMember(IMetadataMember member)
{
if (member.MetadataToken.Rid == 0)
{
throw new ArgumentException("Cannot cache metadata members that do not have a metadata token yet.");
}
_cachedMembers[member.MetadataToken] = member;
}
public MetadataToken GetNewToken(IMetadataMember member)
{
MetadataToken token;
if (!_members.TryGetValue(member, out token))
{
throw new MemberNotImportedException(member);
}
return(token);
}
public static string SafeToString(this IMetadataMember self)
{
if (self is null)
{
return("null");
}
try
{
return(self.ToString());
}
catch (Exception)
{
return($"0x{self.MetadataToken}");
}
}
public MetadataToken GetMetadataToken(IMetadataMember member)
{
var type = member as ITypeDefOrRef;
if (type != null)
{
return(_buffer.TableStreamBuffer.GetTypeToken(type));
}
var reference = member as MemberReference;
if (reference != null)
{
return(_buffer.TableStreamBuffer.GetMemberReferenceToken(reference));
}
var method = member as IMethodDefOrRef;
if (method != null)
{
return(_buffer.TableStreamBuffer.GetMethodToken(method));
}
var field = member as FieldDefinition;
if (field != null)
{
return(_buffer.TableStreamBuffer.GetNewToken(field));
}
var specification = member as MethodSpecification;
if (specification != null)
{
return(_buffer.TableStreamBuffer.GetMethodSpecificationToken(specification));
}
var standAlone = member as StandAloneSignature;
if (standAlone != null)
{
return(_buffer.TableStreamBuffer.GetStandaloneSignatureToken(standAlone));
}
throw new NotSupportedException("Invalid or unsupported operand " + member + ".");
}
public bool TryResolveMember(MetadataToken token, out IMetadataMember member)
{
if (!TryGetCachedMember(token, out member))
{
var tableStream = Header.GetStream <TableStream>();
MetadataRow row;
if (!tableStream.TryResolveRow(token, out row))
{
return(false);
}
member = tableStream.GetTable(token.TokenType).GetMemberFromRow(this, row);
CacheMember(member);
}
return(true);
}
private IMetadataMember ToDefinitionInOwnModule(IMetadataMember reference)
{
switch (reference)
{
case TypeReference type:
if (IsDefinedInOwnModule(type))
{
return(type.Resolve());
}
break;
case MemberReference member:
if (IsDefinedInOwnModule(member.DeclaringType))
{
return(member.Resolve());
}
break;
}
return(null);
}
/// <summary>
/// Verifies and inserts an instruction into the collection that references a metadata member.
/// </summary>
/// <param name="index">The zero-based index at which the instruction should be inserted at.</param>
/// <param name="code">The method opcode.</param>
/// <param name="member">The member referenced by the instruction.</param>
/// <returns>The created instruction.</returns>
/// <exception cref="InvalidCilInstructionException">
/// Occurs when the provided operation is not a member opcode.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Occurs when <paramref name="member"/> is null.
/// </exception>
public CilInstruction Insert(int index, CilOpCode code, IMetadataMember member)
{
switch (code.OperandType)
{
case CilOperandType.InlineField:
case CilOperandType.InlineMethod:
case CilOperandType.InlineSig:
case CilOperandType.InlineTok:
case CilOperandType.InlineType:
break;
default:
throw new InvalidCilInstructionException(code);
}
if (member is null)
{
throw new ArgumentNullException(nameof(member));
}
return(InsertAndReturn(index, code, member));
}
public void EnterMember(IMetadataMember member)
{
IGenericArgumentsProvider type = null;
IGenericArgumentsProvider method = null;
if (member is TypeSpecification typeSpec)
{
type = typeSpec.Signature as GenericInstanceTypeSignature;
}
else if (member is IMemberDescriptor memberRef)
{
if (memberRef.DeclaringType is TypeSpecification declaringType)
{
type = declaringType.Signature as GenericInstanceTypeSignature;
}
if (member is MethodSpecification methodSpec)
{
method = methodSpec.Signature;
}
}
_genericContexts.Push(new GenericContext(type, method));
}
internal bool TryLookupMember(MetadataToken token, out IMetadataMember member)
{
member = token.Table switch
{
TableIndex.Module => LookupModuleDefinition(token),
TableIndex.TypeRef => LookupTypeReference(token),
TableIndex.TypeDef => LookupTypeDefinition(token),
TableIndex.TypeSpec => LookupTypeSpecification(token),
TableIndex.Assembly => LookupAssemblyDefinition(token),
TableIndex.AssemblyRef => LookupAssemblyReference(token),
TableIndex.Field => LookupFieldDefinition(token),
TableIndex.Method => LookupMethodDefinition(token),
TableIndex.Param => LookupParameterDefinition(token),
TableIndex.MemberRef => LookupMemberReference(token),
TableIndex.StandAloneSig => LookupStandAloneSignature(token),
TableIndex.Property => LookupPropertyDefinition(token),
TableIndex.Event => LookupEventDefinition(token),
TableIndex.MethodSemantics => LookupMethodSemantics(token),
TableIndex.CustomAttribute => LookupCustomAttribute(token),
TableIndex.MethodSpec => LookupMethodSpecification(token),
TableIndex.GenericParam => LookupGenericParameter(token),
TableIndex.GenericParamConstraint => LookupGenericParameterConstraint(token),
TableIndex.ModuleRef => LookupModuleReference(token),
TableIndex.File => LookupFileReference(token),
TableIndex.ManifestResource => LookupManifestResource(token),
TableIndex.ExportedType => LookupExportedType(token),
TableIndex.Constant => LookupConstant(token),
TableIndex.ClassLayout => LookupClassLayout(token),
TableIndex.ImplMap => LookupImplementationMap(token),
TableIndex.InterfaceImpl => LookupInterfaceImplementation(token),
TableIndex.DeclSecurity => LookupSecurityDeclaration(token),
_ => null
};
return(member != null);
}
/// <inheritdoc /> public override bool TryLookupMember(MetadataToken token, out IMetadataMember member) => _memberFactory.TryLookupMember(token, out member);
public CilInstruction Add(CilOpCode code, IMetadataMember member) => Insert(Count, code, member);
/// <summary>
/// Creates a new instance of the <see cref="MemberNotImportedException"/>.
/// </summary>
/// <param name="member">The member that was not imported.</param>
public MemberNotImportedException(IMetadataMember member)
: base($"Member {member} was not imported into the module.")
{
Member = member;
}
public TokenAnnotation(IMetadataMember member)
: base(VMCalls.TOKEN, VMType.Pointer)
{
Member = member;
}
public MemberNotImportedException(IMetadataMember member)
: base(string.Format("The member {0} is not imported into the assembly.", member))
{
Member = member;
}
internal bool TryGetCachedMember(MetadataToken token, out IMetadataMember member)
{
return(_cachedMembers.TryGetValue(token, out member));
}
