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)); }