|
static private FromAssembly ( Assembly assembly ) : |
||
| assembly | Assembly | |
| return | ||
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);
}
