protected ImportedMember(ImportedModule module, StringHandle nameHandle, ImportedType declaringType) { Module = module; DeclaringType = declaringType; _nameHandle = nameHandle; }
public bool StartsWith(StringHandle handle, string value) { if (value == null) { Throw.ValueArgumentNull(); } return _reader.StringStream.StartsWith(handle, value, _reader.utf8Decoder); }
public bool Equals(StringHandle handle, string value, bool ignoreCase) { if (value == null) { Throw.ValueArgumentNull(); } return _reader.StringHeap.Equals(handle, value, _reader.Utf8Decoder, ignoreCase); }
public bool Equals(StringHandle handle, string value) { if (value == null) { ThrowValueArgumentNull(); } return _reader.StringStream.Equals(handle, value, _reader.utf8Decoder); }
private static AssemblyReferenceInformation FormatAssemblyInfo(this MetadataReader metadataReader, string name, StringHandle cultureHandle, BlobHandle publicKeyTokenHandle, Version version) { var culture = cultureHandle.IsNil ? "neutral" : metadataReader.GetString(cultureHandle); var publicKeyToken = publicKeyTokenHandle.IsNil ? "null" : metadataReader.FormatPublicKeyToken(publicKeyTokenHandle); return new AssemblyReferenceInformation(name, version, culture, publicKeyToken); }
public static bool GetAttributeNamespaceAndName(this MetadataReader metadataReader, CustomAttributeHandle attributeHandle, out StringHandle namespaceHandle, out StringHandle nameHandle) { EntityHandle attributeType, attributeCtor; if (!GetAttributeTypeAndConstructor(metadataReader, attributeHandle, out attributeType, out attributeCtor)) { namespaceHandle = default(StringHandle); nameHandle = default(StringHandle); return false; } return GetAttributeTypeNamespaceAndName(metadataReader, attributeType, out namespaceHandle, out nameHandle); }
public static string GetString(this MetadataReader[] readers, StringHandle handle) { int index = MetadataTokens.GetHeapOffset(handle); foreach (var reader in readers) { int length = reader.GetHeapSize(HeapIndex.String); if (index < length) { return reader.GetString(MetadataTokens.StringHandle(index)); } index -= length; } return null; }
public NamespaceData( StringHandle name, string fullName, NamespaceDefinitionHandle parent, ImmutableArray<NamespaceDefinitionHandle> namespaceDefinitions, ImmutableArray<TypeDefinitionHandle> typeDefinitions, ImmutableArray<ExportedTypeHandle> exportedTypes) { this.Name = name; this.FullName = fullName; this.Parent = parent; this.NamespaceDefinitions = namespaceDefinitions; this.TypeDefinitions = typeDefinitions; this.ExportedTypes = exportedTypes; }
private static string GetMetadataNameWithoutBackticks(MetadataReader reader, StringHandle name) { var blobReader = reader.GetBlobReader(name); var backtickIndex = blobReader.IndexOf((byte)'`'); if (backtickIndex == -1) { return reader.GetString(name); } unsafe { return MetadataStringDecoder.DefaultUTF8.GetString( blobReader.CurrentPointer, backtickIndex); } }
public ProjectionInfo( string winRtNamespace, StringHandle.VirtualIndex clrNamespace, StringHandle.VirtualIndex clrName, AssemblyReferenceHandle.VirtualIndex clrAssembly, TypeDefTreatment treatment = TypeDefTreatment.RedirectedToClrType, bool isIDisposable = false) { this.WinRTNamespace = winRtNamespace; this.ClrNamespace = clrNamespace; this.ClrName = clrName; this.AssemblyRef = clrAssembly; this.Treatment = treatment; this.IsIDisposable = isIDisposable; }
public static bool GetAttributeTypeNamespaceAndName(this MetadataReader metadataReader, EntityHandle attributeType, out StringHandle namespaceHandle, out StringHandle nameHandle) { namespaceHandle = default(StringHandle); nameHandle = default(StringHandle); if (attributeType.Kind == HandleKind.TypeReference) { TypeReference typeRefRow = metadataReader.GetTypeReference((TypeReferenceHandle)attributeType); HandleKind handleType = typeRefRow.ResolutionScope.Kind; // Nested type? if (handleType == HandleKind.TypeReference || handleType == HandleKind.TypeDefinition) return false; nameHandle = typeRefRow.Name; namespaceHandle = typeRefRow.Namespace; return true; } else if (attributeType.Kind == HandleKind.TypeDefinition) { var def = metadataReader.GetTypeDefinition((TypeDefinitionHandle)attributeType); // Nested type? if (IsNested(def.Attributes)) return false; nameHandle = def.Name; namespaceHandle = def.Namespace; return true; } else { // unsupported metadata return false; } }
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata( MetadataReader reader, StringHandle name, Version version, StringHandle culture, BlobHandle publicKeyOrToken, AssemblyFlags assemblyFlags) { AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None; if (0 != (assemblyFlags & AssemblyFlags.PublicKey)) assemblyNameFlags |= AssemblyNameFlags.PublicKey; if (0 != (assemblyFlags & AssemblyFlags.Retargetable)) assemblyNameFlags |= AssemblyNameFlags.Retargetable; int contentType = ((int)assemblyFlags) & 0x00000E00; assemblyNameFlags |= (AssemblyNameFlags)contentType; return new RuntimeAssemblyName( name.GetString(reader), version, culture.GetString(reader), assemblyNameFlags, reader.GetBlobContent(publicKeyOrToken).ToArray() ); }
public void AddFieldDefinition( FieldAttributes attributes, StringHandle name, BlobHandle signature) { _fieldTable.Add(new FieldDefRow { Flags = (ushort)attributes, Name = name, Signature = signature }); }
public void AddParameter(ParameterAttributes attributes, StringHandle name, int sequenceNumber) { _paramTable.Add(new ParamRow { Flags = (ushort)attributes, Name = name, Sequence = (ushort)sequenceNumber }); }
public void AddEvent(EventAttributes attributes, StringHandle name, EntityHandle type) { _eventTable.Add(new EventRow { EventFlags = (ushort)attributes, Name = name, EventType = (uint)CodedIndex.ToTypeDefOrRef(type) }); }
/// <summary> /// Returns true if the given raw (non-virtual) handle represents the same string as given ASCII string. /// </summary> internal bool EqualsRaw(StringHandle rawHandle, string asciiString) { Debug.Assert(!rawHandle.IsVirtual); Debug.Assert(rawHandle.StringKind != StringKind.DotTerminated, "Not supported"); return(this.Block.CompareUtf8NullTerminatedStringWithAsciiString(rawHandle.GetHeapOffset(), asciiString) == 0); }
public void IsNil() { Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil); Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil); Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil); Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil); Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil); Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil); Assert.False(ExportedTypeHandle.FromRowId(1).IsNil); Assert.False(TypeReferenceHandle.FromRowId(1).IsNil); Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(ParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil); Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil); Assert.False(CustomAttributeHandle.FromRowId(1).IsNil); Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(ConstantHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(AssemblyFileHandle.FromRowId(1).IsNil); Assert.False(MethodImplementationHandle.FromRowId(1).IsNil); Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil); Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil); Assert.False(StringHandle.FromOffset(1).IsNil); Assert.False(BlobHandle.FromOffset(1).IsNil); Assert.False(UserStringHandle.FromOffset(1).IsNil); Assert.False(GuidHandle.FromIndex(1).IsNil); Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil); Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil); Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil); Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil); Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil); Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil); Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil); Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil); Assert.True(ExportedTypeHandle.FromRowId(0).IsNil); Assert.True(TypeReferenceHandle.FromRowId(0).IsNil); Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(ParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil); Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil); Assert.True(CustomAttributeHandle.FromRowId(0).IsNil); Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(ConstantHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(AssemblyFileHandle.FromRowId(0).IsNil); Assert.True(MethodImplementationHandle.FromRowId(0).IsNil); Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil); Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil); // heaps: Assert.True(StringHandle.FromOffset(0).IsNil); Assert.True(BlobHandle.FromOffset(0).IsNil); Assert.True(UserStringHandle.FromOffset(0).IsNil); Assert.True(GuidHandle.FromIndex(0).IsNil); Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil); Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil); // virtual: Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil); Assert.False(StringHandle.FromVirtualIndex(0).IsNil); Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil); Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil); }
private string Literal(StringHandle handle) { return(Literal(handle, BlobKind.None, (r, h) => "'" + r.GetString((StringHandle)h) + "'")); }
public void AddExportedType( TypeAttributes attributes, StringHandle @namespace, StringHandle name, EntityHandle implementation, int typeDefinitionId) { _exportedTypeTable.Add(new ExportedTypeRow { Flags = (uint)attributes, Implementation = (uint)CodedIndex.ToImplementation(implementation), TypeNamespace = @namespace, TypeName = name, TypeDefId = (uint)typeDefinitionId }); }
private bool GetAttributeTypeNameRaw(CustomAttributeHandle caHandle, out StringHandle namespaceName, out StringHandle typeName) { namespaceName = typeName = default(StringHandle); EntityHandle typeDefOrRef = GetAttributeTypeRaw(caHandle); if (typeDefOrRef.IsNil) { return(false); } if (typeDefOrRef.Kind == HandleKind.TypeReference) { TypeReferenceHandle typeRef = (TypeReferenceHandle)typeDefOrRef; var resolutionScope = TypeRefTable.GetResolutionScope(typeRef); if (!resolutionScope.IsNil && resolutionScope.Kind == HandleKind.TypeReference) { // we don't need to handle nested types return(false); } // other resolution scopes don't affect full name typeName = TypeRefTable.GetName(typeRef); namespaceName = TypeRefTable.GetNamespace(typeRef); } else if (typeDefOrRef.Kind == HandleKind.TypeDefinition) { TypeDefinitionHandle typeDef = (TypeDefinitionHandle)typeDefOrRef; if (TypeDefTable.GetFlags(typeDef).IsNested()) { // we don't need to handle nested types return(false); } typeName = TypeDefTable.GetName(typeDef); namespaceName = TypeDefTable.GetNamespace(typeDef); } else { // invalid metadata return(false); } return(true); }
internal static StringHandle GetProjectedNamespace(int projectionIndex) { Debug.Assert(s_projectionInfos != null && projectionIndex >= 0 && projectionIndex < s_projectionInfos.Length); return(StringHandle.FromVirtualIndex(s_projectionInfos[projectionIndex].ClrNamespace)); }
public int GetHeapOffset(StringHandle handle) { return(_stringIndexToResolvedOffsetMap[MetadataTokens.GetHeapOffset(handle)]); }
public static string GetString(this StringHandle handle, MetadataReader reader) { return(reader.GetString(handle)); }
private static AssemblyName CreateAssemblyName(MetadataReader mdReader, StringHandle name, System.Version version, StringHandle culture) { var cultureString = mdReader.GetString(culture); var assemblyName = new AssemblyName() { Name = mdReader.GetString(name), Version = version }; if (cultureString != "neutral") { assemblyName.CultureInfo = CultureInfo.GetCultureInfo(cultureString); } return(assemblyName); }
private static AssemblyReferenceInformation FormatAssemblyInfo(this MetadataReader metadataReader, string name, StringHandle cultureHandle, BlobHandle publicKeyTokenHandle, Version version) { var culture = cultureHandle.IsNil ? "neutral" : metadataReader.GetString(cultureHandle); var publicKeyToken = publicKeyTokenHandle.IsNil ? "null" : metadataReader.FormatPublicKeyToken(publicKeyTokenHandle); return(new AssemblyReferenceInformation(name, version, culture, publicKeyToken)); }
public void AddMethodImport( EntityHandle member, MethodImportAttributes attributes, StringHandle name, ModuleReferenceHandle module) { _implMapTable.Add(new ImplMapRow { MemberForwarded = (uint)CodedIndex.ToMemberForwarded(member), ImportName = name, ImportScope = (uint)MetadataTokens.GetRowNumber(module), MappingFlags = (ushort)attributes, }); }
public void AddManifestResource( ManifestResourceAttributes attributes, StringHandle name, EntityHandle implementation, long offset) { _manifestResourceTable.Add(new ManifestResourceRow { Flags = (uint)attributes, Name = name, Implementation = implementation.IsNil ? 0 : (uint)CodedIndex.ToImplementation(implementation), Offset = (uint)offset }); }
public static bool IsGeneratedName(this StringHandle handle, MetadataReader metadata) { return(!handle.IsNil && metadata.GetString(handle).StartsWith("<", StringComparison.Ordinal)); }
public LocalConstantHandle AddLocalConstant(StringHandle name, BlobHandle signature) { _localConstantTable.Add(new LocalConstantRow { Name = name, Signature = signature }); return MetadataTokens.LocalConstantHandle(_localConstantTable.Count); }
internal MethodImport(MethodImportAttributes attributes, StringHandle name, ModuleReferenceHandle module) { _attributes = attributes; _name = name; _module = module; }
/// <summary> /// Equivalent to Array.BinarySearch, searches for given raw (non-virtual) handle in given array of ASCII strings. /// </summary> internal int BinarySearchRaw(string[] asciiKeys, StringHandle rawHandle) { Debug.Assert(!rawHandle.IsVirtual); Debug.Assert(rawHandle.StringKind != StringKind.DotTerminated, "Not supported"); return(this.Block.BinarySearch(asciiKeys, rawHandle.GetHeapOffset())); }
public static BlobReader GetBlobReader(this StringHandle handle, MetadataReader reader) => reader.GetBlobReader(handle);
public static string GetString(this StringHandle handle, MetadataReader reader) => reader.GetString(handle);
public static string?GetStringOrNull(this StringHandle handle, MetadataReader reader) => handle.IsNil ? null : reader.GetString(handle);
internal BlobReader GetBlobReader(StringHandle handle) { return(new BlobReader(GetMemoryBlock(handle))); }
public static bool Equals(this StringHandle handle, string value, MetadataReader reader) => reader.StringComparer.Equals(handle, value, ignoreCase: false);
public void AddModuleReference(StringHandle moduleName) { _moduleRefTable.Add(new ModuleRefRow { Name = moduleName }); }
/// <summary> /// Returns the offset of metadata heap data that corresponds /// to the specified <paramref name="handle"/>. /// </summary> /// <returns> /// Zero based offset, or -1 if <paramref name="handle"/> can only be interpreted in a context of a specific <see cref="MetadataReader"/> or <see cref="MetadataBuilder"/>. /// See <see cref="GetHeapOffset(MetadataReader, Handle)"/>. /// </returns> public static int GetHeapOffset(StringHandle handle) => handle.IsVirtual ? -1 : handle.GetHeapOffset();
public GenericParameterHandle AddGenericParameter( EntityHandle parent, GenericParameterAttributes attributes, StringHandle name, int index) { _genericParamTable.Add(new GenericParamRow { Flags = (ushort)attributes, Name = name, Number = (ushort)index, Owner = (uint)CodedIndex.ToTypeOrMethodDef(parent) }); return MetadataTokens.GenericParameterHandle(_genericParamTable.Count); }
public bool StartsWith(StringHandle handle, string value) { return(StartsWith(handle, value, ignoreCase: false)); }
public MethodDefinitionHandle AddMethodDefinition( MethodAttributes attributes, MethodImplAttributes implAttributes, StringHandle name, BlobHandle signature, int bodyOffset, ParameterHandle paramList) { _methodDefTable.Add(new MethodRow { Flags = (ushort)attributes, ImplFlags = (ushort)implAttributes, Name = name, Signature = signature, BodyOffset = bodyOffset, ParamList = (uint)MetadataTokens.GetRowNumber(paramList) }); return MetadataTokens.MethodDefinitionHandle(_methodDefTable.Count); }
public bool Equals(StringHandle handle, string value) { return(Equals(handle, value, ignoreCase: false)); }
public MemberReferenceHandle AddMemberReference( EntityHandle parent, StringHandle name, BlobHandle signature) { _memberRefTable.Add(new MemberRefRow { Class = (uint)CodedIndex.ToMemberRefParent(parent), Name = name, Signature = signature }); return MetadataTokens.MemberReferenceHandle(_memberRefTable.Count); }
private bool GetAttributeTypeNameRaw(CustomAttributeHandle caHandle, out StringHandle namespaceName, out StringHandle typeName) { namespaceName = typeName = default(StringHandle); EntityHandle typeDefOrRef = GetAttributeTypeRaw(caHandle); if (typeDefOrRef.IsNil) { return false; } if (typeDefOrRef.Kind == HandleKind.TypeReference) { TypeReferenceHandle typeRef = (TypeReferenceHandle)typeDefOrRef; var resolutionScope = TypeRefTable.GetResolutionScope(typeRef); if (!resolutionScope.IsNil && resolutionScope.Kind == HandleKind.TypeReference) { // we don't need to handle nested types return false; } // other resolution scopes don't affect full name typeName = TypeRefTable.GetName(typeRef); namespaceName = TypeRefTable.GetNamespace(typeRef); } else if (typeDefOrRef.Kind == HandleKind.TypeDefinition) { TypeDefinitionHandle typeDef = (TypeDefinitionHandle)typeDefOrRef; if (TypeDefTable.GetFlags(typeDef).IsNested()) { // we don't need to handle nested types return false; } typeName = TypeDefTable.GetName(typeDef); namespaceName = TypeDefTable.GetNamespace(typeDef); } else { // invalid metadata return false; } return true; }
public void AddAssemblyFile( StringHandle name, BlobHandle hashValue, bool containsMetadata) { _fileTable.Add(new FileTableRow { FileName = name, Flags = containsMetadata ? 0u : 1u, HashValue = hashValue }); }
internal MemoryBlock GetMemoryBlock(StringHandle handle) { return(handle.IsVirtual ? GetVirtualHandleMemoryBlock(handle) : GetNonVirtualStringMemoryBlock(handle)); }
public LocalVariableHandle AddLocalVariable(LocalVariableAttributes attributes, int index, StringHandle name) { _localVariableTable.Add(new LocalVariableRow { Attributes = (ushort)attributes, Index = (ushort)index, Name = name }); return MetadataTokens.LocalVariableHandle(_localVariableTable.Count); }
// internal for testing internal int SerializeHandle(ImmutableArray <int> map, StringHandle handle) => map[handle.GetWriterVirtualIndex()];
internal AssemblyName GetAssemblyName(StringHandle nameHandle, Version version, StringHandle cultureHandle, BlobHandle publicKeyOrTokenHandle, AssemblyHashAlgorithm assemblyHashAlgorithm, AssemblyFlags flags) { string name = GetString(nameHandle); string?cultureName = (!cultureHandle.IsNil) ? GetString(cultureHandle) : null; var hashAlgorithm = (Configuration.Assemblies.AssemblyHashAlgorithm)assemblyHashAlgorithm; byte[]? publicKeyOrToken = !publicKeyOrTokenHandle.IsNil ? GetBlobBytes(publicKeyOrTokenHandle) : null; var assemblyName = new AssemblyName(name) { Version = version, CultureName = cultureName, HashAlgorithm = hashAlgorithm, Flags = GetAssemblyNameFlags(flags), ContentType = GetContentTypeFromAssemblyFlags(flags) }; bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; if (hasPublicKey) { assemblyName.SetPublicKey(publicKeyOrToken); } else { assemblyName.SetPublicKeyToken(publicKeyOrToken); } return(assemblyName); }
/// <summary>Load our fields from the metadata of the file as represented by the provided metadata reader.</summary> /// <param name="metadataReader">The metadata reader for the CLI file this represents.</param> private void LoadManagedAssemblyMetadata(MetadataReader metadataReader) { AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); // Set the internal and original names based on the file name. _internalName = _originalFilename = Path.GetFileName(_fileName); // Set the product version based on the assembly's version (this may be overwritten // later in the method). Version productVersion = assemblyDefinition.Version; _productVersion = productVersion.ToString(); _productMajor = productVersion.Major; _productMinor = productVersion.Minor; _productBuild = productVersion.Build != -1 ? productVersion.Build : 0; _productPrivate = productVersion.Revision != -1 ? productVersion.Revision : 0; // "Language Neutral" is used on Win32 for unknown language identifiers. _language = "Language Neutral"; // Set other fields to default values in case they're not overwritten by attributes _companyName = string.Empty; _comments = string.Empty; _fileDescription = " "; // this is what the managed compiler outputs when value isn't set _fileVersion = string.Empty; _legalCopyright = " "; // this is what the managed compiler outputs when value isn't set _legalTrademarks = string.Empty; _productName = string.Empty; _privateBuild = string.Empty; _specialBuild = string.Empty; // Be explicit about initialization to suppress warning about fields not being set _isDebug = false; _isPatched = false; _isPreRelease = false; _isPrivateBuild = false; _isSpecialBuild = false; // Everything else is parsed from assembly attributes MetadataStringComparer comparer = metadataReader.StringComparer; foreach (CustomAttributeHandle attrHandle in assemblyDefinition.GetCustomAttributes()) { CustomAttribute attr = metadataReader.GetCustomAttribute(attrHandle); StringHandle typeNamespaceHandle = default(StringHandle), typeNameHandle = default(StringHandle); if (TryGetAttributeName(metadataReader, attr, out typeNamespaceHandle, out typeNameHandle) && comparer.Equals(typeNamespaceHandle, "System.Reflection")) { if (comparer.Equals(typeNameHandle, "AssemblyCompanyAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _companyName); } else if (comparer.Equals(typeNameHandle, "AssemblyCopyrightAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalCopyright); } else if (comparer.Equals(typeNameHandle, "AssemblyDescriptionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _comments); } else if (comparer.Equals(typeNameHandle, "AssemblyFileVersionAttribute")) { string versionString = string.Empty; GetStringAttributeArgumentValue(metadataReader, attr, ref versionString); Version v; if (Version.TryParse(versionString, out v)) { _fileVersion = v.ToString(); _fileMajor = v.Major; _fileMinor = v.Minor; _fileBuild = v.Build != -1 ? v.Build : 0; _filePrivate = v.Revision != -1 ? v.Revision : 0; // When the managed compiler sees an [AssemblyVersion(...)] attribute, it uses that to set // both the assembly version and the product version in the Win32 resources. If it doesn't // see an [AssemblyVersion(...)], then it sets the assembly version to 0.0.0.0, however it // sets the product version in the Win32 resources to whatever was defined in the // [AssemblyFileVersionAttribute(...)] if there was one. Without parsing the Win32 resources, // we can't differentiate these two cases, so given the rarity of explicitly setting an // assembly's version number to 0.0.0.0, we assume that if it is 0.0.0.0 then the attribute // wasn't specified and we use the file version. if (_productVersion == "0.0.0.0") { _productVersion = _fileVersion; _productMajor = _fileMajor; _productMinor = _fileMinor; _productBuild = _fileBuild; _productPrivate = _filePrivate; } } } else if (comparer.Equals(typeNameHandle, "AssemblyProductAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _productName); } else if (comparer.Equals(typeNameHandle, "AssemblyTrademarkAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalTrademarks); } else if (comparer.Equals(typeNameHandle, "AssemblyTitleAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _fileDescription); } } } }
private static bool IsValidIdentifier(MetadataReader reader, StringHandle handle) { var name = reader.GetString(handle); for (int i= 0; i < name.Length; i++) { switch (name[i]) { case '<': case '>': case '$': return false; } } return true; }
/// <summary>Gets the name of an attribute.</summary> /// <param name="reader">The metadata reader.</param> /// <param name="attr">The attribute.</param> /// <param name="typeNamespaceHandle">The namespace of the attribute.</param> /// <param name="typeNameHandle">The name of the attribute.</param> /// <returns>true if the name could be retrieved; otherwise, false.</returns> private static bool TryGetAttributeName(MetadataReader reader, CustomAttribute attr, out StringHandle typeNamespaceHandle, out StringHandle typeNameHandle) { EntityHandle ctorHandle = attr.Constructor; switch (ctorHandle.Kind) { case HandleKind.MemberReference: EntityHandle container = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; if (container.Kind == HandleKind.TypeReference) { TypeReference tr = reader.GetTypeReference((TypeReferenceHandle)container); typeNamespaceHandle = tr.Namespace; typeNameHandle = tr.Name; return true; } break; case HandleKind.MethodDefinition: MethodDefinition md = reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle); TypeDefinition td = reader.GetTypeDefinition(md.GetDeclaringType()); typeNamespaceHandle = td.Namespace; typeNameHandle = td.Name; return true; } // Unusual case, potentially invalid IL typeNamespaceHandle = default(StringHandle); typeNameHandle = default(StringHandle); return false; }
internal string GetString(StringHandle handle, MetadataStringDecoder utf8Decoder) { return(handle.IsVirtual ? GetVirtualHandleString(handle, utf8Decoder) : GetNonVirtualString(handle, utf8Decoder, prefixOpt: null)); }
private static string ReadString(MetadataReader reader, StringHandle handle) { return(handle.IsNil ? null : reader.GetString(handle)); }
public string GetString(StringHandle handle) { return StringStream.GetString(handle, utf8Decoder); }
/// <summary> /// Returns true if the given raw (non-virtual) handle represents a string that starts with given ASCII prefix. /// </summary> internal bool StartsWithRaw(StringHandle rawHandle, string asciiPrefix) { Debug.Assert(!rawHandle.IsVirtual); Debug.Assert(rawHandle.StringKind != StringKind.DotTerminated, "Not supported"); return(this.Block.Utf8NullTerminatedStringStartsWithAsciiPrefix(rawHandle.GetHeapOffset(), asciiPrefix)); }
/// <summary>Gets the name of an attribute.</summary> /// <param name="reader">The metadata reader.</param> /// <param name="attr">The attribute.</param> /// <param name="typeNamespaceHandle">The namespace of the attribute.</param> /// <param name="typeNameHandle">The name of the attribute.</param> /// <returns>true if the name could be retrieved; otherwise, false.</returns> private static bool TryGetAttributeName(MetadataReader reader, CustomAttribute attr, out StringHandle typeNamespaceHandle, out StringHandle typeNameHandle) { EntityHandle ctorHandle = attr.Constructor; switch (ctorHandle.Kind) { case HandleKind.MemberReference: EntityHandle container = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; if (container.Kind == HandleKind.TypeReference) { TypeReference tr = reader.GetTypeReference((TypeReferenceHandle)container); typeNamespaceHandle = tr.Namespace; typeNameHandle = tr.Name; return(true); } break; case HandleKind.MethodDefinition: MethodDefinition md = reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle); TypeDefinition td = reader.GetTypeDefinition(md.GetDeclaringType()); typeNamespaceHandle = td.Namespace; typeNameHandle = td.Name; return(true); } // Unusual case, potentially invalid IL typeNamespaceHandle = default(StringHandle); typeNameHandle = default(StringHandle); return(false); }
/// <exception cref="BadImageFormatException">An exception from metadata reader.</exception> private static AssemblyIdentity CreateAssemblyIdentityOrThrow( this MetadataReader reader, Version version, AssemblyFlags flags, BlobHandle publicKey, StringHandle name, StringHandle culture, bool isReference) { string nameStr = reader.GetString(name); if (!MetadataHelpers.IsValidMetadataIdentifier(nameStr)) { throw new BadImageFormatException(string.Format(CodeAnalysisResources.InvalidAssemblyName, nameStr)); } string cultureName = culture.IsNil ? null : reader.GetString(culture); if (cultureName != null && !MetadataHelpers.IsValidMetadataIdentifier(cultureName)) { throw new BadImageFormatException(string.Format(CodeAnalysisResources.InvalidCultureName, cultureName)); } ImmutableArray <byte> publicKeyOrToken = reader.GetBlobContent(publicKey); bool hasPublicKey; if (isReference) { hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; if (hasPublicKey) { if (!MetadataHelpers.IsValidPublicKey(publicKeyOrToken)) { throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKey); } } else { if (!publicKeyOrToken.IsEmpty && publicKeyOrToken.Length != AssemblyIdentity.PublicKeyTokenSize) { throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKeyToken); } } } else { // Assembly definitions never contain a public key token, they only can have a full key or nothing, // so the flag AssemblyFlags.PublicKey does not make sense for them and is ignored. // See Ecma-335, Partition II Metadata, 22.2 "Assembly : 0x20". // This also corresponds to the behavior of the native C# compiler and sn.exe tool. hasPublicKey = !publicKeyOrToken.IsEmpty; if (hasPublicKey && !MetadataHelpers.IsValidPublicKey(publicKeyOrToken)) { throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKey); } } if (publicKeyOrToken.IsEmpty) { publicKeyOrToken = default(ImmutableArray <byte>); } return(new AssemblyIdentity( name: nameStr, version: version, cultureName: cultureName, publicKeyOrToken: publicKeyOrToken, hasPublicKey: hasPublicKey, isRetargetable: (flags & AssemblyFlags.Retargetable) != 0, contentType: (AssemblyContentType)((int)(flags & AssemblyFlags.ContentTypeMask) >> 9), noThrow: true)); }
public static string[] GetStrings(this MetadataReader[] readers, StringHandle[] handles) { return handles.Select(handle => readers.GetString(handle)).ToArray(); }
/// <summary>Load our fields from the metadata of the file as represented by the provided metadata reader.</summary> /// <param name="metadataReader">The metadata reader for the CLI file this represents.</param>\ /// <param name="isExe">true if the assembly represents an executable; false if it's a dll.</param> private void LoadManagedAssemblyMetadata(MetadataReader metadataReader, bool isExe) { AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); // Set the internal and original names based on the assembly name. We avoid using the // current filename for determinism and better alignment with behavior on Windows. string assemblyName = metadataReader.GetString(assemblyDefinition.Name); if (!assemblyName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !assemblyName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) { assemblyName += isExe ? ".exe" : ".dll"; } _internalName = _originalFilename = assemblyName; // Set the product version based on the assembly's version (this may be overwritten // later in the method). Version productVersion = assemblyDefinition.Version; _productVersion = productVersion.ToString(); _productMajor = productVersion.Major; _productMinor = productVersion.Minor; _productBuild = productVersion.Build != -1 ? productVersion.Build : 0; _productPrivate = productVersion.Revision != -1 ? productVersion.Revision : 0; // "Language Neutral" is used on Win32 for unknown language identifiers. _language = "Language Neutral"; // Set other fields to default values in case they're not overwritten by attributes _companyName = string.Empty; _comments = string.Empty; _fileDescription = " "; // this is what the managed compiler outputs when value isn't set _fileVersion = string.Empty; _legalCopyright = " "; // this is what the managed compiler outputs when value isn't set _legalTrademarks = string.Empty; _productName = string.Empty; _privateBuild = string.Empty; _specialBuild = string.Empty; // Be explicit about initialization to suppress warning about fields not being set _isDebug = false; _isPatched = false; _isPreRelease = false; _isPrivateBuild = false; _isSpecialBuild = false; bool sawAssemblyInformationalVersionAttribute = false; // Everything else is parsed from assembly attributes MetadataStringComparer comparer = metadataReader.StringComparer; foreach (CustomAttributeHandle attrHandle in assemblyDefinition.GetCustomAttributes()) { CustomAttribute attr = metadataReader.GetCustomAttribute(attrHandle); StringHandle typeNamespaceHandle = default(StringHandle), typeNameHandle = default(StringHandle); if (TryGetAttributeName(metadataReader, attr, out typeNamespaceHandle, out typeNameHandle) && comparer.Equals(typeNamespaceHandle, "System.Reflection")) { if (comparer.Equals(typeNameHandle, "AssemblyCompanyAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _companyName); } else if (comparer.Equals(typeNameHandle, "AssemblyCopyrightAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalCopyright); } else if (comparer.Equals(typeNameHandle, "AssemblyDescriptionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _comments); } else if (comparer.Equals(typeNameHandle, "AssemblyFileVersionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _fileVersion); ParseVersion(_fileVersion, out _fileMajor, out _fileMinor, out _fileBuild, out _filePrivate); } else if (comparer.Equals(typeNameHandle, "AssemblyInformationalVersionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _productVersion); ParseVersion(_productVersion, out _productMajor, out _productMinor, out _productBuild, out _productPrivate); sawAssemblyInformationalVersionAttribute = true; } else if (comparer.Equals(typeNameHandle, "AssemblyProductAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _productName); } else if (comparer.Equals(typeNameHandle, "AssemblyTrademarkAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalTrademarks); } else if (comparer.Equals(typeNameHandle, "AssemblyTitleAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _fileDescription); } } } // When the managed compiler sees an [AssemblyVersion(...)] attribute, it uses that to set // both the assembly version and the product version in the Win32 resources. If it doesn't // see an [AssemblyVersion(...)], then it sets the assembly version to 0.0.0.0, however it // sets the product version in the Win32 resources to whatever was defined in the // [AssemblyFileVersionAttribute(...)] if there was one (unless there is an AssemblyInformationalVersionAttribute, // in which case it always uses that for the product version). Without parsing the Win32 resources, // we can't differentiate these two cases, so given the rarity of explicitly setting an // assembly's version number to 0.0.0.0, we assume that if it is 0.0.0.0 then the attribute // wasn't specified and we use the file version. if (!sawAssemblyInformationalVersionAttribute && _productVersion == "0.0.0.0") { _productVersion = _fileVersion; _productMajor = _fileMajor; _productMinor = _fileMinor; _productBuild = _fileBuild; _productPrivate = _filePrivate; } }