private static TypeWrapper GetWrapper(TypeWrapper primitive) { Debug.Assert(primitive.IsPrimitive); switch (primitive.SigName[0]) { case 'Z': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Boolean")); case 'B': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Byte")); case 'S': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Short")); case 'C': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Character")); case 'I': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Integer")); case 'J': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Long")); case 'F': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Float")); case 'D': return(ClassLoaderWrapper.LoadClassCritical("java.lang.Double")); default: throw new InvalidOperationException(); } }
internal override bool InternalsVisibleToImpl(TypeWrapper wrapper, TypeWrapper friend) { ClassLoaderWrapper other = friend.GetClassLoader(); if (this == other) { return(true); } AssemblyName otherName; #if STATIC_COMPILER CompilerClassLoader ccl = other as CompilerClassLoader; if (ccl == null) { return(false); } otherName = ccl.GetAssemblyName(); #else AssemblyClassLoader acl = other as AssemblyClassLoader; if (acl == null) { return(false); } otherName = acl.GetAssembly(friend).GetName(); #endif return(GetLoaderForExportedAssembly(GetAssembly(wrapper)).InternalsVisibleTo(otherName)); }
internal static DynamicClassLoader Get(ClassLoaderWrapper loader) { #if STATIC_COMPILER return(new DynamicClassLoader(((CompilerClassLoader)loader).CreateModuleBuilder(), false)); #else AssemblyClassLoader acl = loader as AssemblyClassLoader; if (acl != null && ForgedKeyPair.Instance != null) { string name = acl.MainAssembly.GetName().Name + DynamicAssemblySuffixAndPublicKey; foreach (InternalsVisibleToAttribute attr in acl.MainAssembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), false)) { if (attr.AssemblyName == name) { AssemblyName n = new AssemblyName(name); n.KeyPair = ForgedKeyPair.Instance; return(new DynamicClassLoader(CreateModuleBuilder(n), true)); } } } #if CLASSGC DynamicClassLoader instance = new DynamicClassLoader(CreateModuleBuilder(), false); #endif return(instance); #endif }
internal static void AddGetObjectData(TypeBuilder tb) { string name = tb.IsSealed ? "System.Runtime.Serialization.ISerializable.GetObjectData" : "GetObjectData"; MethodAttributes attr = tb.IsSealed ? MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final : MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride; tb.AddInterfaceImplementation(JVM.Import(typeof(ISerializable))); MethodBuilder getObjectData = tb.DefineMethod(name, attr, null, new Type[] { JVM.Import(typeof(SerializationInfo)), JVM.Import(typeof(StreamingContext)) }); getObjectData.SetCustomAttribute(securityCriticalAttribute); AttributeHelper.HideFromJava(getObjectData); // AddDeclarativeSecurity does not exist in .net core #if NETFRAMEWORK getObjectData.AddDeclarativeSecurity(SecurityAction.Demand, psetSerializationFormatter); #endif tb.DefineMethodOverride(getObjectData, JVM.Import(typeof(ISerializable)).GetMethod("GetObjectData")); CodeEmitter ilgen = CodeEmitter.Create(getObjectData); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Ldarg_1); TypeWrapper serializationHelper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.Serialization"); MethodWrapper mw = serializationHelper.GetMethodWrapper("writeObject", "(Ljava.lang.Object;Lcli.System.Runtime.Serialization.SerializationInfo;)V", false); mw.Link(); mw.EmitCall(ilgen); ilgen.Emit(OpCodes.Ret); ilgen.DoEmit(); }
private static MethodBuilder AddConstructor(TypeBuilder tb, MethodWrapper defaultConstructor, MethodBase serializationConstructor, bool callReadObject) { MethodBuilder ctor = ReflectUtil.DefineConstructor(tb, MethodAttributes.Family, new Type[] { JVM.Import(typeof(SerializationInfo)), JVM.Import(typeof(StreamingContext)) }); AttributeHelper.HideFromJava(ctor); // AddDeclarativeSecurity does not exist in .net core #if NETFRAMEWORK ctor.AddDeclarativeSecurity(SecurityAction.Demand, psetSerializationFormatter); #endif CodeEmitter ilgen = CodeEmitter.Create(ctor); ilgen.Emit(OpCodes.Ldarg_0); if (defaultConstructor != null) { defaultConstructor.EmitCall(ilgen); } else { ilgen.Emit(OpCodes.Ldarg_1); ilgen.Emit(OpCodes.Ldarg_2); ilgen.Emit(OpCodes.Call, serializationConstructor); } if (callReadObject) { ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Ldarg_1); TypeWrapper serializationHelper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.Serialization"); MethodWrapper mw = serializationHelper.GetMethodWrapper("readObject", "(Ljava.lang.Object;Lcli.System.Runtime.Serialization.SerializationInfo;)V", false); mw.Link(); mw.EmitCall(ilgen); } ilgen.Emit(OpCodes.Ret); ilgen.DoEmit(); return(ctor); }
private static ConstructorBuilder DefineThreadLocalType(DynamicTypeWrapper.FinishContext context, int opcodeIndex, MethodWrapper caller) { TypeWrapper threadLocal = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.IntrinsicThreadLocal"); TypeBuilder tb = caller.DeclaringType.TypeAsBuilder.DefineNestedType("__<tls>_" + opcodeIndex, TypeAttributes.NestedPrivate | TypeAttributes.Sealed, threadLocal.TypeAsBaseType); FieldBuilder fb = tb.DefineField("field", Types.Object, FieldAttributes.Private | FieldAttributes.Static); fb.SetCustomAttribute(new CustomAttributeBuilder(JVM.Import(typeof(ThreadStaticAttribute)).GetConstructor(Type.EmptyTypes), new object[0])); MethodBuilder mbGet = tb.DefineMethod("get", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final, Types.Object, Type.EmptyTypes); ILGenerator ilgen = mbGet.GetILGenerator(); ilgen.Emit(OpCodes.Ldsfld, fb); ilgen.Emit(OpCodes.Ret); MethodBuilder mbSet = tb.DefineMethod("set", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final, null, new Type[] { Types.Object }); ilgen = mbSet.GetILGenerator(); ilgen.Emit(OpCodes.Ldarg_1); ilgen.Emit(OpCodes.Stsfld, fb); ilgen.Emit(OpCodes.Ret); ConstructorBuilder cb = tb.DefineConstructor(MethodAttributes.Assembly, CallingConventions.Standard, Type.EmptyTypes); CodeEmitter ctorilgen = CodeEmitter.Create(cb); ctorilgen.Emit(OpCodes.Ldarg_0); MethodWrapper basector = threadLocal.GetMethodWrapper("<init>", "()V", false); basector.Link(); basector.EmitCall(ctorilgen); ctorilgen.Emit(OpCodes.Ret); context.RegisterPostFinishProc(delegate { threadLocal.Finish(); tb.CreateType(); }); return(cb); }
static ProxyGenerator() { ClassLoaderWrapper bootClassLoader = ClassLoaderWrapper.GetBootstrapClassLoader(); proxyClass = bootClassLoader.LoadClassByDottedNameFast("java.lang.reflect.Proxy"); errorClass = bootClassLoader.LoadClassByDottedNameFast("java.lang.Error"); runtimeExceptionClass = bootClassLoader.LoadClassByDottedNameFast("java.lang.RuntimeException"); undeclaredThrowableExceptionConstructor = bootClassLoader.LoadClassByDottedNameFast("java.lang.reflect.UndeclaredThrowableException").GetMethodWrapper("<init>", "(Ljava.lang.Throwable;)V", false); undeclaredThrowableExceptionConstructor.Link(); invocationHandlerField = proxyClass.GetFieldWrapper("h", "Ljava.lang.reflect.InvocationHandler;"); invocationHandlerField.Link(); javaLangReflectMethod = bootClassLoader.LoadClassByDottedNameFast("java.lang.reflect.Method"); javaLangNoSuchMethodException = bootClassLoader.LoadClassByDottedNameFast("java.lang.NoSuchMethodException"); javaLangNoClassDefFoundErrorConstructor = bootClassLoader.LoadClassByDottedNameFast("java.lang.NoClassDefFoundError").GetMethodWrapper("<init>", "(Ljava.lang.String;)V", false); javaLangNoClassDefFoundErrorConstructor.Link(); javaLangThrowable_getMessage = bootClassLoader.LoadClassByDottedNameFast("java.lang.Throwable").GetMethodWrapper("getMessage", "()Ljava.lang.String;", false); javaLangThrowable_getMessage.Link(); javaLangClass_getMethod = CoreClasses.java.lang.Class.Wrapper.GetMethodWrapper("getMethod", "(Ljava.lang.String;[Ljava.lang.Class;)Ljava.lang.reflect.Method;", false); javaLangClass_getMethod.Link(); invocationHandlerClass = bootClassLoader.LoadClassByDottedNameFast("java.lang.reflect.InvocationHandler"); invokeMethod = invocationHandlerClass.GetMethodWrapper("invoke", "(Ljava.lang.Object;Ljava.lang.reflect.Method;[Ljava.lang.Object;)Ljava.lang.Object;", false); proxyConstructor = proxyClass.GetMethodWrapper("<init>", "(Ljava.lang.reflect.InvocationHandler;)V", false); proxyConstructor.Link(); hashCodeMethod = CoreClasses.java.lang.Object.Wrapper.GetMethodWrapper("hashCode", "()I", false); equalsMethod = CoreClasses.java.lang.Object.Wrapper.GetMethodWrapper("equals", "(Ljava.lang.Object;)Z", false); toStringMethod = CoreClasses.java.lang.Object.Wrapper.GetMethodWrapper("toString", "()Ljava.lang.String;", false); }
private static AssemblyClassLoader Create(Assembly assembly) { // If the assembly is a part of a multi-assembly shared class loader, // it will export the __<MainAssembly> type from the main assembly in the group. Type forwarder = assembly.GetType("__<MainAssembly>"); if (forwarder != null) { Assembly mainAssembly = forwarder.Assembly; if (mainAssembly != assembly) { return(FromAssembly(mainAssembly)); } } #if STATIC_COMPILER if (JVM.CoreAssembly == null && CompilerClassLoader.IsCoreAssembly(assembly)) { JVM.CoreAssembly = assembly; ClassLoaderWrapper.LoadRemappedTypes(); } #endif if (assembly == JVM.CoreAssembly) { // This cast is necessary for ikvmc and a no-op for the runtime. // Note that the cast cannot fail, because ikvmc will only return a non AssemblyClassLoader // from GetBootstrapClassLoader() when compiling the core assembly and in that case JVM.CoreAssembly // will be null. return((AssemblyClassLoader)GetBootstrapClassLoader()); } return(new AssemblyClassLoader(assembly)); }
internal static int GetGenericClassLoaderId(ClassLoaderWrapper wrapper) { lock (wrapperLock) { return(genericClassLoaders.IndexOf(wrapper as GenericClassLoader)); } }
private static Assembly OnTypeResolve(object sender, ResolveEventArgs args) { TypeWrapper type; #if CLASSGC DynamicClassLoader instance; ClassLoaderWrapper loader = ClassLoaderWrapper.GetClassLoaderForDynamicJavaAssembly(args.RequestingAssembly); if (loader == null) { return(null); } instance = (DynamicClassLoader)loader.GetTypeWrapperFactory(); #endif instance.dynamicTypes.TryGetValue(args.Name, out type); if (type == null) { return(null); } try { type.Finish(); } catch (RetargetableJavaException x) { throw x.ToJava(); } // NOTE We used to remove the type from the hashtable here, but that creates a race condition if // another thread also fires the OnTypeResolve event while we're baking the type. // I really would like to remove the type from the hashtable, but at the moment I don't see // any way of doing that that wouldn't cause this race condition. // UPDATE since we now also use the dynamicTypes hashtable to keep track of type names that // have been used already, we cannot remove the keys. return(type.TypeAsTBD.Assembly); }
private static void CreateEnumEnum(ModuleBuilder modb, ClassLoaderWrapper loader) { TypeBuilder tb = modb.DefineType(DotNetTypeWrapper.GenericEnumEnumTypeName, TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public); GenericTypeParameterBuilder gtpb = tb.DefineGenericParameters("T")[0]; gtpb.SetBaseTypeConstraint(Types.Enum); genericEnumEnumType = tb; }
internal TypeWrapper DefineClass(ClassFile f, object protectionDomain) { #if NOEMIT throw new InvalidOperationException(); #else string dotnetAssembly = f.IKVMAssemblyAttribute; if (dotnetAssembly != null) { // It's a stub class generated by ikvmstub (or generated by the runtime when getResource was // called on a statically compiled class). ClassLoaderWrapper loader; try { loader = ClassLoaderWrapper.GetAssemblyClassLoaderByName(dotnetAssembly); } catch (Exception x) { // TODO don't catch all exceptions here throw new NoClassDefFoundError(f.Name + " (" + x.Message + ")"); } TypeWrapper tw = loader.LoadClassByDottedNameFast(f.Name); if (tw == null) { throw new NoClassDefFoundError(f.Name + " (type not found in " + dotnetAssembly + ")"); } return(RegisterInitiatingLoader(tw)); } CheckDefineClassAllowed(f.Name); lock (types) { if (types.ContainsKey(f.Name)) { throw new LinkageError("duplicate class definition: " + f.Name); } // mark the type as "loading in progress", so that we can detect circular dependencies. types.Add(f.Name, null); defineClassInProgress.Add(f.Name, Thread.CurrentThread); } try { return(GetTypeWrapperFactory().DefineClassImpl(types, f, this, protectionDomain)); } finally { lock (types) { if (types[f.Name] == null) { // if loading the class fails, we remove the indicator that we're busy loading the class, // because otherwise we get a ClassCircularityError if we try to load the class again. types.Remove(f.Name); } defineClassInProgress.Remove(f.Name); Monitor.PulseAll(types); } } }
internal void EmitThrow(string dottedClassName) { TypeWrapper exception = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(dottedClassName); MethodWrapper mw = exception.GetMethodWrapper("<init>", "()V", false); mw.Link(); mw.EmitNewobj(this); Emit(OpCodes.Throw); }
private static void EmitUnboxNumber(CodeEmitter ilgen, string methodName, string methodSig) { TypeWrapper tw = ClassLoaderWrapper.LoadClassCritical("java.lang.Number"); tw.EmitCheckcast(ilgen); MethodWrapper mw = tw.GetMethodWrapper(methodName, methodSig, false); mw.Link(); mw.EmitCallvirt(ilgen); }
protected static void SetWrapperForClassLoader(object javaClassLoader, ClassLoaderWrapper wrapper) { #if !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR #if __MonoCS__ SetClassLoadWrapperHack(ref ((java.lang.ClassLoader)javaClassLoader).wrapper, wrapper); #else ((java.lang.ClassLoader)javaClassLoader).wrapper = wrapper; #endif #endif }
protected static void SetWrapperForClassLoader(object javaClassLoader, ClassLoaderWrapper wrapper) { #if !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR #if __MonoCS__ typeof(java.lang.ClassLoader).GetField("wrapper", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(javaClassLoader, wrapper); #else ((java.lang.ClassLoader)javaClassLoader).wrapper = wrapper; #endif #endif }
internal static void Create(ModuleBuilder modb, ClassLoaderWrapper loader) { TypeBuilder tb = modb.DefineType(DotNetTypeWrapper.GenericDelegateInterfaceTypeName, TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.Public); tb.DefineGenericParameters("T")[0].SetBaseTypeConstraint(Types.MulticastDelegate); genericDelegateInterfaceType = tb.CreateType(); genericAttributeAnnotationType = CreateAnnotationType(modb, DotNetTypeWrapper.GenericAttributeAnnotationTypeName); genericAttributeAnnotationMultipleType = CreateAnnotationType(modb, DotNetTypeWrapper.GenericAttributeAnnotationMultipleTypeName); genericAttributeAnnotationReturnValueType = CreateAnnotationType(modb, DotNetTypeWrapper.GenericAttributeAnnotationReturnValueTypeName); CreateEnumEnum(modb, loader); }
internal static AssemblyClassLoader GetBootstrapClassLoader() #endif { lock (wrapperLock) { if (bootstrapClassLoader == null) { bootstrapClassLoader = new BootstrapClassLoader(); } return(bootstrapClassLoader); } }
internal static TypeWrapper LoadClassNoThrow(ClassLoaderWrapper classLoader, string name) { try { TypeWrapper wrapper = classLoader.LoadClassByDottedNameFast(name); if (wrapper == null) { string elementTypeName = name; if (elementTypeName.StartsWith("[")) { int skip = 1; while (elementTypeName[skip++] == '[') { ; } elementTypeName = elementTypeName.Substring(skip, elementTypeName.Length - skip - 1); } #if STATIC_COMPILER classLoader.IssueMessage(Message.ClassNotFound, elementTypeName); #else Tracer.Error(Tracer.ClassLoading, "Class not found: {0}", elementTypeName); #endif wrapper = new UnloadableTypeWrapper(name); } return(wrapper); } catch (RetargetableJavaException x) { // HACK keep the compiler from warning about unused local GC.KeepAlive(x); #if !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR && !NOEMIT if (Tracer.ClassLoading.TraceError) { java.lang.ClassLoader cl = (java.lang.ClassLoader)classLoader.GetJavaClassLoader(); if (cl != null) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); string sep = ""; while (cl != null) { sb.Append(sep).Append(cl); sep = " -> "; cl = cl.getParent(); } Tracer.Error(Tracer.ClassLoading, "ClassLoader chain: {0}", sb); } Exception m = ikvm.runtime.Util.mapException(x.ToJava()); Tracer.Error(Tracer.ClassLoading, m.ToString() + Environment.NewLine + m.StackTrace); } #endif // !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR return(new UnloadableTypeWrapper(name)); } }
private static TypeWrapper[] LoadTypes(ClassLoaderWrapper loader, string[] classes) { if (classes == null || classes.Length == 0) { return(TypeWrapper.EmptyArray); } TypeWrapper[] tw = new TypeWrapper[classes.Length]; for (int i = 0; i < tw.Length; i++) { tw[i] = loader.LoadClassByDottedName(classes[i]); } return(tw); }
internal static DynamicClassLoader Get(ClassLoaderWrapper loader) { #if STATIC_COMPILER DynamicClassLoader instance = new DynamicClassLoader(((CompilerClassLoader)loader).CreateModuleBuilder()); #elif CLASSGC DynamicClassLoader instance = new DynamicClassLoader(CreateModuleBuilder()); if (saveClassLoaders != null) { saveClassLoaders.Add(instance); } #endif return(instance); }
private static string GetFileName(StackFrame frame) { MethodBase mb = frame.GetMethod(); if (mb != null) { TypeWrapper tw = ClassLoaderWrapper.GetWrapperFromType(mb.DeclaringType); if (tw != null) { return(tw.GetSourceFileName()); } } return(null); }
private static Assembly OnTypeResolve(object sender, ResolveEventArgs args) { #if CLASSGC ClassLoaderWrapper loader = ClassLoaderWrapper.GetClassLoaderForDynamicJavaAssembly(args.RequestingAssembly); if (loader == null) { return(null); } DynamicClassLoader instance = (DynamicClassLoader)loader.GetTypeWrapperFactory(); return(Resolve(instance.dynamicTypes, args.Name)); #else return(Resolve(dynamicTypes, args.Name)); #endif }
internal static void Finish(ClassLoaderWrapper loader) { TypeBuilder tb = (TypeBuilder)genericEnumEnumType; TypeWrapper enumTypeWrapper = loader.LoadClassByDottedName("java.lang.Enum"); enumTypeWrapper.Finish(); tb.SetParent(enumTypeWrapper.TypeAsBaseType); CodeEmitter ilgen = CodeEmitter.Create(ReflectUtil.DefineConstructor(tb, MethodAttributes.Private, new Type[] { Types.String, Types.Int32 })); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Ldarg_1); ilgen.Emit(OpCodes.Ldarg_2); enumTypeWrapper.GetMethodWrapper("<init>", "(Ljava.lang.String;I)V", false).EmitCall(ilgen); ilgen.Emit(OpCodes.Ret); ilgen.DoEmit(); genericEnumEnumType = tb.CreateType(); }
static Boxer() { ClassLoaderWrapper bootClassLoader = ClassLoaderWrapper.GetBootstrapClassLoader(); javaLangByte = bootClassLoader.LoadClassByDottedNameFast("java.lang.Byte"); byteValue = javaLangByte.GetMethodWrapper("byteValue", "()B", false); byteValue.Link(); valueOfByte = javaLangByte.GetMethodWrapper("valueOf", "(B)Ljava.lang.Byte;", false); valueOfByte.Link(); javaLangBoolean = bootClassLoader.LoadClassByDottedNameFast("java.lang.Boolean"); booleanValue = javaLangBoolean.GetMethodWrapper("booleanValue", "()Z", false); booleanValue.Link(); valueOfBoolean = javaLangBoolean.GetMethodWrapper("valueOf", "(Z)Ljava.lang.Boolean;", false); valueOfBoolean.Link(); javaLangShort = bootClassLoader.LoadClassByDottedNameFast("java.lang.Short"); shortValue = javaLangShort.GetMethodWrapper("shortValue", "()S", false); shortValue.Link(); valueOfShort = javaLangShort.GetMethodWrapper("valueOf", "(S)Ljava.lang.Short;", false); valueOfShort.Link(); javaLangCharacter = bootClassLoader.LoadClassByDottedNameFast("java.lang.Character"); charValue = javaLangCharacter.GetMethodWrapper("charValue", "()C", false); charValue.Link(); valueOfCharacter = javaLangCharacter.GetMethodWrapper("valueOf", "(C)Ljava.lang.Character;", false); valueOfCharacter.Link(); javaLangInteger = bootClassLoader.LoadClassByDottedNameFast("java.lang.Integer"); intValue = javaLangInteger.GetMethodWrapper("intValue", "()I", false); intValue.Link(); valueOfInteger = javaLangInteger.GetMethodWrapper("valueOf", "(I)Ljava.lang.Integer;", false); valueOfInteger.Link(); javaLangFloat = bootClassLoader.LoadClassByDottedNameFast("java.lang.Float"); floatValue = javaLangFloat.GetMethodWrapper("floatValue", "()F", false); floatValue.Link(); valueOfFloat = javaLangFloat.GetMethodWrapper("valueOf", "(F)Ljava.lang.Float;", false); valueOfFloat.Link(); javaLangLong = bootClassLoader.LoadClassByDottedNameFast("java.lang.Long"); longValue = javaLangLong.GetMethodWrapper("longValue", "()J", false); longValue.Link(); valueOfLong = javaLangLong.GetMethodWrapper("valueOf", "(J)Ljava.lang.Long;", false); valueOfLong.Link(); javaLangDouble = bootClassLoader.LoadClassByDottedNameFast("java.lang.Double"); doubleValue = javaLangDouble.GetMethodWrapper("doubleValue", "()D", false); doubleValue.Link(); valueOfDouble = javaLangDouble.GetMethodWrapper("valueOf", "(D)Ljava.lang.Double;", false); valueOfDouble.Link(); }
private static void CreateEnumEnum(ModuleBuilder modb, ClassLoaderWrapper loader) { TypeWrapper enumTypeWrapper = loader.LoadClassByDottedName("java.lang.Enum"); enumTypeWrapper.Finish(); TypeBuilder tb = modb.DefineType(DotNetTypeWrapper.GenericEnumEnumTypeName, TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public, enumTypeWrapper.TypeAsBaseType); GenericTypeParameterBuilder gtpb = tb.DefineGenericParameters("T")[0]; gtpb.SetBaseTypeConstraint(Types.Enum); CodeEmitter ilgen = CodeEmitter.Create(tb.DefineConstructor(MethodAttributes.Private, CallingConventions.Standard, new Type[] { Types.String, Types.Int32 })); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Ldarg_1); ilgen.Emit(OpCodes.Ldarg_2); enumTypeWrapper.GetMethodWrapper("<init>", "(Ljava.lang.String;I)V", false).EmitCall(ilgen); ilgen.Emit(OpCodes.Ret); genericEnumEnumType = tb.CreateType(); }
private static int GetLineNumber(StackFrame frame) { int ilOffset = frame.GetILOffset(); if (ilOffset != StackFrame.OFFSET_UNKNOWN) { MethodBase mb = frame.GetMethod(); if (mb != null) { TypeWrapper tw = ClassLoaderWrapper.GetWrapperFromType(mb.DeclaringType); if (tw != null) { return(tw.GetSourceLineNumber(mb, ilOffset)); } } } return(-1); }
private static string getClassNameFromType(Type type) { if (ClassLoaderWrapper.IsRemappedType(type)) { return(DotNetTypeWrapper.GetName(type)); } TypeWrapper tw = ClassLoaderWrapper.GetWrapperFromType(type); if (tw != null) { if (tw.IsPrimitive) { return(DotNetTypeWrapper.GetName(type)); } return(tw.Name); } return(type.FullName); }
internal static ClassLoaderWrapper GetGenericClassLoaderByName(string name) { Debug.Assert(name.StartsWith("[[") && name.EndsWith("]]")); Stack <List <ClassLoaderWrapper> > stack = new Stack <List <ClassLoaderWrapper> >(); List <ClassLoaderWrapper> list = null; for (int i = 0; i < name.Length; i++) { if (name[i] == '[') { if (name[i + 1] == '[') { stack.Push(list); list = new List <ClassLoaderWrapper>(); if (name[i + 2] == '[') { i++; } } else { int start = i + 1; i = name.IndexOf(']', i); list.Add(ClassLoaderWrapper.GetAssemblyClassLoaderByName(name.Substring(start, i - start))); } } else if (name[i] == ']') { ClassLoaderWrapper loader = GetGenericClassLoaderByKey(list.ToArray()); list = stack.Pop(); if (list == null) { return(loader); } list.Add(loader); } else { throw new InvalidOperationException(); } } throw new InvalidOperationException(); }
internal static MethodBuilder DefineTypeInitializer(TypeBuilder typeBuilder, ClassLoaderWrapper loader) { MethodAttributes attr = MethodAttributes.Static | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName; if (typeBuilder.IsInterface && loader.WorkaroundInterfacePrivateMethods) { // LAMESPEC the ECMA spec says (part. I, sect. 8.5.3.2) that all interface members must be public, so we make // the class constructor public. // NOTE it turns out that on .NET 2.0 this isn't necessary anymore (neither Ref.Emit nor the CLR verifier complain about it), // but the C# compiler still considers interfaces with non-public methods to be invalid, so to keep interop with C# we have // to keep making the .cctor method public. attr |= MethodAttributes.Public; } else { attr |= MethodAttributes.Private; } return(typeBuilder.DefineMethod(ConstructorInfo.TypeConstructorName, attr, null, Type.EmptyTypes)); }