private void ImplementInterface(ClsTypeEmitter/*!*/ emitter, Type/*!*/ interfaceType, Dictionary<Type/*!*/, bool>/*!*/ doneTypes) { if (doneTypes.ContainsKey(interfaceType)) { return; } doneTypes.Add(interfaceType, true); emitter.OverrideMethods(interfaceType); foreach (Type t in interfaceType.GetInterfaces()) { ImplementInterface(emitter, t, doneTypes); } }
public void Implement(ClsTypeEmitter /*!*/ emitter) { // TODO: Exclude interfaces already implemented in base class feature sets // TODO: Exclude IDynamicObject, IRubyObject, etc. or handle specially Dictionary <Type, bool> doneTypes = new Dictionary <Type, bool>(); foreach (Type interfaceType in _interfaces) { _tb.AddInterfaceImplementation(interfaceType); ImplementInterface(emitter, interfaceType, doneTypes); } }
private void ImplementInterface(ClsTypeEmitter /*!*/ emitter, Type /*!*/ interfaceType, Dictionary <Type /*!*/, bool> /*!*/ doneTypes) { if (doneTypes.ContainsKey(interfaceType)) { return; } doneTypes.Add(interfaceType, true); emitter.OverrideMethods(interfaceType); foreach (Type t in interfaceType.GetInterfaces()) { ImplementInterface(emitter, t, doneTypes); } }
public void Implement(ClsTypeEmitter/*!*/ emitter) { _emitter = (RubyTypeEmitter)emitter; DefineConstructors(); if (!IsDerivedRubyType) { DefineRubyObjectImplementation(); DefineSerializer(); DefineDynamicObjectImplementation(); #if !SILVERLIGHT // ICustomTypeDescriptor DefineCustomTypeDescriptor(); #endif DefineRubyTypeImplementation(); } }
public void Implement(ClsTypeEmitter/*!*/ emitter) { DefineConstructors(); DefineRubyObjectImplementation(); DefineSerializer(); RubyTypeEmitter re = (emitter as RubyTypeEmitter); Assert.NotNull(re); re.ImmediateClassField = _immediateClassField; DefineDynamicObjectImplementation(); #if !SILVERLIGHT // ICustomTypeDescriptor DefineCustomTypeDescriptor(); #endif }
public void Implement(ClsTypeEmitter /*!*/ emitter) { _emitter = (RubyTypeEmitter)emitter; DefineConstructors(); if (!IsDerivedRubyType) { DefineRubyObjectImplementation(); DefineSerializer(); DefineDynamicObjectImplementation(); #if !SILVERLIGHT // ICustomTypeDescriptor DefineCustomTypeDescriptor(); #endif DefineRubyTypeImplementation(); } }
public void Implement(ClsTypeEmitter/*!*/ emitter) { // TODO: Exclude interfaces already implemented in base class feature sets // TODO: Exclude IDynamicMetaObjectProvider, IRubyObject, etc. or handle specially Dictionary<Type, bool> doneTypes = new Dictionary<Type, bool>(); foreach (Type interfaceType in _interfaces) { if (interfaceType != typeof(IRubyType) && interfaceType != typeof(IRubyObject) && #if !SILVERLIGHT interfaceType != typeof(ICustomTypeDescriptor) && interfaceType != typeof(ISerializable) && #endif interfaceType != typeof(IRubyDynamicMetaObjectProvider)) { _tb.AddInterfaceImplementation(interfaceType); ImplementInterface(emitter, interfaceType, doneTypes); } } }
public void Implement(ClsTypeEmitter /*!*/ emitter) { _emitter = (RubyTypeEmitter)emitter; DefineConstructors(); if (!IsDerivedRubyType) { DefineRubyObjectImplementation(); DefineSerializer(); DefineDynamicObjectImplementation(); #if FEATURE_CUSTOM_TYPE_DESCRIPTOR DefineCustomTypeDescriptor(); #endif DefineRubyTypeImplementation(); } }
public void Implement(ClsTypeEmitter /*!*/ emitter) { // TODO: Exclude interfaces already implemented in base class feature sets // TODO: Exclude IDynamicMetaObjectProvider, IRubyObject, etc. or handle specially Dictionary <Type, bool> doneTypes = new Dictionary <Type, bool>(); foreach (Type interfaceType in _interfaces) { if (interfaceType != typeof(IRubyType) && interfaceType != typeof(IRubyObject) && #if !SILVERLIGHT interfaceType != typeof(ICustomTypeDescriptor) && interfaceType != typeof(ISerializable) && #endif interfaceType != typeof(IRubyDynamicMetaObjectProvider)) { _tb.AddInterfaceImplementation(interfaceType); ImplementInterface(emitter, interfaceType, doneTypes); } } }
public void Implement(ClsTypeEmitter/*!*/ emitter) { DefineConstructors(); DefineRubyObjectImplementation(); DefineSerializer(); RubyTypeEmitter re = (emitter as RubyTypeEmitter); Assert.NotNull(re); re.ClassField = _classField; DefineDynamicObjectImplementation(); #if !SILVERLIGHT // ICustomTypeDescriptor DefineCustomTypeDescriptor(); #endif // we need to get the right execution context #if OBSOLETE // TODO: remove the need for these methods to be special cased EmitOverrideEquals(typeGen); EmitOverrideGetHashCode(typeGen); #endif }
public void Implement(ClsTypeEmitter /*!*/ emitter) { DefineConstructors(); DefineRubyObjectImplementation(); DefineSerializer(); RubyTypeEmitter re = (emitter as RubyTypeEmitter); Assert.NotNull(re); re.ClassField = _classField; DefineDynamicObjectImplementation(); #if !SILVERLIGHT // ICustomTypeDescriptor DefineCustomTypeDescriptor(); #endif // we need to get the right execution context #if OBSOLETE // TODO: remove the need for these methods to be special cased EmitOverrideEquals(typeGen); EmitOverrideGetHashCode(typeGen); #endif }
public void Implement(ClsTypeEmitter/*!*/ emitter) { // TODO: Exclude interfaces already implemented in base class feature sets // TODO: Exclude IDynamicMetaObjectProvider, IRubyObject, etc. or handle specially Dictionary<Type, bool> doneTypes = new Dictionary<Type, bool>(); foreach (Type interfaceType in _interfaces) { _tb.AddInterfaceImplementation(interfaceType); ImplementInterface(emitter, interfaceType, doneTypes); } }
private void BuildConstructors(IList <ConstructorBuilderInfo> /*!*/ ctors) { foreach (var ctor in ctors) { // ctor(... RubyClass! class ..., <visible params>) : base(<hidden params>, <visible params>) { _class = class; } // ctor(... RubyClass! class ..., <visible params>) : base(... RubyOps.GetContextFromClass(class) ..., <visible params>) { _class = class; } // ctor(RubyClass! class) : base(RubyOps.GetDefaultExceptionMessage(class)) { _class = class; } ConstructorBuilder cb = _tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctor.ParameterTypes); ILGen il = new ILGen(cb.GetILGenerator()); int paramIndex = 0; int argIndex = 0; // We need to initialize before calling base ctor since the ctor can call virtual methods. // _immediateClass = immediateClass: if (!IsDerivedRubyType) { il.EmitLoadArg(0); il.EmitLoadArg(1 + ctor.ClassParamIndex); il.EmitFieldSet(ImmediateClassField); } // base ctor call: il.EmitLoadArg(0); ConstructorInfo msgCtor; if (ctor.ParameterTypes.Length == 1 && ctor.Adjustment == SignatureAdjustment.InsertClass && _tb.IsSubclassOf(typeof(Exception)) && IsAvailable(msgCtor = _tb.BaseType.GetConstructor(_exceptionMessageSignature))) { // a parameterless exception constructor should use Ruby default message: il.EmitLoadArg(1); il.EmitCall(Methods.GetDefaultExceptionMessage); il.Emit(OpCodes.Call, msgCtor); } else { if (ctor.Adjustment == SignatureAdjustment.InsertClass) { paramIndex++; } while (paramIndex < ctor.ParameterTypes.Length) { if (ctor.Adjustment == SignatureAdjustment.ConvertClassToContext && argIndex == ctor.ContextArgIndex) { il.EmitLoadArg(1 + ctor.ClassParamIndex); il.EmitCall(Methods.GetContextFromModule); } else { ClsTypeEmitter.DefineParameterCopy(cb, paramIndex, ctor.BaseParameters[argIndex]); il.EmitLoadArg(1 + paramIndex); } argIndex++; paramIndex++; } il.Emit(OpCodes.Call, ctor.BaseCtor); } il.Emit(OpCodes.Ret); } }
public void Implement(ClsTypeEmitter/*!*/ emitter) { _emitter = (RubyTypeEmitter)emitter; DefineConstructors(); if (!IsDerivedRubyType) { DefineRubyObjectImplementation(); DefineSerializer(); DefineDynamicObjectImplementation(); #if FEATURE_CUSTOM_TYPE_DESCRIPTOR DefineCustomTypeDescriptor(); #endif DefineRubyTypeImplementation(); } }