internal virtual TypeWrapper GetWrapperFromAssemblyType(Type type) { //Tracer.Info(Tracer.Runtime, "GetWrapperFromAssemblyType: {0}", type.FullName); Debug.Assert(!type.Name.EndsWith("[]"), "!type.IsArray", type.FullName); Debug.Assert(AssemblyClassLoader.FromAssembly(type.Assembly) == this); TypeWrapper wrapper = GetLoader(type.Assembly).CreateWrapperForAssemblyType(type); if (wrapper != null) { if (type.IsGenericType && !type.IsGenericTypeDefinition) { // in the case of "magic" implementation generic type instances we'll end up here as well, // but then wrapper.GetClassLoader() will return this anyway wrapper = wrapper.GetClassLoader().RegisterInitiatingLoader(wrapper); } else { wrapper = RegisterInitiatingLoader(wrapper); } if (wrapper.TypeAsTBD != type && (!wrapper.IsRemapped || wrapper.TypeAsBaseType != type)) { // this really shouldn't happen, it means that we have two different types in our assembly that both // have the same Java name #if STATIC_COMPILER throw new FatalCompilerErrorException(Message.AssemblyContainsDuplicateClassNames, type.FullName, wrapper.TypeAsTBD.FullName, wrapper.Name, type.Assembly.FullName); #else string msg = String.Format("\nType \"{0}\" and \"{1}\" both map to the same name \"{2}\".\n", type.FullName, wrapper.TypeAsTBD.FullName, wrapper.Name); JVM.CriticalFailure(msg, null); #endif } return(wrapper); } return(null); }
internal TypeWrapper LoadReferenced(string name) { LazyInitExports(); for (int i = 0; i < delegates.Length; i++) { if (delegates[i] == null) { Assembly asm = LoadAssemblyOrClearName(ref references[i], false); if (asm != null) { delegates[i] = AssemblyClassLoader.FromAssembly(asm); } } if (delegates[i] != null) { TypeWrapper tw = delegates[i].DoLoad(name); if (tw != null) { return(tw); } } } if (!assemblyLoader.HasJavaModule) { return(GetBootstrapClassLoader().LoadClassByDottedNameFast(name)); } return(null); }
internal static ClassLoaderWrapper GetAssemblyClassLoaderByName(string name) { if (name.StartsWith("[[")) { return(GetGenericClassLoaderByName(name)); } #if STATIC_COMPILER || STUB_GENERATOR return(AssemblyClassLoader.FromAssembly(StaticCompiler.Load(name))); #else return(AssemblyClassLoader.FromAssembly(Assembly.Load(name))); #endif }
internal override VfsEntry GetEntry(int index, string[] path) { if (path[path.Length - 1].EndsWith(".class", StringComparison.Ordinal)) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); for (int i = index; i < path.Length - 1; i++) { sb.Append(path[i]).Append('.'); } sb.Append(path[path.Length - 1], 0, path[path.Length - 1].Length - 6); string className = sb.ToString(); VfsEntry entry; lock (classes) { if (classes.TryGetValue(className, out entry)) { return(entry); } } AssemblyClassLoader acl = AssemblyClassLoader.FromAssembly(asm); TypeWrapper tw = null; try { tw = acl.LoadClassByDottedNameFast(className); } catch { } if (tw != null && !tw.IsArray) { lock (classes) { if (!classes.TryGetValue(className, out entry)) { entry = new VfsAssemblyClass(tw); classes.Add(className, entry); } } return(entry); } return(null); } else { Populate(); return(base.GetEntry(index, path)); } }
internal static ClassLoaderWrapper GetGenericClassLoader(TypeWrapper wrapper) { Type type = wrapper.TypeAsTBD; Debug.Assert(type.IsGenericType); Debug.Assert(!type.ContainsGenericParameters); List <ClassLoaderWrapper> list = new List <ClassLoaderWrapper>(); list.Add(AssemblyClassLoader.FromAssembly(type.Assembly)); foreach (Type arg in type.GetGenericArguments()) { ClassLoaderWrapper loader = GetWrapperFromType(arg).GetClassLoader(); if (!list.Contains(loader) && loader != bootstrapClassLoader) { list.Add(loader); } } ClassLoaderWrapper[] key = list.ToArray(); ClassLoaderWrapper matchingLoader = GetGenericClassLoaderByKey(key); matchingLoader.RegisterInitiatingLoader(wrapper); return(matchingLoader); }
private IEnumerable <java.net.URL> GetResourcesImpl(string unmangledName, bool getFromDelegates) { if (ReflectUtil.IsDynamicAssembly(assemblyLoader.Assembly)) { yield break; } #if !FIRST_PASS java.util.Enumeration urls = assemblyLoader.FindResources(unmangledName); while (urls.hasMoreElements()) { yield return((java.net.URL)urls.nextElement()); } #endif string name = JVM.MangleResourceName(unmangledName); if (assemblyLoader.Assembly.GetManifestResourceInfo(name) != null) { yield return(MakeResourceURL(assemblyLoader.Assembly, name)); } LazyInitExports(); if (exports != null) { List <int> assemblies; if (exports.TryGetValue(JVM.PersistableHash(unmangledName), out assemblies)) { foreach (int index in assemblies) { AssemblyLoader loader = exportedAssemblies[index]; if (loader == null) { Assembly asm = LoadAssemblyOrClearName(ref exportedAssemblyNames[index], true); if (asm == null) { continue; } loader = exportedAssemblies[index] = GetLoaderForExportedAssembly(asm); } #if !FIRST_PASS urls = loader.FindResources(unmangledName); while (urls.hasMoreElements()) { yield return((java.net.URL)urls.nextElement()); } #endif if (loader.Assembly.GetManifestResourceInfo(name) != null) { yield return(MakeResourceURL(loader.Assembly, name)); } } } } if (!getFromDelegates) { yield break; } for (int i = 0; i < delegates.Length; i++) { if (delegates[i] == null) { Assembly asm = LoadAssemblyOrClearName(ref references[i], false); if (asm != null) { delegates[i] = AssemblyClassLoader.FromAssembly(asm); } } if (delegates[i] != null) { foreach (java.net.URL url in delegates[i].FindResources(unmangledName)) { yield return(url); } } } if (!assemblyLoader.HasJavaModule) { foreach (java.net.URL url in GetBootstrapClassLoader().FindResources(unmangledName)) { yield return(url); } } }
public static global::java.lang.ClassLoader getAssemblyClassLoader(Assembly asm) { // note that we don't do a security check here, because if you have the Assembly object, // you can already get at all the types in it. return(AssemblyClassLoader_.FromAssembly(asm).GetJavaClassLoader()); }
private void Populate() { bool populate; lock (entries) { populate = entries.Count == 0; } if (populate) { Dictionary <string, string> names = new Dictionary <string, string>(); AssemblyClassLoader acl = AssemblyClassLoader.FromAssembly(this.asm); foreach (Assembly asm in acl.GetAllAvailableAssemblies()) { Type[] types; try { types = asm.GetTypes(); } catch (ReflectionTypeLoadException x) { types = x.Types; } catch { types = Type.EmptyTypes; } foreach (Type type in types) { if (type != null) { string name = null; try { bool isJavaType; name = acl.GetTypeNameAndType(type, out isJavaType); #if !FIRST_PASS // annotation custom attributes are pseudo proxies and are not loadable by name (and should not exist in the file systems, // because proxies are, ostensibly, created on the fly) if (isJavaType && type.BaseType == typeof(global::[email protected]) && name.Contains(".$Proxy")) { name = null; } #endif } catch { } if (name != null) { names[name] = name; } } } } lock (entries) { if (entries.Count == 0) { foreach (string name in names.Keys) { string[] parts = name.Split('.'); VfsDirectory dir = this; for (int i = 0; i < parts.Length - 1; i++) { dir = dir.GetEntry(parts[i]) as VfsDirectory ?? dir.AddDirectory(parts[i]); } // we're adding a dummy file, to make the file appear in the directory listing, it will not actually // be accessed, because the code above handles that dir.Add(parts[parts.Length - 1] + ".class", VfsDummyFile.Instance); } } } } }
internal Assembly[] FindResourceAssemblies(string unmangledName, bool firstOnly) { List <Assembly> list = null; string name = JVM.MangleResourceName(unmangledName); Assembly first = FindResourceAssembliesImpl(unmangledName, name, firstOnly, ref list); if (first != null) { return(new Assembly[] { first }); } LazyInitExports(); for (int i = 0; i < delegates.Length; i++) { if (delegates[i] == null) { Assembly asm = LoadAssemblyOrClearName(ref references[i], false); if (asm != null) { delegates[i] = AssemblyClassLoader.FromAssembly(asm); } } if (delegates[i] != null) { first = delegates[i].FindResourceAssembliesImpl(unmangledName, name, firstOnly, ref list); if (first != null) { return(new Assembly[] { first }); } } } if (!assemblyLoader.HasJavaModule) { if (firstOnly) { return(GetBootstrapClassLoader().FindResourceAssemblies(unmangledName, firstOnly)); } else { Assembly[] assemblies = GetBootstrapClassLoader().FindResourceAssemblies(unmangledName, firstOnly); if (assemblies != null) { foreach (Assembly asm in assemblies) { if (list == null) { list = new List <Assembly>(); } if (!list.Contains(asm)) { list.Add(asm); } } } } } if (list == null) { return(null); } return(list.ToArray()); }
internal static TypeWrapper GetWrapperFromType(Type type) { //Tracer.Info(Tracer.Runtime, "GetWrapperFromType: {0}", type.AssemblyQualifiedName); #if !STATIC_COMPILER TypeWrapper.AssertFinished(type); #endif Debug.Assert(!type.IsPointer); Debug.Assert(!type.IsByRef); TypeWrapper wrapper; lock (globalTypeToTypeWrapper) { globalTypeToTypeWrapper.TryGetValue(type, out wrapper); } if (wrapper != null) { return(wrapper); } string remapped; if (remappedTypes.TryGetValue(type, out remapped)) { wrapper = LoadClassCritical(remapped); } else if (ReflectUtil.IsVector(type)) { // it might be an array of a dynamically compiled Java type int rank = 1; Type elem = type.GetElementType(); while (ReflectUtil.IsVector(elem)) { rank++; elem = elem.GetElementType(); } wrapper = GetWrapperFromType(elem).MakeArrayType(rank); } else { Assembly asm = type.Assembly; #if CLASSGC ClassLoaderWrapper loader; if (dynamicAssemblies != null && dynamicAssemblies.TryGetValue(asm, out loader)) { lock (loader.typeToTypeWrapper) { return(loader.typeToTypeWrapper[type]); } } #endif #if !STATIC_COMPILER && !STUB_GENERATOR if (ReflectUtil.IsReflectionOnly(type)) { // historically we've always returned null for types that don't have a corresponding TypeWrapper (or java.lang.Class) return(null); } #endif // if the wrapper doesn't already exist, that must mean that the type // is a .NET type (or a pre-compiled Java class), which means that it // was "loaded" by an assembly classloader wrapper = AssemblyClassLoader.FromAssembly(asm).GetWrapperFromAssemblyType(type); } #if CLASSGC if (type.Assembly.IsDynamic) { // don't cache types in dynamic assemblies, because they might live in a RunAndCollect assembly // TODO we also shouldn't cache generic type instances that have a GCable type parameter return(wrapper); } #endif lock (globalTypeToTypeWrapper) { globalTypeToTypeWrapper[type] = wrapper; } return(wrapper); }