public AssemblyQualifiedTypeName(NonQualifiedTypeName nonQualifiedTypeName, RuntimeAssemblyName assemblyName) { Debug.Assert(nonQualifiedTypeName != null); Debug.Assert(assemblyName != null); _nonQualifiedTypeName = nonQualifiedTypeName; _assemblyName = assemblyName; }
public AssemblyQualifiedTypeName(NonQualifiedTypeName nonQualifiedTypeName, RuntimeAssemblyName assemblyName) { Debug.Assert(nonQualifiedTypeName != null); Debug.Assert(assemblyName != null); _nonQualifiedTypeName = nonQualifiedTypeName; _assemblyName = assemblyName; }
// // Encapsulates the assembly ref->def matching policy. // private static bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName, ref Exception preferredException) { // // The defName came from trusted metadata so it should be fully specified. // Debug.Assert(defName.Version != null); Debug.Assert(defName.CultureName != null); if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase))) { return(false); } if (refName.Version != null) { if (!AssemblyVersionMatches(refVersion: refName.Version, defVersion: defName.Version)) { preferredException = new FileLoadException(SR.Format(SR.FileLoadException_RefDefMismatch, refName.FullName, defName.Version, refName.Version)); return(false); } } if (refName.CultureName != null) { if (!(refName.CultureName.Equals(defName.CultureName))) { return(false); } } // Strong names are ignored in .NET Core return(true); }
// // Lex the next segment as an assembly name embedded inside a generic argument type. // // Terminated by an unescaped ']'. // public RuntimeAssemblyName GetNextEmbeddedAssemblyName() { SkipWhiteSpace(); int src = _index; char[] buffer = new char[_chars.Length]; int dst = 0; for (;;) { char c = _chars[src]; if (c == NUL) { throw new ArgumentException(); } if (c == ']') { break; } src++; // Backslash can be used to escape a ']' - any other backslash character is left alone (along with the backslash) // for the AssemblyName parser to handle. if (c == '\\' && _chars[src] == ']') { c = _chars[src++]; } buffer[dst++] = c; } _index = src; string fullName = new string(buffer, 0, dst); return(RuntimeAssemblyName.Parse(fullName)); }
public PEInfo(RuntimeAssemblyName name, MetadataReader?reader, PEReader?pe, MemoryMappedViewAccessor?memoryMappedView = null) { Name = name; Reader = reader; PE = pe; MemoryMappedView = memoryMappedView; }
// // Name match routine for mscorlib references // private bool MscorlibAssemblyNameMatches(RuntimeAssemblyName coreAssemblyName, RuntimeAssemblyName defName) { // // The defName came from trusted metadata so it should be fully specified. // Debug.Assert(defName.Version != null); Debug.Assert(defName.CultureName != null); Debug.Assert((coreAssemblyName.Flags & AssemblyNameFlags.PublicKey) == 0); Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0); if (defName.Name != coreAssemblyName.Name) { return(false); } byte[] defPkt = defName.PublicKeyOrToken; if (defPkt == null) { return(false); } if (!ArePktsEqual(defPkt, coreAssemblyName.PublicKeyOrToken)) { return(false); } return(true); }
public NativeFormatModule GetModuleFromAssemblyName(string assemblyNameString) { AssemblyBindResult bindResult; RuntimeAssemblyName assemblyName = AssemblyNameParser.Parse(assemblyNameString); Exception failureException; if (!AssemblyBinderImplementation.Instance.Bind(assemblyName, cacheMissedLookups: true, out bindResult, out failureException)) { throw failureException; } var moduleList = Internal.Runtime.TypeLoader.ModuleList.Instance; NativeFormatModuleInfo primaryModule = moduleList.GetModuleInfoForMetadataReader(bindResult.Reader); // If this isn't the primary module, defer to that module to load the MetadataUnit if (primaryModule != _module) { return(Context.ResolveMetadataUnit(primaryModule).GetModule(bindResult.ScopeDefinitionHandle)); } // Setup arguments and allocate the NativeFormatModule ArrayBuilder <NativeFormatModule.QualifiedScopeDefinition> qualifiedScopes = new ArrayBuilder <NativeFormatModule.QualifiedScopeDefinition>(); qualifiedScopes.Add(new NativeFormatModule.QualifiedScopeDefinition(this, bindResult.ScopeDefinitionHandle)); foreach (QScopeDefinition scope in bindResult.OverflowScopes) { NativeFormatModuleInfo module = moduleList.GetModuleInfoForMetadataReader(scope.Reader); ScopeDefinitionHandle scopeHandle = scope.Handle; NativeFormatMetadataUnit metadataUnit = Context.ResolveMetadataUnit(module); qualifiedScopes.Add(new NativeFormatModule.QualifiedScopeDefinition(metadataUnit, scopeHandle)); } return(new NativeFormatModule(Context, qualifiedScopes.ToArray())); }
// // Parse a generic argument. In particular, generic arguments can take the special form [<typename>,<assemblyname>]. // private TypeName ParseGenericTypeArgument() { TokenType token = _lexer.GetNextToken(); if (token == TokenType.Other) { NonQualifiedTypeName nonQualifiedTypeName = ParseNonQualifiedTypeName(); return(new AssemblyQualifiedTypeName(nonQualifiedTypeName, null)); } else if (token == TokenType.OpenSqBracket) { RuntimeAssemblyName assemblyName = null; NonQualifiedTypeName typeName = ParseNonQualifiedTypeName(); token = _lexer.GetNextToken(); if (token == TokenType.Comma) { assemblyName = _lexer.GetNextEmbeddedAssemblyName(); token = _lexer.GetNextToken(); } if (token != TokenType.CloseSqBracket) { throw new ArgumentException(); } return(new AssemblyQualifiedTypeName(typeName, assemblyName)); } else { throw new ArgumentException(); } }
public Assembly CoreResolveAssembly(RuntimeAssemblyName name) { Assembly assembly = _coreAssemblyResolver(name); if (assembly == null && ThrowOnError) throw new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, name.FullName)); return assembly; }
public IEnumerable <string> FilePathsForAssembly(RuntimeAssemblyName refName) { // Check for illegal characters in file name if (refName.Name.IndexOfAny(Path.GetInvalidFileNameChars()) != -1) { yield break; } // Implement simple probing for assembly in application base directory and culture specific directory string probingDirectory = AppContext.BaseDirectory; string cultureQualifiedDirectory = probingDirectory; if (!String.IsNullOrEmpty(refName.CultureName)) { cultureQualifiedDirectory = Path.Combine(probingDirectory, refName.CultureName); } else { // Loading non-resource dlls not yet supported yield break; } // Attach assembly name yield return(Path.Combine(cultureQualifiedDirectory, refName.Name + ".dll")); }
private unsafe InternalManifestResourceInfo GetInternalManifestResourceInfo(string resourceName) { InternalManifestResourceInfo result = new InternalManifestResourceInfo(); ManifestResourceHandleCollection manifestResources = MetadataReader.ManifestResources; foreach (var resourceHandle in manifestResources) { ManifestResource resource = MetadataReader.GetManifestResource(resourceHandle); if (MetadataReader.StringComparer.Equals(resource.Name, resourceName)) { result.Found = true; if (resource.Implementation.IsNil) { checked { // Embedded data resource result.ResourceLocation = ResourceLocation.Embedded | ResourceLocation.ContainedInManifestFile; PEReader pe = PEReader; PEMemoryBlock resourceDirectory = pe.GetSectionData(pe.PEHeaders.CorHeader.ResourcesDirectory.RelativeVirtualAddress); BlobReader reader = resourceDirectory.GetReader((int)resource.Offset, resourceDirectory.Length - (int)resource.Offset); uint length = reader.ReadUInt32(); result.PointerToResource = reader.CurrentPointer; // Length check the size of the resource to ensure it fits in the PE file section, note, this is only safe as its in a checked region if (length + sizeof(Int32) > reader.Length) { throw new BadImageFormatException(); } result.SizeOfResource = length; } } else { if (resource.Implementation.Kind == HandleKind.AssemblyFile) { // Get file name result.ResourceLocation = default(ResourceLocation); AssemblyFile file = MetadataReader.GetAssemblyFile((AssemblyFileHandle)resource.Implementation); if (file.ContainsMetadata) { result.ResourceLocation = ResourceLocation.Embedded; throw new PlatformNotSupportedException(); // Support for multi-module assemblies is not implemented on this platform } result.FileName = MetadataReader.GetString(file.Name); } else if (resource.Implementation.Kind == HandleKind.AssemblyReference) { // Resolve assembly reference result.ResourceLocation = ResourceLocation.ContainedInAnotherAssembly; RuntimeAssemblyName destinationAssemblyName = ((AssemblyReferenceHandle)resource.Implementation).ToRuntimeAssemblyName(MetadataReader); result.ReferencedAssembly = RuntimeAssembly.GetRuntimeAssemblyIfExists(destinationAssemblyName); } } } } return(result); }
internal static String ComputeDisplayName(RuntimeAssemblyName a) { if (a.Name == String.Empty) throw new FileLoadException(); StringBuilder sb = new StringBuilder(); if (a.Name != null) { sb.AppendQuoted(a.Name); } if (a.Version != null) { sb.Append(", Version="); sb.Append(a.Version.ToString()); } String cultureName = a.CultureName; if (cultureName != null) { if (cultureName == String.Empty) cultureName = "neutral"; sb.Append(", Culture="); sb.AppendQuoted(cultureName); } byte[] pkt = a.PublicKeyOrToken; if (pkt != null) { if (0 != (a.Flags & AssemblyNameFlags.PublicKey)) pkt = ComputePublicKeyToken(pkt); if (pkt.Length > PUBLIC_KEY_TOKEN_LEN) throw new ArgumentException(); sb.Append(", PublicKeyToken="); if (pkt.Length == 0) sb.Append("null"); else { foreach (byte b in pkt) { sb.Append(b.ToString("x2", CultureInfo.InvariantCulture)); } } } if (0 != (a.Flags & AssemblyNameFlags.Retargetable)) sb.Append(", Retargetable=Yes"); AssemblyContentType contentType = ExtractAssemblyContentType(a.Flags); if (contentType == AssemblyContentType.WindowsRuntime) sb.Append(", ContentType=WindowsRuntime"); // NOTE: By design (desktop compat) AssemblyName.FullName and ToString() do not include ProcessorArchitecture. return sb.ToString(); }
// // Encapsulates the assembly ref->def matching policy. // private bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName) { // // The defName came from trusted metadata so it should be fully specified. // Debug.Assert(defName.Version != null); Debug.Assert(defName.CultureName != null); Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0); Debug.Assert((refName.Flags & AssemblyNameFlags.PublicKey) == 0); if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase))) { return(false); } if (refName.Version != null) { int compareResult = refName.Version.CompareTo(defName.Version); if (compareResult > 0) { return(false); } } if (refName.CultureName != null) { if (!(refName.CultureName.Equals(defName.CultureName))) { return(false); } } AssemblyNameFlags materialRefNameFlags = refName.Flags.ExtractAssemblyNameFlags(); AssemblyNameFlags materialDefNameFlags = defName.Flags.ExtractAssemblyNameFlags(); if (materialRefNameFlags != materialDefNameFlags) { return(false); } byte[] refPublicKeyToken = refName.PublicKeyOrToken; if (refPublicKeyToken != null) { byte[] defPublicKeyToken = defName.PublicKeyOrToken; if (defPublicKeyToken == null) { return(false); } if (!ArePktsEqual(refPublicKeyToken, defPublicKeyToken)) { return(false); } } return(true); }
// // Encapsulates the assembly ref->def matching policy. // private bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName, ref Exception preferredException) { // // The defName came from trusted metadata so it should be fully specified. // Debug.Assert(defName.Version != null); Debug.Assert(defName.CultureName != null); Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0); Debug.Assert((refName.Flags & AssemblyNameFlags.PublicKey) == 0); if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase))) { return(false); } if (refName.Version != null) { if (!AssemblyVersionMatches(refVersion: refName.Version, defVersion: defName.Version)) { preferredException = new FileLoadException(SR.Format(SR.FileLoadException_RefDefMismatch, refName.FullName, defName.Version, refName.Version)); return(false); } } if (refName.CultureName != null) { if (!(refName.CultureName.Equals(defName.CultureName))) { return(false); } } AssemblyNameFlags materialRefNameFlags = refName.Flags.ExtractAssemblyNameFlags(); AssemblyNameFlags materialDefNameFlags = defName.Flags.ExtractAssemblyNameFlags(); if (materialRefNameFlags != materialDefNameFlags) { return(false); } byte[] refPublicKeyToken = refName.PublicKeyOrToken; if (refPublicKeyToken != null) { byte[] defPublicKeyToken = defName.PublicKeyOrToken; if (defPublicKeyToken == null) { return(false); } if (!ArePktsEqual(refPublicKeyToken, defPublicKeyToken)) { return(false); } } return(true); }
public Assembly CoreResolveAssembly(RuntimeAssemblyName name) { Assembly assembly = _coreAssemblyResolver(name); if (assembly == null && ThrowOnError) { throw new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, name.FullName)); } return(assembly); }
public TypeForwardInfo(RuntimeAssemblyName redirectedAssemblyName, string namespaceName, string typeName) { Debug.Assert(redirectedAssemblyName != null); Debug.Assert(namespaceName != null); Debug.Assert(typeName != null); RedirectedAssemblyName = redirectedAssemblyName; NamespaceName = namespaceName; TypeName = typeName; }
internal sealed override RuntimeTypeInfo UncachedGetTypeCoreCaseSensitive(string fullName) { string[] parts = fullName.Split('.'); int numNamespaceParts = parts.Length - 1; string[] namespaceParts = new string[numNamespaceParts]; for (int i = 0; i < numNamespaceParts; i++) { namespaceParts[numNamespaceParts - i - 1] = parts[i]; } string name = parts[numNamespaceParts]; foreach (QScopeDefinition scopeDefinition in AllScopes) { MetadataReader reader = scopeDefinition.Reader; ScopeDefinitionHandle scopeDefinitionHandle = scopeDefinition.Handle; NamespaceDefinition namespaceDefinition; if (!TryResolveNamespaceDefinitionCaseSensitive(reader, namespaceParts, scopeDefinitionHandle, out namespaceDefinition)) { continue; } // We've successfully drilled down the namespace chain. Now look for a top-level type matching the type name. TypeDefinitionHandleCollection candidateTypes = namespaceDefinition.TypeDefinitions; foreach (TypeDefinitionHandle candidateType in candidateTypes) { TypeDefinition typeDefinition = candidateType.GetTypeDefinition(reader); if (typeDefinition.Name.StringEquals(name, reader)) { return(candidateType.ResolveTypeDefinition(reader)); } } // No match found in this assembly - see if there's a matching type forwarder. TypeForwarderHandleCollection candidateTypeForwarders = namespaceDefinition.TypeForwarders; foreach (TypeForwarderHandle typeForwarderHandle in candidateTypeForwarders) { TypeForwarder typeForwarder = typeForwarderHandle.GetTypeForwarder(reader); if (typeForwarder.Name.StringEquals(name, reader)) { RuntimeAssemblyName redirectedAssemblyName = typeForwarder.Scope.ToRuntimeAssemblyName(reader); RuntimeAssemblyInfo redirectedAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(redirectedAssemblyName); if (redirectedAssembly == null) { return(null); } return(redirectedAssembly.GetTypeCoreCaseSensitive(fullName)); } } } return(null); }
private Exception UncachedTryResolveCaseSensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { result = null; foreach (QScopeDefinition scopeDefinition in currentAssembly.AllScopes) { MetadataReader reader = scopeDefinition.Reader; ScopeDefinitionHandle scopeDefinitionHandle = scopeDefinition.Handle; NamespaceDefinition namespaceDefinition; if (!TryResolveNamespaceDefinitionCaseSensitive(reader, scopeDefinitionHandle, out namespaceDefinition)) { continue; } // We've successfully drilled down the namespace chain. Now look for a top-level type matching the type name. IEnumerable <TypeDefinitionHandle> candidateTypes = namespaceDefinition.TypeDefinitions; foreach (TypeDefinitionHandle candidateType in candidateTypes) { TypeDefinition typeDefinition = candidateType.GetTypeDefinition(reader); if (typeDefinition.Name.StringEquals(_name, reader)) { result = reflectionDomain.ResolveTypeDefinition(reader, candidateType); return(null); } } // No match found in this assembly - see if there's a matching type forwarder. IEnumerable <TypeForwarderHandle> candidateTypeForwarders = namespaceDefinition.TypeForwarders; foreach (TypeForwarderHandle typeForwarderHandle in candidateTypeForwarders) { TypeForwarder typeForwarder = typeForwarderHandle.GetTypeForwarder(reader); if (typeForwarder.Name.StringEquals(_name, reader)) { RuntimeAssemblyName redirectedAssemblyName = typeForwarder.Scope.ToRuntimeAssemblyName(reader); AssemblyQualifiedTypeName redirectedTypeName = new AssemblyQualifiedTypeName(this, redirectedAssemblyName); return(redirectedTypeName.TryResolve(reflectionDomain, null, /*ignoreCase: */ false, out result)); } } } { String typeName = this.ToString(); String message = SR.Format(SR.TypeLoad_TypeNotFound, typeName, currentAssembly.FullName); return(ReflectionCoreNonPortable.CreateTypeLoadException(message, typeName)); } }
// // Parses a typename. The typename may be optionally postpended with a "," followed by a legal assembly name. // private static TypeName ParseAssemblyQualifiedTypeName(String s) { if (string.IsNullOrEmpty(s)) { return(null); } // Desktop compat: a whitespace-only "typename" qualified by an assembly name throws an ArgumentException rather than // a TypeLoadException. int idx = 0; while (idx < s.Length && Char.IsWhiteSpace(s[idx])) { idx++; } if (idx < s.Length && s[idx] == ',') { throw new ArgumentException(); } try { TypeParser parser = new TypeParser(s); NonQualifiedTypeName typeName = parser.ParseNonQualifiedTypeName(); TokenType token = parser._lexer.GetNextToken(); if (token == TokenType.End) { return(typeName); } if (token == TokenType.Comma) { RuntimeAssemblyName assemblyName = parser._lexer.GetNextAssemblyName(); token = parser._lexer.Peek; if (token != TokenType.End) { throw new ArgumentException(); } return(new AssemblyQualifiedTypeName(typeName, assemblyName)); } throw new ArgumentException(); } catch (TypeLexer.IllegalEscapeSequenceException) { // Emulates a CLR4.5 bug that causes any string that contains an illegal escape sequence to be parsed as the empty string. return(ParseAssemblyQualifiedTypeName(String.Empty)); } }
private static void AddScopesFromReaderToGroups(LowLevelDictionaryWithIEnumerable <RuntimeAssemblyName, ScopeDefinitionGroup> groups, MetadataReader reader) { foreach (ScopeDefinitionHandle scopeDefinitionHandle in reader.ScopeDefinitions) { RuntimeAssemblyName defName = scopeDefinitionHandle.ToRuntimeAssemblyName(reader); ScopeDefinitionGroup scopeDefinitionGroup; if (groups.TryGetValue(defName, out scopeDefinitionGroup)) { scopeDefinitionGroup.AddOverflowScope(new QScopeDefinition(reader, scopeDefinitionHandle)); } else { scopeDefinitionGroup = new ScopeDefinitionGroup(new QScopeDefinition(reader, scopeDefinitionHandle)); groups.Add(defName, scopeDefinitionGroup); } } }
private static CoreTypeResolver CreateCoreTypeResolver(Func <Assembly, string, bool, Type> typeResolver, IList <string> defaultAssemblyNames, bool throwOnError, bool ignoreCase) { if (typeResolver == null) { return(delegate(Assembly containingAssemblyIfAny, string coreTypeName) { if (containingAssemblyIfAny != null) { return containingAssemblyIfAny.GetTypeCore(coreTypeName, ignoreCase: ignoreCase); } else { foreach (string defaultAssemblyName in defaultAssemblyNames) { RuntimeAssemblyName runtimeAssemblyName = RuntimeAssemblyName.Parse(defaultAssemblyName); RuntimeAssemblyInfo defaultAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(runtimeAssemblyName); if (defaultAssembly == null) { continue; } Type resolvedType = defaultAssembly.GetTypeCore(coreTypeName, ignoreCase: ignoreCase); if (resolvedType != null) { return resolvedType; } } if (throwOnError && defaultAssemblyNames.Count > 0) { // Though we don't have to throw a TypeLoadException exception (that's our caller's job), we can throw a more specific exception than he would so just do it. throw Helpers.CreateTypeLoadException(coreTypeName, defaultAssemblyNames[0]); } return null; } }); } else { return(delegate(Assembly containingAssemblyIfAny, string coreTypeName) { string escapedName = coreTypeName.EscapeTypeNameIdentifier(); Type type = typeResolver(containingAssemblyIfAny, escapedName, ignoreCase); return type; }); } }
private Exception TryResolveCaseInsensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { String fullName = this.ToString().ToLower(); LowLevelDictionary <String, QHandle> dict = GetCaseInsensitiveTypeDictionary(currentAssembly); QHandle qualifiedHandle; if (!dict.TryGetValue(fullName, out qualifiedHandle)) { result = null; return(new TypeLoadException(SR.Format(SR.TypeLoad_TypeNotFound, this.ToString(), currentAssembly.FullName))); } MetadataReader reader = qualifiedHandle.Reader; Handle typeDefOrForwarderHandle = qualifiedHandle.Handle; HandleType handleType = typeDefOrForwarderHandle.HandleType; switch (handleType) { case HandleType.TypeDefinition: { TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader); result = reflectionDomain.ResolveTypeDefinition(reader, typeDefinitionHandle); return(null); } case HandleType.TypeForwarder: { TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader); ScopeReferenceHandle destinationScope = typeForwarder.Scope; RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader); RuntimeAssembly destinationAssembly; Exception exception = RuntimeAssembly.TryGetRuntimeAssembly(reflectionDomain, destinationAssemblyName, out destinationAssembly); if (exception != null) { result = null; return(exception); } return(TryResolveCaseInsensitive(reflectionDomain, destinationAssembly, out result)); } default: throw new InvalidOperationException(); } }
partial void BindEcmaByteArray(byte[] rawAssembly, byte[] rawSymbolStore, ref AssemblyBindResult bindResult, ref Exception exception, ref bool?result) { // 1. Load byte[] into immutable array for use by PEReader/MetadataReader ImmutableArray <byte> assemblyData = ImmutableArray.Create(rawAssembly); PEReader pe = new PEReader(assemblyData); MetadataReader reader = pe.GetMetadataReader(); // 2. Create AssemblyName from MetadataReader RuntimeAssemblyName runtimeAssemblyName = reader.GetAssemblyDefinition().ToRuntimeAssemblyName(reader); AssemblyName asmName = new AssemblyName(); runtimeAssemblyName.CopyToAssemblyName(asmName); lock (s_ecmaLoadedAssemblies) { // 3. Attempt to bind to already loaded assembly if (Bind(asmName, out bindResult, out exception)) { result = true; return; } exception = null; // 4. If that fails, then add newly created metareader to global cache of byte array loaded modules PEInfo peinfo = new PEInfo(asmName, reader, pe); s_ecmaLoadedAssemblies.Add(peinfo); ModuleList moduleList = ModuleList.Instance; ModuleInfo newModuleInfo = new EcmaModuleInfo(moduleList.SystemModule.Handle, pe, reader); moduleList.RegisterModule(newModuleInfo); // 5. Then try to load by name again. This load should always succeed if (Bind(asmName, out bindResult, out exception)) { result = true; return; } result = false; Debug.Assert(exception != null); // We must have an error on load. At this time this could happen due to ambiguous name matching } }
public sealed override bool Bind(RuntimeAssemblyName refName, bool cacheMissedLookups, out AssemblyBindResult result, out Exception exception) { bool foundMatch = false; result = default(AssemblyBindResult); exception = null; Exception preferredException = null; foreach (KeyValuePair <RuntimeAssemblyName, ScopeDefinitionGroup> group in ScopeGroups) { if (AssemblyNameMatches(refName, group.Key, ref preferredException)) { if (foundMatch) { exception = new AmbiguousMatchException(); return(false); } foundMatch = true; ScopeDefinitionGroup scopeDefinitionGroup = group.Value; result.Reader = scopeDefinitionGroup.CanonicalScope.Reader; result.ScopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle; result.OverflowScopes = scopeDefinitionGroup.OverflowScopes; } } BindEcmaAssemblyName(refName, cacheMissedLookups, ref result, ref exception, ref preferredException, ref foundMatch); if (exception != null) { return(false); } if (!foundMatch) { exception = preferredException ?? new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName)); return(false); } return(true); }
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, ref AssemblyBindResult result, ref Exception exception, ref bool foundMatch) { lock (s_ecmaLoadedAssemblies) { for (int i = 0; i < s_ecmaLoadedAssemblies.Count; i++) { PEInfo info = s_ecmaLoadedAssemblies[i]; if (AssemblyNameMatches(refName, info.Name)) { if (foundMatch) { exception = new AmbiguousMatchException(); return; } foundMatch = true; result.EcmaMetadataReader = info.Reader; } } } }
internal sealed override RuntimeTypeInfo GetTypeCoreCaseInsensitive(string fullName) { LowLevelDictionary <string, QHandle> dict = CaseInsensitiveTypeDictionary; QHandle qualifiedHandle; if (!dict.TryGetValue(fullName.ToLowerInvariant(), out qualifiedHandle)) { return(null); } MetadataReader reader = qualifiedHandle.Reader; Handle typeDefOrForwarderHandle = qualifiedHandle.Handle; HandleType handleType = typeDefOrForwarderHandle.HandleType; switch (handleType) { case HandleType.TypeDefinition: { TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader); return(typeDefinitionHandle.ResolveTypeDefinition(reader)); } case HandleType.TypeForwarder: { TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader); ScopeReferenceHandle destinationScope = typeForwarder.Scope; RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader); RuntimeAssemblyInfo destinationAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(destinationAssemblyName); if (destinationAssembly == null) { return(null); } return(destinationAssembly.GetTypeCoreCaseInsensitive(fullName)); } default: throw new InvalidOperationException(); } }
public static AssemblyQualifiedTypeName ToAssemblyQualifiedTypeName(this NamespaceReferenceHandle namespaceReferenceHandle, String typeName, MetadataReader reader) { LowLevelList <String> namespaceParts = new LowLevelList <String>(8); NamespaceReference namespaceReference; for (; ;) { namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader); String namespacePart = namespaceReference.Name.GetStringOrNull(reader); if (namespacePart == null) { break; } namespaceParts.Add(namespacePart); namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedNamespaceReferenceHandle(reader); } ScopeReferenceHandle scopeReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedScopeReferenceHandle(reader); RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader); return(new AssemblyQualifiedTypeName(new NamespaceTypeName(namespaceParts.ToArray(), typeName), assemblyName)); }
// // Lex the next segment as the assembly name at the end of an assembly-qualified type name. (Do not use for // assembly names embedded inside generic type arguments.) // // Terminated by NUL. There are no escape characters defined by the typename lexer (however, AssemblyName // does have its own escape rules.) // public RuntimeAssemblyName GetNextAssemblyName() { SkipWhiteSpace(); int src = _index; char[] buffer = new char[_chars.Length]; int dst = 0; for (;;) { char c = _chars[src]; if (c == NUL) { break; } src++; buffer[dst++] = c; } _index = src; string fullName = new string(buffer, 0, dst); return(RuntimeAssemblyName.Parse(fullName)); }
private void BindEcma(PEReader pe, MemoryMappedViewAccessor?memoryMappedView, out AssemblyBindResult bindResult, out Exception?exception, out bool?result) { MetadataReader reader = pe.GetMetadataReader(); // 1. Create AssemblyName from MetadataReader RuntimeAssemblyName runtimeAssemblyName = reader.GetAssemblyDefinition().ToRuntimeAssemblyName(reader); lock (s_ecmaLoadedAssemblies) { // 2. Attempt to bind to already loaded assembly if (Bind(runtimeAssemblyName, cacheMissedLookups: false, out bindResult, out exception)) { result = true; return; } exception = null; // 3. If that fails, then add newly created metareader to global cache of loaded modules PEInfo peinfo = new PEInfo(runtimeAssemblyName, reader, pe, memoryMappedView); s_ecmaLoadedAssemblies.Add(peinfo); ModuleList moduleList = ModuleList.Instance; ModuleInfo newModuleInfo = new EcmaModuleInfo(moduleList.SystemModule.Handle, pe, reader); moduleList.RegisterModule(newModuleInfo); // 4. Then try to load by name again. This load should always succeed if (Bind(runtimeAssemblyName, cacheMissedLookups: true, out bindResult, out exception)) { result = true; return; } result = false; Debug.Assert(exception != null); // We must have an error on load. At this time this could happen due to ambiguous name matching } }
public sealed override void InitializeAssemblyName(AssemblyName blank, String fullName) { RuntimeAssemblyName runtimeAssemblyName = AssemblyNameParser.Parse(fullName); runtimeAssemblyName.CopyToAssemblyName(blank); }
private static RuntimeTypeInfo?TryResolveTypeReference(this TypeReferenceHandle typeReferenceHandle, MetadataReader reader, ref Exception?exception) { RuntimeTypeHandle resolvedRuntimeTypeHandle; if (ReflectionCoreExecution.ExecutionEnvironment.TryGetNamedTypeForTypeReference(reader, typeReferenceHandle, out resolvedRuntimeTypeHandle)) { return(resolvedRuntimeTypeHandle.GetTypeForRuntimeTypeHandle()); } TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader); string name = typeReference.TypeName.GetString(reader); Handle parent = typeReference.ParentNamespaceOrType; HandleType parentType = parent.HandleType; TypeInfo? outerTypeInfo = null; // Check if this is a reference to a nested type. if (parentType == HandleType.TypeDefinition) { outerTypeInfo = parent.ToTypeDefinitionHandle(reader).GetNamedType(reader); } else if (parentType == HandleType.TypeReference) { RuntimeTypeInfo?outerType = parent.ToTypeReferenceHandle(reader).TryResolveTypeReference(reader, ref exception); if (outerType == null) { return(null); } outerTypeInfo = outerType; // Since we got to outerType via a metadata reference, we're assured GetTypeInfo() won't throw a MissingMetadataException. } if (outerTypeInfo != null) { // It was a nested type. We've already resolved the containing type recursively - just find the nested among its direct children. TypeInfo?resolvedTypeInfo = outerTypeInfo.GetDeclaredNestedType(name); if (resolvedTypeInfo == null) { exception = ReflectionCoreExecution.ExecutionDomain.CreateMissingMetadataException(outerTypeInfo, name); return(null); } return(resolvedTypeInfo.CastToRuntimeTypeInfo()); } // If we got here, the typeReference was to a non-nested type. if (parentType == HandleType.NamespaceReference) { NamespaceReferenceHandle namespaceReferenceHandle = parent.ToNamespaceReferenceHandle(reader); string fullName = namespaceReferenceHandle.ToFullyQualifiedTypeName(name, reader); Handle parentHandleToSearch = parent; while (parentHandleToSearch.HandleType != HandleType.ScopeReference) { parentHandleToSearch = parentHandleToSearch.ToNamespaceReferenceHandle(reader).GetNamespaceReference(reader).ParentScopeOrNamespace; } ScopeReferenceHandle scopeReferenceHandle = parentHandleToSearch.ToScopeReferenceHandle(reader); RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader); RuntimeAssemblyInfo runtimeAssembly; exception = RuntimeAssemblyInfo.TryGetRuntimeAssembly(assemblyName, out runtimeAssembly); if (exception != null) { return(null); } RuntimeTypeInfo runtimeType = runtimeAssembly.GetTypeCore(fullName, ignoreCase: false); if (runtimeType == null) { exception = Helpers.CreateTypeLoadException(fullName, assemblyName.FullName); return(null); } return(runtimeType); } throw new BadImageFormatException(); // Expected TypeReference parent to be typeRef, typeDef or namespaceRef. }
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, bool cacheMissedLookups, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool resultBoolean);
public AssemblyQualifiedTypeName(NonQualifiedTypeName typeName, RuntimeAssemblyName assemblyName) { Debug.Assert(typeName != null); TypeName = typeName; AssemblyName = assemblyName; }
public PEInfo(RuntimeAssemblyName name, MetadataReader reader, PEReader pe) { Name = name; Reader = reader; PE = pe; }