internal static bool Emit(DynamicTypeWrapper.FinishContext context, TypeWrapper wrapper, CodeEmitter ilgen, ClassFile classFile, int i, ClassFile.Method.Instruction[] code, InstructionFlags[] flags) { if (i >= 3 && (flags[i - 0] & InstructionFlags.BranchTarget) == 0 && (flags[i - 1] & InstructionFlags.BranchTarget) == 0 && (flags[i - 2] & InstructionFlags.BranchTarget) == 0 && (flags[i - 3] & InstructionFlags.BranchTarget) == 0 && code[i - 1].NormalizedOpCode == NormalizedByteCode.__ldc && code[i - 2].NormalizedOpCode == NormalizedByteCode.__ldc && code[i - 3].NormalizedOpCode == NormalizedByteCode.__ldc) { // we now have a structural match, now we need to make sure that the argument values are what we expect TypeWrapper tclass = classFile.GetConstantPoolClassType(code[i - 3].Arg1); TypeWrapper vclass = classFile.GetConstantPoolClassType(code[i - 2].Arg1); string fieldName = classFile.GetConstantPoolConstantString(code[i - 1].Arg1); if (tclass == wrapper && !vclass.IsUnloadable && !vclass.IsPrimitive && !vclass.IsNonPrimitiveValueType) { FieldWrapper field = wrapper.GetFieldWrapper(fieldName, vclass.SigName); if (field != null && !field.IsStatic && field.IsVolatile && field.DeclaringType == wrapper && field.FieldTypeWrapper == vclass) { // everything matches up, now call the actual emitter DoEmit(context, wrapper, ilgen, field); return true; } } } return false; }
private IList<Test> GetFixtures(Assembly assembly, IList names) { var fixtures = new List<Test>(); var testTypes = GetCandidateFixtureTypes(assembly, names); int testcases = 0; foreach (Type testType in testTypes) { var typeInfo = new TypeWrapper(testType); try { if (_unitySuiteBuilder.CanBuildFrom(typeInfo)) { Test fixture = _unitySuiteBuilder.BuildFrom(typeInfo); fixtures.Add(fixture); testcases += fixture.TestCaseCount; } } catch (Exception ex) { Debug.LogException(ex); } } return fixtures; }
internal static bool IsEnabled(TypeWrapper tw) { string className = tw.Name; // match class name for (OptionNode n = classes; n != null; n = n.next) { if (n.name == className) { return n.enabled; } } // match package name if (packages != null) { int len = className.Length; while (len > 0 && className[--len] != '.') ; do { for (OptionNode n = packages; n != null; n = n.next) { if (String.Compare(n.name, 0, className, 0, len, false, CultureInfo.InvariantCulture) == 0 && len == n.name.Length) { return n.enabled; } } while (len > 0 && className[--len] != '.') ; } while (len > 0); } return tw.GetClassLoader() == ClassLoaderWrapper.GetBootstrapClassLoader() ? sysAsserts : userAsserts; }
internal static ConstructorInfo AddAutomagicSerialization(TypeWrapper wrapper) { ConstructorInfo serializationCtor = null; if (wrapper.GetClassLoader().NoAutomagicSerialization) { // do nothing } else if ((wrapper.Modifiers & IKVM.Attributes.Modifiers.Enum) != 0) { MarkSerializable(wrapper); } else if (wrapper.IsSubTypeOf(serializable) && IsSafeForAutomagicSerialization(wrapper)) { if (wrapper.IsSubTypeOf(externalizable)) { MethodWrapper ctor = wrapper.GetMethodWrapper("<init>", "()V", false); if (ctor != null && ctor.IsPublic) { MarkSerializable(wrapper); ctor.Link(); serializationCtor = AddConstructor(wrapper.TypeAsBuilder, ctor, null, true); if (!wrapper.BaseTypeWrapper.IsSubTypeOf(serializable)) { AddGetObjectData(wrapper); } if (wrapper.BaseTypeWrapper.GetMethodWrapper("readResolve", "()Ljava.lang.Object;", true) != null) { RemoveReadResolve(wrapper); } } } else if (wrapper.BaseTypeWrapper.IsSubTypeOf(serializable)) { ConstructorInfo baseCtor = wrapper.GetBaseSerializationConstructor(); if (baseCtor != null && (baseCtor.IsFamily || baseCtor.IsFamilyOrAssembly)) { MarkSerializable(wrapper); serializationCtor = AddConstructor(wrapper.TypeAsBuilder, null, baseCtor, false); AddReadResolve(wrapper); } } else { MethodWrapper baseCtor = wrapper.BaseTypeWrapper.GetMethodWrapper("<init>", "()V", false); if (baseCtor != null && baseCtor.IsAccessibleFrom(wrapper.BaseTypeWrapper, wrapper, wrapper)) { MarkSerializable(wrapper); AddGetObjectData(wrapper); #if STATIC_COMPILER // because the base type can be a __WorkaroundBaseClass__, we may need to replace the constructor baseCtor = ((AotTypeWrapper)wrapper).ReplaceMethodWrapper(baseCtor); #endif baseCtor.Link(); serializationCtor = AddConstructor(wrapper.TypeAsBuilder, baseCtor, null, true); AddReadResolve(wrapper); } } } return serializationCtor; }
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); }
internal Meta(ScriptEngine engine, ModelInstance instance) : base(engine, engine.Object.InstancePrototype) { this.PopulateFunctions(); this.instance = instance; this.typeWrapper = new TypeWrapper(engine, instance.Type); }
private static bool HasJavaMethods(TypeWrapper tw) { foreach (MethodWrapper mw in tw.GetMethods()) { if (!mw.IsHideFromReflection && !mw.IsClassInitializer) { return true; } } return false; }
public void WriteTypeName(TypeWrapper type) { if (this._builder.Length > 0) this._builder.Append(" "); string typeName = type.GetDisplayName(false); if (typeName == "Void") typeName = "void"; WriteValue(typeName); }
private static bool HasJavaMethods(TypeWrapper tw) { foreach (MethodWrapper mw in tw.GetMethods()) { if (!mw.IsHideFromReflection && mw.Name != StringConstants.CLINIT) { return true; } } return false; }
public string GenerateSyntax(TypeWrapper type) { var syntax = new SyntaxWriter(this._version); if (type.IsPublic) syntax.WriteToken("public"); if (type.IsEnum) { syntax.WriteToken("enum"); syntax.WriteTypeName(type); } else { if (type.IsSealed) syntax.WriteToken("sealed"); if (type.IsAbstract) syntax.WriteToken("abstract"); if (type.IsStatic) syntax.WriteToken("static"); if (type.IsClass) syntax.WriteToken("class"); else if (type.IsInterface) syntax.WriteToken("interface"); else if (type.IsValueType) syntax.WriteToken("struct"); syntax.WriteTypeName(type); var baseType = type.BaseType; if (baseType != null) { syntax.WriteRaw(" :"); syntax.WriteTypeName(baseType); } var interfaces = type.GetInterfaces(); if (interfaces.Count > 0) { syntax.WriteNewLineWithTab(); syntax.BeginCommaDelimitedList(); foreach (var face in interfaces.OrderBy(x => x.Name)) { syntax.WriteTypeName(face); } syntax.EndCommaDelimitedList(); } } return syntax.CurrentSyntax; }
private static void WriteModifiers(BigEndianStream bes, TypeWrapper tw) { Modifiers mods = tw.ReflectiveModifiers & (Modifiers.Public | Modifiers.Final | Modifiers.Interface | Modifiers.Abstract); if ((mods & Modifiers.Interface) != 0) { mods &= ~Modifiers.Abstract; if (HasJavaMethods(tw)) { mods |= Modifiers.Abstract; } } bes.WriteUInt32((uint)mods); }
public void Test_ToStringShouldReturnTypeToString() { //---------------Set up test pack------------------- var type = MockRepository.GenerateMock<Type>(); var expectedToString = GetRandomString(); type.Stub(type1 => type1.ToString()).Return(expectedToString); TypeWrapper wrapper = new TypeWrapper(type); //---------------Assert Precondition---------------- Assert.AreEqual(expectedToString, type.ToString()); //---------------Execute Test ---------------------- var toString = wrapper.ToString(); //---------------Test Result ----------------------- Assert.AreEqual(expectedToString, toString); }
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(); }
internal static long Compute(TypeWrapper tw) { MemoryStream mem = new MemoryStream(); BigEndianStream bes = new BigEndianStream(mem); WriteClassName(bes, tw); WriteModifiers(bes, tw); WriteInterfaces(bes, tw); WriteFields(bes, tw); WriteStaticInitializer(bes, tw); WriteConstructors(bes, tw); WriteMethods(bes, tw); byte[] buf = sha1.ComputeHash(mem.ToArray()); long hash = 0; for (int i = 7; i >= 0; i--) { hash <<= 8; hash |= buf[i]; } return hash; }
internal static void Create(CompilerClassLoader loader, string proxy) { string[] interfaces = proxy.Split(','); TypeWrapper[] wrappers = new TypeWrapper[interfaces.Length]; for (int i = 0; i < interfaces.Length; i++) { try { wrappers[i] = loader.LoadClassByDottedNameFast(interfaces[i]); } catch (RetargetableJavaException) { } if (wrappers[i] == null) { StaticCompiler.IssueMessage(Message.UnableToCreateProxy, proxy, "unable to load interface " + interfaces[i]); return; } } Create(loader, proxy, wrappers); }
private static void DoEmit(DynamicTypeWrapper.FinishContext context, TypeWrapper wrapper, CodeEmitter ilgen, FieldWrapper field) { ConstructorBuilder cb; bool exists; lock (map) { exists = map.TryGetValue(field, out cb); } if (!exists) { // note that we don't need to lock here, because we're running as part of FinishCore, which is already protected by a lock TypeWrapper arfuTypeWrapper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.IntrinsicAtomicReferenceFieldUpdater"); TypeBuilder tb = wrapper.TypeAsBuilder.DefineNestedType("__<ARFU>_" + field.Name + field.Signature.Replace('.', '/'), TypeAttributes.NestedPrivate | TypeAttributes.Sealed, arfuTypeWrapper.TypeAsBaseType); EmitCompareAndSet("compareAndSet", tb, field.GetField()); EmitGet(tb, field.GetField()); EmitSet("set", tb, field.GetField()); cb = tb.DefineConstructor(MethodAttributes.Assembly, CallingConventions.Standard, Type.EmptyTypes); lock (map) { map.Add(field, cb); } CodeEmitter ctorilgen = CodeEmitter.Create(cb); ctorilgen.Emit(OpCodes.Ldarg_0); MethodWrapper basector = arfuTypeWrapper.GetMethodWrapper("<init>", "()V", false); basector.Link(); basector.EmitCall(ctorilgen); ctorilgen.Emit(OpCodes.Ret); context.RegisterPostFinishProc(delegate { arfuTypeWrapper.Finish(); tb.CreateType(); }); } ilgen.LazyEmitPop(); ilgen.LazyEmitPop(); ilgen.LazyEmitPop(); ilgen.Emit(OpCodes.Newobj, cb); }
public static IAsymmetricCipherKeyPairGenerator CreateGenerator(SecureRandom random, TypeWrapper kpGen, int keystrength) { var keypairGen = kpGen.Instance<IAsymmetricCipherKeyPairGenerator>(); //var random = SecureRandomUtils.GetInstance(Model.RandomGenerator, Model.RandomGeneratorArgument); if (keypairGen is DsaKeyPairGenerator) { DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(keystrength, 80, random); //TODO: DsaParameters parameters = pGen.GenerateParameters(); DsaKeyGenerationParameters genParam = new DsaKeyGenerationParameters(random, parameters); keypairGen.Init(genParam); return keypairGen; } if (keypairGen is ECKeyPairGenerator) { keypairGen.Init(new KeyGenerationParameters(random, keystrength)); return keypairGen; } keypairGen.Init(new KeyGenerationParameters(random, keystrength)); return keypairGen; }
private static bool IsSafeForAutomagicSerialization(TypeWrapper wrapper) { if (wrapper.TypeAsBaseType.IsSerializable) { return false; } if (wrapper.IsSubTypeOf(iserializable)) { return false; } if (wrapper.IsSubTypeOf(iobjectreference)) { return false; } if (wrapper.GetMethodWrapper("GetObjectData", "(Lcli.System.Runtime.Serialization.SerializationInfo;Lcli.System.Runtime.Serialization.StreamingContext;)V", false) != null) { return false; } if (wrapper.GetMethodWrapper("<init>", "(Lcli.System.Runtime.Serialization.SerializationInfo;Lcli.System.Runtime.Serialization.StreamingContext;)V", false) != null) { return false; } return true; }
public static string getSigName(java.lang.Class thisClass) { return(TypeWrapper.FromClass(thisClass).SigName); }
public static java.lang.Class getSuperclass(java.lang.Class thisClass) { TypeWrapper super = TypeWrapper.FromClass(thisClass).BaseTypeWrapper; return(super != null ? super.ClassObject : null); }
public static bool desiredAssertionStatus0(java.lang.Class clazz) { return(IKVM.Runtime.Assertions.IsEnabled(TypeWrapper.FromClass(clazz))); }
internal static string TypeNameMangleImpl(Dictionary <string, TypeWrapper> dict, string name, TypeWrapper tw) { // the CLR maximum type name length is 1023 characters, // but we need to leave some room for the suffix that we // may need to append to make the name unique const int MaxLength = 1000; if (name.Length > MaxLength) { name = name.Substring(0, MaxLength) + "/truncated"; } string mangledTypeName = TypeNameUtil.ReplaceIllegalCharacters(name); // FXBUG the CLR (both 1.1 and 2.0) doesn't like type names that end with a single period, // it loses the trailing period in the name that gets passed in the TypeResolve event. if (dict.ContainsKey(mangledTypeName) || mangledTypeName.EndsWith(".")) { #if STATIC_COMPILER Tracer.Warning(Tracer.Compiler, "Class name clash: {0}", mangledTypeName); #endif // Java class names cannot contain slashes (since they are converted into periods), // so we take advantage of that fact to create a unique name. string baseName = mangledTypeName; int instanceId = 0; do { mangledTypeName = baseName + "/" + (++instanceId); } while (dict.ContainsKey(mangledTypeName)); } dict.Add(mangledTypeName, tw); return(mangledTypeName); }
public bool TryGetType(string key, out TypeWrapper typeWrapper) { return(this.typeDictionary.TryGetValue(key, out typeWrapper)); }
internal static Delegate CreateMemberName(MethodWrapper mw, MethodType type, bool doDispatch) { FinishTypes(type); TypeWrapper tw = mw.DeclaringType; Type owner = tw.TypeAsBaseType; #if NET_4_0 if (!doDispatch && !mw.IsStatic) { // on .NET 4 we can only do a non-virtual invocation of a virtual method if we skip verification, // and to skip verification we need to inject the dynamic method in a critical assembly // TODO instead of injecting in mscorlib, we should use DynamicMethodUtils.Create() owner = typeof(object); } #endif DynamicMethodBuilder dm = new DynamicMethodBuilder("MemberName:" + mw.DeclaringType.Name + "::" + mw.Name + mw.Signature, type, null, mw.HasCallerID ? DynamicCallerIDProvider.Instance : null, null, owner, true); for (int i = 0, count = type.parameterCount(); i < count; i++) { if (i == 0 && !mw.IsStatic && (tw.IsGhost || tw.IsNonPrimitiveValueType || tw.IsRemapped) && (!mw.IsConstructor || tw != CoreClasses.java.lang.String.Wrapper)) { if (tw.IsGhost || tw.IsNonPrimitiveValueType) { dm.LoadFirstArgAddress(tw); } else { Debug.Assert(tw.IsRemapped); // TODO this must be checked dm.Ldarg(0); if (mw.IsConstructor) { dm.EmitCastclass(tw.TypeAsBaseType); } else if (tw != CoreClasses.cli.System.Object.Wrapper) { dm.EmitCheckcast(tw); } } } else { dm.Ldarg(i); TypeWrapper argType = TypeWrapper.FromClass(type.parameterType(i)); if (!argType.IsPrimitive) { if (argType.IsUnloadable) { } else if (argType.IsNonPrimitiveValueType) { dm.Unbox(argType); } else if (argType.IsGhost) { dm.UnboxGhost(argType); } else { dm.EmitCheckcast(argType); } } } } if (mw.HasCallerID) { dm.LoadCallerID(); } // special case for Object.clone() and Object.finalize() if (mw.IsFinalizeOrClone) { if (doDispatch) { mw.EmitCallvirtReflect(dm.ilgen); } else { // we can re-use the implementations from cli.System.Object (even though the object may not in-fact extend cli.System.Object) CoreClasses.cli.System.Object.Wrapper.GetMethodWrapper(mw.Name, mw.Signature, false).EmitCall(dm.ilgen); } } else if (doDispatch && !mw.IsStatic) { dm.Callvirt(mw); } else { dm.Call(mw); } TypeWrapper retType = TypeWrapper.FromClass(type.returnType()); if (retType.IsUnloadable) { } else if (retType.IsNonPrimitiveValueType) { dm.Box(retType); } else if (retType.IsGhost) { dm.BoxGhost(retType); } else if (retType == PrimitiveTypeWrapper.BYTE) { dm.CastByte(); } dm.Ret(); return(dm.CreateDelegate()); }
internal static void EmitThrowNoSuchMethodErrorForGetter(CodeEmitter ilgen, TypeWrapper type, bool isStatic) { // HACK the branch around the throw is to keep the verifier happy CodeEmitterLabel label = ilgen.DefineLabel(); ilgen.Emit(OpCodes.Ldc_I4_0); ilgen.Emit(OpCodes.Brtrue_S, label); ilgen.EmitThrow("java.lang.NoSuchMethodError"); ilgen.MarkLabel(label); if (!isStatic) { ilgen.Emit(OpCodes.Pop); } ilgen.Emit(OpCodes.Ldloc, ilgen.DeclareLocal(type.TypeAsLocalOrStackType)); }
internal void EmitCheckcast(TypeWrapper tw) { tw.EmitCheckcast(ilgen); }
private static void ResolveMethod(MemberName self, java.lang.Class caller) { bool invokeSpecial = self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeSpecial; bool newInvokeSpecial = self.getReferenceKind() == MethodHandleNatives.Constants.REF_newInvokeSpecial; bool searchBaseClasses = !newInvokeSpecial; MethodWrapper mw = TypeWrapper.FromClass(self.getDeclaringClass()).GetMethodWrapper(self.getName(), self.getSignature().Replace('/', '.'), searchBaseClasses); if (mw == null) { if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeInterface) { mw = TypeWrapper.FromClass(self.getDeclaringClass()).GetInterfaceMethod(self.getName(), self.getSignature().Replace('/', '.')); if (mw == null) { mw = CoreClasses.java.lang.Object.Wrapper.GetMethodWrapper(self.getName(), self.getSignature().Replace('/', '.'), false); } if (mw != null && mw.IsConstructor) { throw new java.lang.IncompatibleClassChangeError("Found interface " + self.getDeclaringClass().getName() + ", but class was expected"); } } if (mw == null) { string msg = String.Format(invokeSpecial ? "{0}: method {1}{2} not found" : "{0}.{1}{2}", self.getDeclaringClass().getName(), self.getName(), self.getSignature()); throw new java.lang.NoSuchMethodError(msg); } } if (mw.IsStatic != IsReferenceKindStatic(self.getReferenceKind())) { string msg = String.Format(mw.IsStatic ? "Expecting non-static method {0}.{1}{2}" : "Expected static method {0}.{1}{2}", mw.DeclaringType.Name, self.getName(), self.getSignature()); throw new java.lang.IncompatibleClassChangeError(msg); } if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeVirtual && mw.DeclaringType.IsInterface) { throw new java.lang.IncompatibleClassChangeError("Found interface " + mw.DeclaringType.Name + ", but class was expected"); } if (!mw.IsPublic && self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeInterface) { throw new java.lang.IncompatibleClassChangeError("private interface method requires invokespecial, not invokeinterface: method " + self.getDeclaringClass().getName() + "." + self.getName() + self.getSignature()); } if (mw.IsConstructor && mw.DeclaringType == CoreClasses.java.lang.String.Wrapper) { self.vmtarget = CreateMemberNameDelegate(mw, caller, false, self.getMethodType().changeReturnType(CoreClasses.java.lang.String.Wrapper.ClassObject)); } else if (!mw.IsConstructor || invokeSpecial || newInvokeSpecial) { MethodType methodType = self.getMethodType(); if (!mw.IsStatic) { methodType = methodType.insertParameterTypes(0, mw.DeclaringType.ClassObject); if (newInvokeSpecial) { methodType = methodType.changeReturnType(java.lang.Void.TYPE); } } self.vmtarget = CreateMemberNameDelegate(mw, caller, self.hasReceiverTypeDispatch(), methodType); } SetModifiers(self, mw); self._flags(self._flags() | (mw.IsConstructor ? MethodHandleNatives.Constants.MN_IS_CONSTRUCTOR : MethodHandleNatives.Constants.MN_IS_METHOD)); if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeVirtual && (mw.IsPrivate || mw.IsFinal || mw.IsConstructor)) { int flags = self._flags(); flags -= MethodHandleNatives.Constants.REF_invokeVirtual << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT; flags += MethodHandleNatives.Constants.REF_invokeSpecial << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT; self._flags(flags); } if (mw.HasCallerID || DynamicTypeWrapper.RequiresDynamicReflectionCallerClass(mw.DeclaringType.Name, mw.Name, mw.Signature)) { self._flags(self._flags() | MemberName.CALLER_SENSITIVE); } }
internal void BoxGhost(TypeWrapper tw) { tw.EmitConvSignatureTypeToStackType(ilgen); }
internal void UnboxGhost(TypeWrapper tw) { tw.EmitConvStackTypeToSignatureType(ilgen, null); }
internal void Box(TypeWrapper tw) { tw.EmitBox(ilgen); }
internal void Unbox(TypeWrapper tw) { tw.EmitUnbox(ilgen); }
internal CompiledPropertyFieldWrapper(TypeWrapper declaringType, PropertyInfo property, ExModifiers modifiers) : base(declaringType, ClassLoaderWrapper.GetWrapperFromType(property.PropertyType), property.Name, ClassLoaderWrapper.GetWrapperFromType(property.PropertyType).SigName, modifiers, null) { this.property = property; }
internal sealed override TypeWrapper DefineClassImpl(Dictionary <string, TypeWrapper> types, TypeWrapper host, ClassFile f, ClassLoaderWrapper classLoader, ProtectionDomain protectionDomain) { #if STATIC_COMPILER AotTypeWrapper type = new AotTypeWrapper(f, (CompilerClassLoader)classLoader); type.CreateStep1(); types[f.Name] = type; return(type); #elif FIRST_PASS return(null); #else // this step can throw a retargettable exception, if the class is incorrect DynamicTypeWrapper type = new DynamicTypeWrapper(host, f, classLoader, protectionDomain); // This step actually creates the TypeBuilder. It is not allowed to throw any exceptions, // if an exception does occur, it is due to a programming error in the IKVM or CLR runtime // and will cause a CriticalFailure and exit the process. type.CreateStep1(); type.CreateStep2(); if (types == null) { // we're defining an anonymous class, so we don't need any locking TieClassAndWrapper(type, protectionDomain); return(type); } lock (types) { // in very extreme conditions another thread may have beaten us to it // and loaded (not defined) a class with the same name, in that case // we'll leak the the Reflection.Emit defined type. Also see the comment // in ClassLoaderWrapper.RegisterInitiatingLoader(). TypeWrapper race; types.TryGetValue(f.Name, out race); if (race == null) { types[f.Name] = type; TieClassAndWrapper(type, protectionDomain); } else { throw new LinkageError("duplicate class definition: " + f.Name); } } return(type); #endif // STATIC_COMPILER }
// constructor for type 1 access stubs internal CompiledAccessStubFieldWrapper(TypeWrapper wrapper, PropertyInfo property, TypeWrapper propertyType) : this(wrapper, property, null, propertyType, GetModifiers(property), MemberFlags.HideFromReflection | MemberFlags.AccessStub) { }
private void SerializeValue(IDataAdapter data, object target) { objectsCache.Add(target, maxObjId++); TypeWrapper wrapper = TypeCache.GetWrapper(target.GetType()); if (wrapper.TrySerialize(target, data, this)) { return; } for (int i = 0; i < wrapper.Properties.Count; i++) { PropertyWrapper property = wrapper.Properties[i]; if (property.IsPrivate) { if (!settings.SerializePrivateProperties) { continue; } havePrivateProperties = true; } bool isReadOnly; if (property.ConstructorArg != -1 || // will be used in constructor settings.SerializeReadOnly) { isReadOnly = false; // always serialize } else { isReadOnly = !property.CanWrite; } object value = property.GetValue(target); if (value != null) { SerializeValue(property.MemberType, value, data, new Info(property), isReadOnly); } else if (settings.SerializeNull) { data.AddNullValue(property.Name, property.Location != NanoLocation.SubNode); } } for (int i = 0; i < wrapper.Fields.Count; i++) { FieldWrapper field = wrapper.Fields[i]; if (!settings.IgnoreNotSerialized && field.Info.IsNotSerialized) { continue; } object value = field.GetValue(target); if (value != null) { SerializeValue(field.MemberType, value, data, new Info(field), false); } else if (settings.SerializeNull) { data.AddNullValue(field.Name, field.Location != NanoLocation.SubNode); } } }
private CompiledAccessStubFieldWrapper(TypeWrapper wrapper, PropertyInfo property, FieldInfo field, TypeWrapper propertyType, Modifiers modifiers, MemberFlags flags) : base(wrapper, propertyType, property.Name, propertyType.SigName, modifiers, field, flags) { this.getter = property.GetGetMethod(true); this.setter = property.GetSetMethod(true); }
public void Add(string key, TypeWrapper typeWrapper) { this.typeDictionary.Add(key, typeWrapper); this.types.Add(typeWrapper); }
internal static MethodWrapper Create(TypeWrapper declaringType, string name, string sig, MethodBase method, TypeWrapper returnType, TypeWrapper[] parameterTypes, Modifiers modifiers, MemberFlags flags) { Debug.Assert(declaringType != null && name!= null && sig != null && method != null); if(declaringType.IsGhost) { // HACK since our caller isn't aware of the ghost issues, we'll handle the method swapping if(method.DeclaringType.IsValueType) { Type[] types = new Type[parameterTypes.Length]; for(int i = 0; i < types.Length; i++) { types[i] = parameterTypes[i].TypeAsSignatureType; } method = declaringType.TypeAsBaseType.GetMethod(method.Name, types); } return new GhostMethodWrapper(declaringType, name, sig, method, returnType, parameterTypes, modifiers, flags); } else if(method is ConstructorInfo) { return new SmartConstructorMethodWrapper(declaringType, name, sig, (ConstructorInfo)method, parameterTypes, modifiers, flags); } else { return new SmartCallMethodWrapper(declaringType, name, sig, (MethodInfo)method, returnType, parameterTypes, modifiers, flags, SimpleOpCode.Call, method.IsStatic ? SimpleOpCode.Call : SimpleOpCode.Callvirt); } }
private static void doLoad(object thisNativeLibrary, string name) { java.lang.ClassLoader.NativeLibrary lib = (java.lang.ClassLoader.NativeLibrary)thisNativeLibrary; lib.handle = IKVM.Runtime.JniHelper.LoadLibrary(name, TypeWrapper.FromClass(java.lang.ClassLoader.NativeLibrary.getFromClass()).GetClassLoader()); lib.loaded = true; }
internal void Link() { lock(this) { if(parameterTypeWrappers != null) { return; } } ClassLoaderWrapper loader = this.DeclaringType.GetClassLoader(); TypeWrapper ret = loader.RetTypeWrapperFromSigNoThrow(Signature); TypeWrapper[] parameters = loader.ArgTypeWrapperListFromSigNoThrow(Signature); lock(this) { try { // critical code in the finally block to avoid Thread.Abort interrupting the thread } finally { if(parameterTypeWrappers == null) { Debug.Assert(returnTypeWrapper == null || returnTypeWrapper == PrimitiveTypeWrapper.VOID); returnTypeWrapper = ret; parameterTypeWrappers = parameters; UpdateNonPublicTypeInSignatureFlag(); if(method == null) { try { DoLinkMethod(); } catch { // HACK if linking fails, we unlink to make sure // that the next link attempt will fail again returnTypeWrapper = null; parameterTypeWrappers = null; throw; } } } } } }
public static java.lang.Class forName0(string name, bool initialize, java.lang.ClassLoader loader) { #if FIRST_PASS return(null); #else //Console.WriteLine("forName: " + name + ", loader = " + loader); TypeWrapper tw = null; if (name.IndexOf(',') > 0) { // we essentially require full trust before allowing arbitrary types to be loaded, // hence we do the "createClassLoader" permission check java.lang.SecurityManager sm = java.lang.System.getSecurityManager(); if (sm != null) { sm.checkPermission(new java.lang.RuntimePermission("createClassLoader")); } Type type = Type.GetType(name); if (type != null) { tw = ClassLoaderWrapper.GetWrapperFromType(type); } if (tw == null) { java.lang.Throwable.suppressFillInStackTrace = true; throw new java.lang.ClassNotFoundException(name); } } else { try { ClassLoaderWrapper classLoaderWrapper = ClassLoaderWrapper.GetClassLoaderWrapper(loader); tw = classLoaderWrapper.LoadClassByDottedName(name); } catch (ClassNotFoundException x) { java.lang.Throwable.suppressFillInStackTrace = true; throw new java.lang.ClassNotFoundException(x.Message); } catch (ClassLoadingException x) { throw x.InnerException; } catch (RetargetableJavaException x) { throw x.ToJava(); } } if (initialize && !tw.IsArray) { try { tw.Finish(); } catch (RetargetableJavaException x) { throw x.ToJava(); } tw.RunClassInit(); } return(tw.ClassObject); #endif }
public static bool isPrimitive(java.lang.Class thisClass) { return(TypeWrapper.FromClass(thisClass).IsPrimitive); }
public static java.lang.Class getComponentType(java.lang.Class thisClass) { TypeWrapper tw = TypeWrapper.FromClass(thisClass); return(tw.IsArray ? tw.ElementTypeWrapper.ClassObject : null); }
private static bool IsNonVectorArray(TypeWrapper tw) { return(!tw.IsArray && tw.TypeAsBaseType.IsArray); }
public static java.lang.ClassLoader getClassLoader0(java.lang.Class thisClass) { return(TypeWrapper.FromClass(thisClass).GetClassLoader().GetJavaClassLoader()); }
private static void AddToExportList(TypeWrapper c) { todo[c.Name] = c; }
private static void AssertReverseRelationshipHasIgnoreAttribute(TypeWrapper reverseClassType, string relName) { var singleRelProp = reverseClassType.GetProperty(relName); Assert.IsTrue(singleRelProp.HasIgnoreAttribute, relName + " on " + reverseClassType.Name + " should have an ignore attribute"); }
internal StubTypeWrapper(Modifiers modifiers, string name, TypeWrapper baseWrapper, bool remapped) : base(TypeFlags.None, modifiers, name) { this.remapped = remapped; this.baseWrapper = baseWrapper; }
private bool InPracticeInternalsVisibleTo(TypeWrapper caller) { #if !STATIC_COMPILER if (DeclaringType.TypeAsTBD.Assembly.Equals(caller.TypeAsTBD.Assembly)) { // both the caller and the declaring type are in the same assembly // so we know that the internals are visible // (this handles the case where we're running in dynamic mode) return true; } #endif #if CLASSGC if (DeclaringType is DynamicTypeWrapper) { // if we are dynamic, we can just become friends with the caller DeclaringType.GetClassLoader().GetTypeWrapperFactory().AddInternalsVisibleTo(caller.TypeAsTBD.Assembly); return true; } #endif return DeclaringType.InternalsVisibleTo(caller); }
private static void AssertRelationshipIsForOwnerClass(TypeWrapper ownerClassType, TypeWrapper reverseClassType, string reveresRelationshipName) { var reversePropInfo = reverseClassType.GetProperty(reveresRelationshipName); Assert.IsNotNull(reversePropInfo, reveresRelationshipName + " on " + reverseClassType.Name + " should not be null"); Assert.AreSame(ownerClassType.UnderlyingType, reversePropInfo.RelatedClassType.UnderlyingType); }
internal ConstantFieldWrapper(TypeWrapper declaringType, TypeWrapper fieldType, string name, string sig, Modifiers modifiers, FieldInfo field, object constant, MemberFlags flags) : base(declaringType, fieldType, name, sig, modifiers, field, flags) { Debug.Assert(IsStatic); Debug.Assert(constant == null || constant.GetType().IsPrimitive || constant is string); this.constant = constant; }
private static void AssertReverseRelationshipNotForOwnerClass(TypeWrapper ownerClassType, TypeWrapper reverseClassType, string reveresRelationshipName) { var reversePropInfo = reverseClassType.GetProperty(reveresRelationshipName); Assert.IsNotNull(reversePropInfo, "No Reverse Relationship found with the name"); Assert.AreNotSame(ownerClassType, reversePropInfo.RelatedClassType); }
// constructor for type 2 access stubs internal CompiledAccessStubFieldWrapper(TypeWrapper wrapper, PropertyInfo property, FieldInfo field, TypeWrapper propertyType) : this(wrapper, property, field, propertyType, AttributeHelper.GetModifiersAttribute(property).Modifiers, MemberFlags.AccessStub) { }
private static bool IsSafeForGetClassOptimization(TypeWrapper tw) { // because of ghost arrays, we don't optimize if both types are either java.lang.Object or an array return(tw != CoreClasses.java.lang.Object.Wrapper && !tw.IsArray); }
internal GhostMethodWrapper(TypeWrapper declaringType, string name, string sig, MethodBase method, TypeWrapper returnType, TypeWrapper[] parameterTypes, Modifiers modifiers, MemberFlags flags) : base(declaringType, name, sig, method, returnType, parameterTypes, modifiers, flags) { // make sure we weren't handed the ghostMethod in the wrapper value type Debug.Assert(method == null || method.DeclaringType.IsInterface); }
private static bool Unsafe_putObjectImpl(EmitIntrinsicContext eic, bool membarrier) { TypeWrapper tw = eic.GetStackTypeWrapper(0, 2); if (IsSupportedArrayTypeForUnsafeOperation(tw) && eic.GetStackTypeWrapper(0, 0).IsAssignableTo(tw.ElementTypeWrapper)) { CodeEmitterLocal value = eic.Emitter.AllocTempLocal(tw.ElementTypeWrapper.TypeAsLocalOrStackType); CodeEmitterLocal index = eic.Emitter.AllocTempLocal(Types.Int32); CodeEmitterLocal array = eic.Emitter.AllocTempLocal(tw.TypeAsLocalOrStackType); eic.Emitter.Emit(OpCodes.Stloc, value); eic.Emitter.Emit(OpCodes.Conv_Ovf_I4); eic.Emitter.Emit(OpCodes.Stloc, index); eic.Emitter.Emit(OpCodes.Stloc, array); EmitConsumeUnsafe(eic); eic.Emitter.Emit(OpCodes.Ldloc, array); eic.Emitter.Emit(OpCodes.Ldloc, index); eic.Emitter.Emit(OpCodes.Ldloc, value); eic.Emitter.ReleaseTempLocal(array); eic.Emitter.ReleaseTempLocal(index); eic.Emitter.ReleaseTempLocal(value); eic.Emitter.Emit(OpCodes.Stelem_Ref); if (membarrier) { eic.Emitter.EmitMemoryBarrier(); } eic.NonLeaf = false; return(true); } if ((eic.Flags[eic.OpcodeIndex] & InstructionFlags.BranchTarget) != 0 || (eic.Flags[eic.OpcodeIndex - 1] & InstructionFlags.BranchTarget) != 0) { return(false); } if ((eic.Match(-1, NormalizedByteCode.__aload) || eic.Match(-1, NormalizedByteCode.__aconst_null)) && eic.Match(-2, NormalizedByteCode.__getstatic)) { FieldWrapper fw = GetUnsafeField(eic, eic.GetFieldref(-2)); if (fw != null && (!fw.IsFinal || (!fw.IsStatic && eic.Caller.Name == "<init>") || (fw.IsStatic && eic.Caller.Name == "<clinit>")) && fw.IsAccessibleFrom(fw.DeclaringType, eic.Caller.DeclaringType, fw.DeclaringType) && eic.GetStackTypeWrapper(0, 0).IsAssignableTo(fw.FieldTypeWrapper) && (fw.IsStatic || fw.DeclaringType == eic.GetStackTypeWrapper(0, 2))) { CodeEmitterLocal value = eic.Emitter.AllocTempLocal(fw.FieldTypeWrapper.TypeAsLocalOrStackType); eic.Emitter.Emit(OpCodes.Stloc, value); eic.Emitter.Emit(OpCodes.Pop); // discard offset field if (fw.IsStatic) { eic.Emitter.Emit(OpCodes.Pop); // discard object EmitConsumeUnsafe(eic); } else { CodeEmitterLocal obj = eic.Emitter.AllocTempLocal(fw.DeclaringType.TypeAsLocalOrStackType); eic.Emitter.Emit(OpCodes.Stloc, obj); EmitConsumeUnsafe(eic); eic.Emitter.Emit(OpCodes.Ldloc, obj); eic.Emitter.ReleaseTempLocal(obj); } eic.Emitter.Emit(OpCodes.Ldloc, value); eic.Emitter.ReleaseTempLocal(value); // note that we assume the CLR memory model where all writes are ordered, // so we don't need a volatile store or a memory barrier and putOrderedObject // is typically used with a volatile field, so to avoid the memory barrier, // we don't use FieldWrapper.EmitSet(), but emit the store directly eic.Emitter.Emit(fw.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld, fw.GetField()); if (membarrier) { eic.Emitter.EmitMemoryBarrier(); } eic.NonLeaf = false; return(true); } } return(false); }
internal MethodWrapper(TypeWrapper declaringType, string name, string sig, MethodBase method, TypeWrapper returnType, TypeWrapper[] parameterTypes, Modifiers modifiers, MemberFlags flags) : base(declaringType, name, sig, modifiers, flags) { Profiler.Count("MethodWrapper"); this.method = method; Debug.Assert(((returnType == null) == (parameterTypes == null)) || (returnType == PrimitiveTypeWrapper.VOID)); this.returnTypeWrapper = returnType; this.parameterTypeWrappers = parameterTypes; if (Intrinsics.IsIntrinsic(this)) { SetIntrinsicFlag(); } UpdateNonPublicTypeInSignatureFlag(); }
private static bool Unsafe_compareAndSwapObject(EmitIntrinsicContext eic) { TypeWrapper tw = eic.GetStackTypeWrapper(0, 3); if (IsSupportedArrayTypeForUnsafeOperation(tw) && eic.GetStackTypeWrapper(0, 0).IsAssignableTo(tw.ElementTypeWrapper) && eic.GetStackTypeWrapper(0, 1).IsAssignableTo(tw.ElementTypeWrapper)) { Type type = tw.TypeAsLocalOrStackType.GetElementType(); CodeEmitterLocal update = eic.Emitter.AllocTempLocal(type); CodeEmitterLocal expect = eic.Emitter.AllocTempLocal(type); CodeEmitterLocal index = eic.Emitter.AllocTempLocal(Types.Int32); CodeEmitterLocal obj = eic.Emitter.AllocTempLocal(tw.TypeAsLocalOrStackType); eic.Emitter.Emit(OpCodes.Stloc, update); eic.Emitter.Emit(OpCodes.Stloc, expect); eic.Emitter.Emit(OpCodes.Conv_Ovf_I4); eic.Emitter.Emit(OpCodes.Stloc, index); eic.Emitter.Emit(OpCodes.Stloc, obj); EmitConsumeUnsafe(eic); eic.Emitter.Emit(OpCodes.Ldloc, obj); eic.Emitter.Emit(OpCodes.Ldloc, index); eic.Emitter.Emit(OpCodes.Ldelema, type); eic.Emitter.Emit(OpCodes.Ldloc, update); eic.Emitter.Emit(OpCodes.Ldloc, expect); eic.Emitter.Emit(OpCodes.Call, AtomicReferenceFieldUpdaterEmitter.MakeCompareExchange(type)); eic.Emitter.Emit(OpCodes.Ldloc, expect); eic.Emitter.Emit(OpCodes.Ceq); eic.Emitter.ReleaseTempLocal(obj); eic.Emitter.ReleaseTempLocal(index); eic.Emitter.ReleaseTempLocal(expect); eic.Emitter.ReleaseTempLocal(update); eic.NonLeaf = false; return(true); } if ((eic.Flags[eic.OpcodeIndex] & InstructionFlags.BranchTarget) != 0 || (eic.Flags[eic.OpcodeIndex - 1] & InstructionFlags.BranchTarget) != 0 || (eic.Flags[eic.OpcodeIndex - 2] & InstructionFlags.BranchTarget) != 0) { return(false); } if ((eic.Match(-1, NormalizedByteCode.__aload) || eic.Match(-1, NormalizedByteCode.__aconst_null)) && (eic.Match(-2, NormalizedByteCode.__aload) || eic.Match(-2, NormalizedByteCode.__aconst_null)) && eic.Match(-3, NormalizedByteCode.__getstatic)) { FieldWrapper fw = GetUnsafeField(eic, eic.GetFieldref(-3)); if (fw != null && fw.IsAccessibleFrom(fw.DeclaringType, eic.Caller.DeclaringType, fw.DeclaringType) && eic.GetStackTypeWrapper(0, 0).IsAssignableTo(fw.FieldTypeWrapper) && eic.GetStackTypeWrapper(0, 1).IsAssignableTo(fw.FieldTypeWrapper) && (fw.IsStatic || fw.DeclaringType == eic.GetStackTypeWrapper(0, 3))) { Type type = fw.FieldTypeWrapper.TypeAsLocalOrStackType; CodeEmitterLocal update = eic.Emitter.AllocTempLocal(type); CodeEmitterLocal expect = eic.Emitter.AllocTempLocal(type); eic.Emitter.Emit(OpCodes.Stloc, update); eic.Emitter.Emit(OpCodes.Stloc, expect); eic.Emitter.Emit(OpCodes.Pop); // discard index if (fw.IsStatic) { eic.Emitter.Emit(OpCodes.Pop); // discard obj EmitConsumeUnsafe(eic); eic.Emitter.Emit(OpCodes.Ldsflda, fw.GetField()); } else { CodeEmitterLocal obj = eic.Emitter.AllocTempLocal(eic.Caller.DeclaringType.TypeAsLocalOrStackType); eic.Emitter.Emit(OpCodes.Stloc, obj); EmitConsumeUnsafe(eic); eic.Emitter.Emit(OpCodes.Ldloc, obj); eic.Emitter.ReleaseTempLocal(obj); eic.Emitter.Emit(OpCodes.Ldflda, fw.GetField()); } eic.Emitter.Emit(OpCodes.Ldloc, update); eic.Emitter.Emit(OpCodes.Ldloc, expect); eic.Emitter.Emit(OpCodes.Call, AtomicReferenceFieldUpdaterEmitter.MakeCompareExchange(type)); eic.Emitter.Emit(OpCodes.Ldloc, expect); eic.Emitter.Emit(OpCodes.Ceq); eic.Emitter.ReleaseTempLocal(expect); eic.Emitter.ReleaseTempLocal(update); eic.NonLeaf = false; return(true); } } return(false); }
protected MemberWrapper(TypeWrapper declaringType, string name, string sig, Modifiers modifiers, MemberFlags flags) { Debug.Assert(declaringType != null); this.declaringType = declaringType; this.name = String.Intern(name); this.sig = String.Intern(sig); this.modifiers = modifiers; this.flags = flags; }
public static TDelegate CompileLambda <TDelegate>(params object[] expressions) /*TODO: add in C# v7.3: where TDelegate : Delegate*/ { var typeWrapper = new TypeWrapper(typeof(TDelegate)); return((TDelegate)(object)typeWrapper.CompileLambda(expressions)); }