Beispiel #1
0
 protected virtual void EmitEventModificationMethodForStronglyReferencedEvents(
     CILField eventField,
     MethodIL il,
     CILMethod modificationMethod
     )
 {
     // Code for modifying events:
     // public void Event<idx>Add/Remove( <event type> evt )
     // {
     //    <event type> current = this.<event field>;
     //    <event type> oldCurrent, combined;
     //    do
     //    {
     //       oldCurrent = current;
     //       combined = (EventHandler<EventArgs>) Delegate.Combine( oldCurrent, evt ); <- or Delegate.Remove in case of removal
     //       current = Interlocked.CompareExchange( ref this.<event field>, combined, oldCurrent );
     //    } while ( !Object.ReferenceEquals( current, oldCurrent ) ); <- replace ReferenceEquals with OpCodes.bne.un.s.
     // }
     il.EmitInterlockedCompareExchangeFieldSettingLoop(
         eventField,
         (il2, oldCurrentB) => il2
         .EmitLoadLocal(oldCurrentB)
         .EmitLoadArg(1)
         .EmitCall(modificationMethod)
         .EmitCastToType(modificationMethod.GetReturnType(), eventField.FieldType)
         )
     .EmitReturn();
 }
Beispiel #2
0
 internal void Emit(OpCode code, CILField field, Boolean useGDefIfPossible)
 {
     ArgumentValidator.ValidateNotNull("Field", field);
     this.BeforeEmittingOpCode();
     this.EmitOpCode(code);
     this.UpdateStackSize(code, null, null);
     this.AddInt32(this._metaData.GetTokenFor(this._assemblyMapper.TryMapField(field), useGDefIfPossible && code.OperandType == OperandType.InlineTok));
 }
Beispiel #3
0
        public CILField ChangeDeclaringType(params CILTypeBase[] args)
        {
            LogicalUtils.ThrowIfDeclaringTypeNotGeneric(this, args);
            CILField fieldToGive = this;
            CILType  dt          = this.declaringType.Value;

            if (dt.GenericDefinition != null)
            {
                fieldToGive = dt.GenericDefinition.DeclaredFields[dt.DeclaredFields.IndexOf(this)];
            }
            return(this.context.Cache.MakeFieldWithGenericDeclaringType(fieldToGive, args));
        }
Beispiel #4
0
 protected virtual void EmitEventCheckMethodForStronglyReferencedEvents(
     CILField eventField,
     MethodIL il
     )
 {
     il.EmitLoadThisField(eventField)
     .EmitLoadNull()
     .EmitCeq()
     .EmitLoadInt32(0)
     .EmitCeq()
     .EmitReturn();
 }
Beispiel #5
0
 public CILField MapField(CILField field)
 {
     return(this._fieldCache.GetOrAdd(field, fieldArg =>
     {
         var mapped = this.MapType(fieldArg.DeclaringType);
         var retVal = mapped.Equals(fieldArg.DeclaringType) ? fieldArg : mapped.DeclaredFields.FirstOrDefault(f => f.Name == fieldArg.Name && MatchParameterTypes(fieldArg.FieldType, f.FieldType));
         if (retVal == null)
         {
             throw new InvalidOperationException("Failed to map field " + fieldArg + " of declaring type " + fieldArg.DeclaringType + ".");
         }
         return retVal;
     }));
 }
        protected virtual void EmitPropertyCompareExchangeMethod(
            PropertyModel propertyModel,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField propertyField,
            CompositeMethodGenerationInfo methodGenInfo,
            Action <CILField, MethodIL> compareExchangeAction
            )
        {
            var il = methodGenInfo.IL;

            this.EmitThrowIfApplicationNotActiveWithoutLocalVariable(thisGenerationInfo, il);

            this.EmitCheckPropertyImmutability(propertyModel, thisGenerationInfo, il);

            // return Interlocked.CompareExchange(ref this._property, <arg-2>, <arg-1>);
            compareExchangeAction(propertyField, il);
            il.EmitReturn();
        }
        protected virtual void EmitPropertySetterMethod(
            CompositeCodeGenerationInfo codeGenerationInfo,
            PropertyModel propertyModel,
            CompositeTypeGenerationInfo publicCompositeGenInfo,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField propertyField,
            CILTypeBase fieldType,
            CILTypeBase propertyType,
            CompositeMethodGenerationInfo methodGenInfo,
            Action <CILField, MethodIL> writeAction
            )
        {
            // Code for setting properties:
            // internal void Property<idx>Setter(<property type> value )
            // {
            //    CompositeInstance instance = this._instance;
            //    <if the property is immutable>
            //    if ( !this._instance.IsPrototype )
            //    {
            //       throw new InvalidOperationException( "Can not set immutable propery " + QualifiedName.FromTypeAndName( <declaring type>, <name> ) + " for a non-prototype composite instance." );
            //    }
            //    <end if>
            //    <write property field>
            // }
            var il = methodGenInfo.IL;

            il.EmitLoadThisField(thisGenerationInfo.CompositeField)
            .EmitStoreLocal(methodGenInfo.GetOrCreateLocal(LB_C_INSTANCE, codeGenerationInfo.CompositeInstanceFieldType.NewWrapper(this.ctx)));

            this.EmitThrowIfApplicationNotActive(methodGenInfo);

            this.EmitProcessParameters(codeGenerationInfo, propertyModel.SetterMethod, true, publicCompositeGenInfo, thisGenerationInfo, methodGenInfo);

            this.EmitThrowIfViolations(thisGenerationInfo, methodGenInfo, propertyModel.SetterMethod);

            this.EmitCheckPropertyImmutability(propertyModel, thisGenerationInfo, il);

            writeAction(propertyField, il);

            il
            .EmitPop()
            .EmitReturn();
        }
        protected virtual void EmitPropertyExchangeMethod(
            PropertyModel propertyModel,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField propertyField,
            CILTypeBase fieldType,
            CILTypeBase propertyType,
            CILMethod propertySetter,
            CompositeMethodGenerationInfo methodGenInfo,
            Action <CILField, MethodIL> exchangeAction
            )
        {
            var il = methodGenInfo.IL;

            this.EmitThrowIfApplicationNotActiveWithoutLocalVariable(thisGenerationInfo, il);

            this.EmitCheckPropertyImmutability(propertyModel, thisGenerationInfo, il);

            exchangeAction(propertyField, il);
            il
            .EmitCastToType(fieldType, propertyType)
            .EmitReturn();
        }
        protected virtual void EmitPropertyGetterMethod(
            CompositeCodeGenerationInfo codeGenerationInfo,
            PropertyModel propertyModel,
            CompositeTypeGenerationInfo publicCompositeGenInfo,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField propertyField,
            CILTypeBase propertyType,
            CompositeMethodGenerationInfo methodGenInfo,
            Action <CILField, MethodIL> readAction
            )
        {
            // Code for getting properties:
            // public <property type> Property<idx>Getter( )
            // {
            //    CompositeInstance instance = this._instance;
            //    <check application active>
            //    var result = <read property field>;
            //    <check constraints>
            //    return result;
            // }
            var il = methodGenInfo.IL;

            il.EmitLoadThisField(thisGenerationInfo.CompositeField)
            .EmitStoreLocal(methodGenInfo.GetOrCreateLocal(LB_C_INSTANCE, codeGenerationInfo.CompositeInstanceFieldType.NewWrapper(this.ctx)));
            this.EmitThrowIfApplicationNotActive(methodGenInfo);

            var resultB = methodGenInfo.GetOrCreateLocal(LB_RESULT, methodGenInfo.ReturnType);

            readAction(propertyField, il);
            il.EmitStoreLocal(resultB);

            this.EmitProcessParameters(codeGenerationInfo, propertyModel.GetterMethod, false, publicCompositeGenInfo, thisGenerationInfo, methodGenInfo);
            this.EmitProcessResult(codeGenerationInfo, propertyModel.GetterMethod, publicCompositeGenInfo, thisGenerationInfo, methodGenInfo);

            this.EmitThrowIfViolations(thisGenerationInfo, methodGenInfo, propertyModel.GetterMethod);

            il.EmitLoadLocal(resultB)
            .EmitReturn();
        }
Beispiel #10
0
 /// <summary>
 /// Creates a new instance of <see cref="OpCodeInfoWithFieldToken"/> with specified values.
 /// </summary>
 /// <param name="opCode">The <see cref="OpCode"/> to emit.</param>
 /// <param name="field">The <see cref="CILField"/> to use as operand.</param>
 /// <param name="useGDefIfPossible">
 /// If this is <c>true</c>, and the declaring type of <paramref name="field"/> is generic type definition, and the declaring type of method containing this IL is declaring type of <paramref name="field"/>, then a TypeDef-token will be used instead of TypeSpec when emitting declaring type of the field.
 /// The default behaviour in such scenario is to emit TypeSpec token.
 /// </param>
 /// <exception cref="ArgumentNullException">If <paramref name="field"/> is <c>null</c>.</exception>
 public OpCodeInfoWithFieldToken(OpCode opCode, CILField field, Boolean useGDefIfPossible = false)
     : base(opCode, useGDefIfPossible)
 {
     ArgumentValidator.ValidateNotNull("Field", field);
     this._field = field;
 }
Beispiel #11
0
        protected AbstractCompositeModelTypeCodeGenerator(Boolean isSilverlight, CILReflectionContext aCtx)
        {
            this.isSilverLight = isSilverlight;
            this.ctx           = aCtx;

            this.COMPOSITE_CTOR_PROPERTIES_PARAM_TYPE = COMPOSITE_CTOR_PROPERTIES_PARAM_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.COMPOSITE_CTOR_EVENTS_PARAM_TYPE     = COMPOSITE_CTOR_EVENTS_PARAM_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.ACTION_REF_TYPE       = ACTION_REF_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.ACTION_REF_TYPES_1    = ACTION_REF_TYPES_1_NATIVE.Select(t => t.NewWrapperAsType(ctx)).ToArray();
            this.ACTION_REF_TYPES_2    = ACTION_REF_TYPES_2_NATIVE.Select(t => t.NewWrapperAsType(ctx)).ToArray();
            this.CHECK_STATE_FUNC_TYPE = CHECK_STATE_FUNC_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.PUBLIC_COMPOSITE_CTOR_ADDITTIONAL_PARAM_TYPES = PUBLIC_COMPOSITE_CTOR_ADDITTIONAL_PARAM_TYPES_NATIVE.Select(t => t.NewWrapperAsType(ctx)).ToArray();
            this.ACTION_TYPE                 = ACTION_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.FRAGMENT_DEPENDANT_TYPE     = FRAGMENT_DEPENDANT_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.FIELD_MODEL_TYPE            = FIELD_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.CONSTRUCTOR_MODEL_TYPE      = CONSTRUCTOR_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.PARAMETER_MODEL_TYPE        = PARAMETER_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.SPECIAL_METHOD_MODEL_TYPE   = SPECIAL_METHOD_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.COMPOSITE_METHOD_MODEL_TYPE = COMPOSITE_METHOD_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.CONSTRAINT_MODEL_TYPE       = CONSTRAINT_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.VOID_TYPE      = VOID_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.OBJECT_TYPE    = OBJECT_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.ATTRIBUTE_TYPE = ATTRIBUTE_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.TYPE_TYPE      = TYPE_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.ABSTRACT_INJECTABLE_MODEL_TYPE = ABSTRACT_INJECTABLE_MODEL_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.CONSTRAINT_TYPE = CONSTRAINT_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.INT32_TYPE      = INT32_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.UINT32_TYPE     = UINT32_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.INT64_TYPE      = INT64_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.BOOLEAN_TYPE    = BOOLEAN_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.SINGLE_TYPE     = SINGLE_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.DOUBLE_TYPE     = DOUBLE_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.INT_PTR_TYPE    = INT_PTR_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.STRING_TYPE     = STRING_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.EXCEPTION_TYPE  = EXCEPTION_TYPE_NATIVE.NewWrapperAsType(ctx);
            //this.WEAK_EVENT_WRAPPER_TYPE = WEAK_EVENT_WRAPPER_TYPE_NATIVE.NewWrapperAsType( ctx );
            //this.STRONG_EVENT_WRAPPER_TYPE = STRONG_EVENT_WRAPPER_TYPE_NATIVE.NewWrapperAsType( ctx );
            this.IENUMERABLE_GDEF_TYPE       = IENUMERABLE_GDEF_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.IENUMERABLE_NO_GDEF_TYPE    = IENUMERABLE_NO_GDEF_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.USE_DEFAULTS_ATTRIBUTE_TYPE = USE_DEFAULTS_ATTRIBUTE_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.COMPOSITE_FACTORY_TYPE      = COMPOSITE_FACTORY_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.REF_ACTION_TYPE             = REF_ACTION_TYPE_NATIVE.NewWrapperAsType(ctx);
            this.REF_FUNCTION_TYPE           = REF_FUNCTION_TYPE_NATIVE.NewWrapperAsType(ctx);

            this.APPLICATION_GETTER_METHOD                = APPLICATION_GETTER_METHOD_NATIVE.NewWrapper(ctx);
            this.STRUCTURE_OWNER_GETTER_METHOD            = STRUCTURE_OWNER_GETTER_METHOD_NATIVE.NewWrapper(ctx);
            this.APPLICATION_IS_PASSIVE_GETTER_METHOD     = APPLICATION_IS_PASSIVE_GETTER_METHOD_NATIVE.NewWrapper(ctx);
            this.INJECTION_SERVICE_GETTER_METHOD          = INJECTION_SERVICE_GETTER_METHOD_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_METHOD_MODEL_PARAMETERS_GETTER = COMPOSITE_METHOD_MODEL_PARAMETERS_GETTER_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_METHOD_RESULT_GETTER           = COMPOSITE_METHOD_RESULT_GETTER_NATIVE.NewWrapper(ctx);
            //this.INJECTABLE_MODEL_INJECTION_SCOPES_GETTER = INJECTABLE_MODEL_INJECTION_SCOPES_GETTER_NATIVE.NewWrapper( ctx );
            this.INJECTION_CONTEXT_PROVIDER_METHOD = INJECTION_CONTEXT_PROVIDER_METHOD_NATIVE.NewWrapper(ctx);
            this.OPTIONAL_ATTRIBUTE_FIELD          = OPTIONAL_ATTRIBUTE_FIELD_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_MODELS_GETTER          = CONSTRAINT_MODELS_GETTER_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_ATTRIBUTE_GETTER       = CONSTRAINT_ATTRIBUTE_GETTER_NATIVE.NewWrapper(ctx);
            this.VIOLATIONS_LIST_COUNT_GETTER      = VIOLATIONS_LIST_COUNT_GETTER_NATIVE.NewWrapper(ctx);
            this.METHOD_INFO_NATIVE_GETTER         = METHOD_INFO_NATIVE_GETTER_NATIVE.NewWrapper(ctx);
            this.MODEL_INFO_GETTER = MODEL_INFO_GETTER_NATIVE.NewWrapper(ctx);
            this.MODEL_GETTER      = MODEL_GETTER_NATIVE.NewWrapper(ctx);
            this.C_METHODS_GETTER  = C_METHODS_GETTER_NATIVE.NewWrapper(ctx);
            this.GET_FRAGMENT_INSTANCE_POOL_METHOD = GET_FRAGMENT_INSTANCE_POOL_METHOD_NATIVE.NewWrapper(ctx);
            this.GET_FRAGMENT_INSTANCE_METHOD      = GET_FRAGMENT_INSTANCE_METHOD_NATIVE.NewWrapper(ctx);
            this.TAKE_FRAGMENT_INSTANCE_METHOD     = TAKE_FRAGMENT_INSTANCE_METHOD_NATIVE.NewWrapper(ctx);
            this.RETURN_FRAGMENT_INSTANCE_METHOD   = RETURN_FRAGMENT_INSTANCE_METHOD_NATIVE.NewWrapper(ctx);
            this.SPECIAL_METHODS_GETTER            = SPECIAL_METHODS_GETTER_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_GETTER                              = FRAGMENT_GETTER_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_SETTER                              = FRAGMENT_SETTER_NATIVE.NewWrapper(ctx);
            this.COMPOSITES_GETTER                            = COMPOSITES_GETTER_NATIVE.NewWrapper(ctx);
            this.COMPOSITES_GETTER_INDEXER                    = COMPOSITES_GETTER_INDEXER_NATIVE.NewWrapper(ctx);
            this.TYPE_OBJECT_DICTIONARY_GET_METHOD            = TYPE_OBJECT_DICTIONARY_GET_METHOD_NATIVE.NewWrapper(ctx);
            this.GENERIC_FRAGMENT_METHOD                      = GENERIC_FRAGMENT_METHOD_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATION_CONSTRUCTOR             = CONSTRAINT_VIOLATION_CONSTRUCTOR_NATIVE.NewWrapper(ctx);
            this.ADD_CONSTRAINT_VIOLATION_METHOD              = ADD_CONSTRAINT_VIOLATION_METHOD_NATIVE.NewWrapper(ctx);
            this.F_INSTANCE_SET_NEXT_INFO_METHOD              = F_INSTANCE_SET_NEXT_INFO_METHOD_NATIVE.NewWrapper(ctx);
            this.F_INSTANCE_SET_METHOD_RESULT_METHOD          = F_INSTANCE_SET_METHOD_RESULT_METHOD_NATIVE.NewWrapper(ctx);
            this.F_INSTANCE_GET_NEXT_INFO_METHOD              = F_INSTANCE_GET_NEXT_INFO_METHOD_NATIVE.NewWrapper(ctx);
            this.F_INSTANCE_GET_METHOD_RESULT_METHOD          = F_INSTANCE_GET_METHOD_RESULT_METHOD_NATIVE.NewWrapper(ctx);
            this.STRING_CONCAT_METHOD_3                       = STRING_CONCAT_METHOD_3_NATIVE.NewWrapper(ctx);
            this.STRING_CONCAT_METHOD_2                       = STRING_CONCAT_METHOD_2_NATIVE.NewWrapper(ctx);
            this.METHOD_INFO_GET_GARGS_METHOD                 = METHOD_INFO_GET_GARGS_METHOD_NATIVE.NewWrapper(ctx);
            this.MAKE_GENERIC_METHOD_METHOD                   = MAKE_GENERIC_METHOD_METHOD_NATIVE.NewWrapper(ctx);
            this.INVOKE_METHOD_METHOD                         = INVOKE_METHOD_METHOD_NATIVE.NewWrapper(ctx);
            this.GET_METHDO_GDEF                              = GET_METHDO_GDEF_NATIVE.NewWrapper(ctx);
            this.GET_CTOR_INDEX_METHOD                        = GET_CTOR_INDEX_METHOD_NATIVE.NewWrapper(ctx);
            this.APPLICATION_NOT_ACTIVE_EXCEPTION_CONSTRUCTOR = APPLICATION_NOT_ACTIVE_EXCEPTION_CONSTRUCTOR_NATIVE.NewWrapper(ctx);
            this.GET_CONSTRAINT_INSTANCE_POOL_METHOD          = GET_CONSTRAINT_INSTANCE_POOL_METHOD_NATIVE.NewWrapper(ctx);
            this.TAKE_CONSTRAINT_INSTANCE_METHOD              = TAKE_CONSTRAINT_INSTANCE_METHOD_NATIVE.NewWrapper(ctx);
            this.RETURN_CONSTRAINT_INSTANCE_METHOD            = RETURN_CONSTRAINT_INSTANCE_METHOD_NATIVE.NewWrapper(ctx);
            this.IS_VALID_METHOD                              = IS_VALID_METHOD_NATIVE.NewWrapper(ctx);
            this.TO_STRING_METHOD                             = TO_STRING_METHOD_NATIVE.NewWrapper(ctx);
            this.RETURN_CONCERN_INVOCATION_METHOD             = RETURN_CONCERN_INVOCATION_METHOD_NATIVE.NewWrapper(ctx);
            this.RETURN_SIDE_EFFECT_INVOCATION_METHOD         = RETURN_SIDE_EFFECT_INVOCATION_METHOD_NATIVE.NewWrapper(ctx);
            this.EMPTY_OBJECTS_FIELD                          = EMPTY_OBJECTS_FIELD_NATIVE.NewWrapper(ctx);
            this.LIST_QUERY_ITEM_GETTER                       = LIST_QUERY_ITEM_GETTER_NATIVE.NewWrapper(ctx);
            this.FIELDS_GETTER                                = FIELDS_GETTER_NATIVE.NewWrapper(ctx);
            this.FIELD_SET_VALUE_METHOD                       = FIELD_SET_VALUE_METHOD_NATIVE.NewWrapper(ctx);
            this.PROTOTYPE_ACTION_CONSTRUCTOR                 = PROTOTYPE_ACTION_CONSTRUCTOR_NATIVE.NewWrapper(ctx);
            this.EQUALS_METHOD                                = EQUALS_METHOD_NATIVE.NewWrapper(ctx);
            this.HASH_CODE_METHOD                             = HASH_CODE_METHOD_NATIVE.NewWrapper(ctx);
            this.REFERENCE_EQUALS_METHOD                      = REFERENCE_EQUALS_METHOD_NATIVE.NewWrapper(ctx);
            this.GET_TYPE_METHOD                              = GET_TYPE_METHOD_NATIVE.NewWrapper(ctx);
            this.DELEGATE_COMBINE_METHOD                      = DELEGATE_COMBINE_METHOD_NATIVE.NewWrapper(ctx);
            this.DELEGATE_REMOVE_METHOD                       = DELEGATE_REMOVE_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_METHOD_GDEF     = INTERLOCKED_COMPARE_EXCHANGE_METHOD_GDEF_NATIVE.NewWrapper(ctx);
            this.GET_EVENT_INFO_METHOD                        = GET_EVENT_INFO_METHOD_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_EVENT_CTOR                         = COMPOSITE_EVENT_CTOR_NATIVE.NewWrapper(ctx);
            this.INVALID_OPERATION_EXCEPTION_CTOR_WITH_STRING = INVALID_OPERATION_EXCEPTION_CTOR_WITH_STRING_NATIVE.NewWrapper(ctx);
            this.QNAME_FROM_TYPE_AND_NAME                     = QNAME_FROM_TYPE_AND_NAME_NATIVE.NewWrapper(ctx);
            this.IS_PROTOTYPE_GETTER                          = IS_PROTOTYPE_GETTER_NATIVE.NewWrapper(ctx);
            this.GET_PROPERTY_INFO_METHOD                     = GET_PROPERTY_INFO_METHOD_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_METHODS_INDEXER                    = COMPOSITE_METHODS_INDEXER_NATIVE.NewWrapper(ctx);
            this.EVENT_MODEL_GETTER                           = EVENT_MODEL_GETTER_NATIVE.NewWrapper(ctx);
            this.PROPERTY_MODEL_GETTER                        = PROPERTY_MODEL_GETTER_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_PROPERTY_CTOR                      = COMPOSITE_PROPERTY_CTOR_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_GETTER                       = INVOCATION_INFO_GETTER_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_SETTER                       = INVOCATION_INFO_SETTER_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_CREATOR_CTOR                 = INVOCATION_INFO_CREATOR_CTOR_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_METHOD_GETTER                = INVOCATION_INFO_METHOD_GETTER_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_FRAGMENT_METHOD_MODEL_GETTER = INVOCATION_INFO_FRAGMENT_METHOD_MODEL_GETTER_NATIVE.NewWrapper(ctx);
            this.INVOCATION_INFO_FRAGMENT_METHOD_MODEL_SETTER = INVOCATION_INFO_FRAGMENT_METHOD_MODEL_SETTER_NATIVE.NewWrapper(ctx);
            this.CONCERN_MODELS_GETTER                        = CONCERN_MODELS_GETTER_NATIVE.NewWrapper(ctx);
            this.CONCERN_MODELS_INDEXER                       = CONCERN_MODELS_INDEXER_NATIVE.NewWrapper(ctx);
            this.MIXIN_MODEL_GETTER                           = MIXIN_MODEL_GETTER_NATIVE.NewWrapper(ctx);
            this.SIDE_EFFECT_MODELS_GETTER                    = SIDE_EFFECT_MODELS_GETTER_NATIVE.NewWrapper(ctx);
            this.SIDE_EFFECT_MODELS_INDEXER                   = SIDE_EFFECT_MODELS_INDEXER_NATIVE.NewWrapper(ctx);
            this.COLLECTION_ADD_ONLY_ADD_METHOD               = COLLECTION_ADD_ONLY_ADD_METHOD_NATIVE.NewWrapper(ctx);
            this.ACTION_0_CTOR                                = ACTION_0_CTOR_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_METHOD_GDEF             = INTERLOCKED_EXCHANGE_METHOD_GDEF_NATIVE.NewWrapper(ctx);
            this.GET_INVOCATION_LIST_METHOD                   = GET_INVOCATION_LIST_METHOD_NATIVE.NewWrapper(ctx);
            this.ADD_LAST_METHOD                              = ADD_LAST_METHOD_NATIVE.NewWrapper(ctx);
            //this.WEAK_EVENT_ARRAY_WRAPPER_ARRAY_GETTER = WEAK_EVENT_ARRAY_WRAPPER_ARRAY_GETTER_NATIVE.NewWrapper( ctx );
            //this.WEAK_EVENT_ARRAY_WRAPPER_COUNT_GETTER = WEAK_EVENT_ARRAY_WRAPPER_COUNT_GETTER_NATIVE.NewWrapper( ctx );
            //this.WEAK_EVENT_ARRAY_CLEANUP_METHOD = WEAK_EVENT_ARRAY_CLEANUP_METHOD_NATIVE.NewWrapper( ctx );
            //this.WEAK_EVENT_ARRAY_COMBINE_METHOD = WEAK_EVENT_ARRAY_COMBINE_METHOD_NATIVE.NewWrapper( ctx );
            //this.WEAK_EVENT_ARRAY_REMOVE_METHOD = WEAK_EVENT_ARRAY_REMOVE_METHOD_NATIVE.NewWrapper( ctx );
            //this.IS_EVENT_INFO_DEAD_METHOD = IS_EVENT_INFO_DEAD_METHOD_NATIVE.NewWrapper( ctx );
            //this.EVENT_INFO_TARGET_GETTER = EVENT_INFO_TARGET_GETTER_NATIVE.NewWrapper( ctx );
            //this.EVENT_INFO_METHOD_GETTER = EVENT_INFO_METHOD_GETTER_NATIVE.NewWrapper( ctx );
            //this.EVENT_INFO_CTOR = EVENT_INFO_CTOR_NATIVE.NewWrapper( ctx );
            this.Q_NAME_GET_BARE_TYPE_NAME_METHOD       = Q_NAME_GET_BARE_TYPE_NAME_METHOD_NATIVE.NewWrapper(ctx);
            this.Q_NAME_FROM_MEMBER_INFO_METHOD         = Q_NAME_FROM_MEMBER_INFO_METHOD_NATIVE.NewWrapper(ctx);
            this.INJECTION_EXCEPTION_CTOR               = INJECTION_EXCEPTION_CTOR_NATIVE.NewWrapper(ctx);
            this.CHECK_STATE_METHOD_SIG                 = CHECK_STATE_METHOD_SIG_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_EXCEPTION_VIOLATIONS_GETTER = CONSTRAINT_EXCEPTION_VIOLATIONS_GETTER_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATIONS_DIC_ADD_METHOD   = CONSTRAINT_VIOLATIONS_DIC_ADD_METHOD_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATIONS_DIC_CTOR         = CONSTRAINT_VIOLATIONS_DIC_CTOR_NATIVE.NewWrapper(ctx);
            this.CHECK_ACTION_FUNC_CTOR                 = CHECK_ACTION_FUNC_CTOR_NATIVE.NewWrapper(ctx);
            this.SET_DEFAULTS_METHOD_SIG                = SET_DEFAULTS_METHOD_SIG_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATIONS_LIST_CTOR        = CONSTRAINT_VIOLATIONS_LIST_CTOR_NATIVE.NewWrapper(ctx);
            this.EXCEPTION_LIST_CTOR = EXCEPTION_LIST_CTOR_NATIVE.NewWrapper(ctx);
            this.FUNC_1_CTOR         = FUNC_1_CTOR_NATIVE.NewWrapper(ctx);
            this.FUNC_2_CTOR         = FUNC_2_CTOR_NATIVE.NewWrapper(ctx);
            this.FUNC_3_CTOR         = FUNC_3_CTOR_NATIVE.NewWrapper(ctx);
            this.ACTION_1_CTOR       = ACTION_1_CTOR_NATIVE.NewWrapper(ctx);
            this.LAZY_GDEF_CTOR      = LAZY_GDEF_CTOR_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_INSTANCE_CTOR_NO_PARAMS   = FRAGMENT_INSTANCE_CTOR_NO_PARAMS_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_INSTANCE_CTOR_WITH_PARAMS = FRAGMENT_INSTANCE_CTOR_WITH_PARAMS_NATIVE.NewWrapper(ctx);
            this.MODEL_CTORS_GETTER                 = MODEL_CTORS_GETTER_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_DEPENDANT_GETTER          = FRAGMENT_DEPENDANT_GETTER_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_DEPENDANT_SETTER          = FRAGMENT_DEPENDANT_SETTER_NATIVE.NewWrapper(ctx);
            this.FRAGMENT_DEPENDANT_PROPERTY        = FRAGMENT_DEPENDANT_PROPERTY_NATIVE.NewWrapper(ctx);
            this.CONCERN_INVOCATION_INFO_ITEM_1     = CONCERN_INVOCATION_INFO_ITEM_1_NATIVE.NewWrapper(ctx);
            this.CONCERN_INVOCATION_INFO_ITEM_2     = CONCERN_INVOCATION_INFO_ITEM_2_NATIVE.NewWrapper(ctx);
            this.SIDE_EFFECT_INVOCATION_INFO_ITEM_1 = SIDE_EFFECT_INVOCATION_INFO_ITEM_1_NATIVE.NewWrapper(ctx);
            this.SIDE_EFFECT_INVOCATION_INFO_ITEM_2 = SIDE_EFFECT_INVOCATION_INFO_ITEM_2_NATIVE.NewWrapper(ctx);
            this.SIDE_EFFECT_INVOCATION_INFO_ITEM_3 = SIDE_EFFECT_INVOCATION_INFO_ITEM_3_NATIVE.NewWrapper(ctx);
            this.OBJECT_CTOR             = OBJECT_CTOR_NATIVE.NewWrapper(ctx);
            this.NULLABLE_CTOR           = NULLABLE_CTOR_NATIVE.NewWrapper(ctx);
            this.DEFAULT_CREATOR_GETTER  = DEFAULT_CREATOR_GETTER_NATIVE.NewWrapper(ctx);
            this.DEFAULT_CREATOR_INVOKER = DEFAULT_CREATOR_INVOKER_NATIVE.NewWrapper(ctx);
            this.NO_POOL_ATTRIBUTE_CTOR  = NO_POOL_ATTRIBUTE_CTOR_NATIVE.NewWrapper(ctx);
            this.MAIN_PUBLIC_COMPOSITE_TYPE_ATTRIBUTE_CTOR = MAIN_PUBLIC_COMPOSITE_TYPE_ATTRIBUTE_CTOR_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATION_LIST_CTOR            = CONSTRAINT_VIOLATION_LIST_CTOR_NATIVE.NewWrapper(ctx);
            this.CONSTRAINT_VIOLATION_EXCEPTION_CTOR       = CONSTRAINT_VIOLATION_EXCEPTION_CTOR_NATIVE.NewWrapper(ctx);
            this.INTERNAL_EXCEPTION_CTOR = INTERNAL_EXCEPTION_CTOR_NATIVE.NewWrapper(ctx);
            this.AGGREGATE_EXCEPTION_EXCEPTION_ENUMERABLE_CTOR = AGGREGATE_EXCEPTION_EXCEPTION_ENUMERABLE_CTOR_NATIVE.NewWrapper(ctx);
            this.DEBUGGER_DISPLAY_ATTRIBUTE_STRING_CTOR        = DEBUGGER_DISPLAY_ATTRIBUTE_STRING_CTOR_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_READ_I64_METHOD                 = INTERLOCKED_READ_I64_METHOD_NATIVE == null ? null : INTERLOCKED_READ_I64_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_I32_METHOD             = INTERLOCKED_EXCHANGE_I32_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_I64_METHOD             = INTERLOCKED_EXCHANGE_I64_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_R32_METHOD             = INTERLOCKED_EXCHANGE_R32_METHOD_NATIVE == null ? null : INTERLOCKED_EXCHANGE_R32_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_R64_METHOD             = INTERLOCKED_EXCHANGE_R64_METHOD_NATIVE == null ? null : INTERLOCKED_EXCHANGE_R64_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_INT_PTR_METHOD         = INTERLOCKED_EXCHANGE_INT_PTR_METHOD_NATIVE == null ? null : INTERLOCKED_EXCHANGE_INT_PTR_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_EXCHANGE_OBJECT_METHOD          = INTERLOCKED_EXCHANGE_OBJECT_METHOD_NATIVE == null ? null : INTERLOCKED_EXCHANGE_OBJECT_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_I32_METHOD     = INTERLOCKED_COMPARE_EXCHANGE_I32_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_I64_METHOD     = INTERLOCKED_COMPARE_EXCHANGE_I64_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_R32_METHOD     = INTERLOCKED_COMPARE_EXCHANGE_R32_METHOD_NATIVE == null ? null : INTERLOCKED_COMPARE_EXCHANGE_R32_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_R64_METHOD     = INTERLOCKED_COMPARE_EXCHANGE_R64_METHOD_NATIVE == null ? null : INTERLOCKED_COMPARE_EXCHANGE_R64_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_INT_PTR_METHOD = INTERLOCKED_COMPARE_EXCHANGE_INT_PTR_METHOD_NATIVE == null ? null : INTERLOCKED_COMPARE_EXCHANGE_INT_PTR_METHOD_NATIVE.NewWrapper(ctx);
            this.INTERLOCKED_COMPARE_EXCHANGE_OBJECT_METHOD  = INTERLOCKED_COMPARE_EXCHANGE_OBJECT_METHOD_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_TYPE_ID_CTOR   = COMPOSITE_TYPE_ID_CTOR_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_FACTORY_METHOD = COMPOSITE_FACTORY_METHOD_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_CALLBACK_GET_COMPOSITE_METHOD_METHOD = COMPOSITE_CALLBACK_GET_COMPOSITE_METHOD_METHOD_NATIVE.NewWrapper(ctx);
            this.ARGUMENT_EXCEPTION_STRING_CTOR         = ARGUMENT_EXCEPTION_STRING_CTOR_NATIVE.NewWrapper(ctx);
            this.MAKE_GENERIC_TYPE_METHOD               = MAKE_GENERIC_TYPE_METHOD_NATIVE.NewWrapper(ctx);
            this.GET_FIRST_INSTANCE_CTOR                = GET_FIRST_INSTANCE_CTOR_NATIVE.NewWrapper(ctx);
            this.CONSTRUCTOR_INVOKE_METHOD              = CONSTRUCTOR_INVOKE_METHOD_NATIVE.NewWrapper(ctx);
            this.INT_PTR_SIZE_GETTER                    = INT_PTR_SIZE_GETTER_NATIVE.NewWrapper(ctx);
            this.REF_ACTION_INVOKER                     = REF_ACTION_INVOKER_NATIVE.NewWrapper(ctx);
            this.REF_FUNCTION_INVOKER                   = REF_FUNCTION_INVOKER_NATIVE.NewWrapper(ctx);
            this.REF_INVOKER_CALLBACK_CTOR              = REF_INVOKER_CALLBACK_CTOR_NATIVE.NewWrapper(ctx);
            this.COMPOSITE_METHOD_MODEL_INDEX_ATTRIBUTE = COMPOSITE_METHOD_MODEL_INDEX_ATTRIBUTE_NATIVE.NewWrapper(ctx);
            this.SPECIAL_METHOD_MODEL_INDEX_ATTRIBUTE   = SPECIAL_METHOD_MODEL_INDEX_ATTRIBUTE_NATIVE.NewWrapper(ctx);
            this.CONSTRUCTOR_MODEL_INDEX_ATTRIBUTE      = CONSTRUCTOR_MODEL_INDEX_ATTRIBUTE_NATIVE.NewWrapper(ctx);
            this.DOUBLE_BITS_TO_INT64                   = DOUBLE_BITS_TO_INT64_NATIVE.NewWrapper(ctx);
            this.INT64_BITS_TO_DOUBLE                   = INT64_BITS_TO_DOUBLE_NATIVE.NewWrapper(ctx);
            this.GET_BYTES_INT32  = GET_BYTES_INT32_NATIVE.NewWrapper(ctx);
            this.GET_BYTES_SINGLE = GET_BYTES_INT32_NATIVE.NewWrapper(ctx);
            this.BYTES_TO_INT32   = GET_BYTES_INT32_NATIVE.NewWrapper(ctx);
            this.BYTES_TO_SINGLE  = GET_BYTES_INT32_NATIVE.NewWrapper(ctx);
        }
Beispiel #12
0
        protected virtual void EmitEventInvocationMethodCore(
            EventModel eventModel,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField eventField,
            CILTypeBase fieldType,
            CompositeMethodGenerationInfo invokeMethod,
            CILMethod eventMethodToInvoke,
            Action <LocalBuilder, EventInvocation, Type> actualEventInvoking
            )
        {
            var eventInfo = eventModel.NativeInfo;
            var il        = invokeMethod.IL;

            var eventLB             = il.DeclareLocal(fieldType);
            var afterNullCheckLabel = il.DefineLabel();

            il
            .EmitLoadThisField(eventField)
            .EmitStoreLocal(eventLB)
            .EmitLoadLocal(eventLB)
            .EmitBranch(BranchType.IF_FALSE, afterNullCheckLabel);

            EventInvocation invocationStyle;
            Type            exceptionType;

            this.GetEventInvocationStyle(eventModel, out invocationStyle, out exceptionType);

            actualEventInvoking(eventLB, invocationStyle, exceptionType);

            // Throw exception if needed
            if (EventInvocation.INVOKE_ALL.Equals(invocationStyle))
            {
                // TODO TODO TODO
                this.EmitThrowIfExceptionListHasAny(invokeMethod, exceptionType.GetConstructor(EXCEPTION_ENUMERABLE_ARRAY).NewWrapper(this.ctx));
            }

            if (!VOID_TYPE.Equals(eventMethodToInvoke.GetReturnType()))
            {
                //LocalBuilder amountOfDeadB;
                //if ( invokeMethod.TryGetLocal( LB_AMOUNT_OF_DEAD_EVENT_INFOS, out amountOfDeadB ) )
                //{
                //   il
                //      .EmitLoadLocal( amountOfDeadB )
                //      .EmitBranch( BranchType.IF_FALSE, afterNullCheckLabel );
                //}
                LocalBuilder resultB;
                if (invokeMethod.TryGetLocal(LB_RESULT, out resultB))
                {
                    il.EmitLoadLocal(resultB);
                }
                var returnLabel = il.DefineLabel();
                il
                .EmitBranch(BranchType.ALWAYS, returnLabel)
                .MarkLabel(afterNullCheckLabel)
                .EmitLoadString("The event " + eventInfo.Name + " in ")
                .EmitReflectionObjectOf(TypeGenerationUtils.CreateTypeForEmitting(eventInfo.DeclaringType.NewWrapper(this.ctx), thisGenerationInfo.GenericArguments, null))
                .EmitCall(TO_STRING_METHOD)
                .EmitLoadString(" is not set.")
                .EmitCall(STRING_CONCAT_METHOD_3)
                .EmitThrowNewException(INVALID_OPERATION_EXCEPTION_CTOR_WITH_STRING)
                .MarkLabel(returnLabel);
            }
            else
            {
                il.MarkLabel(afterNullCheckLabel);
            }

            il.EmitReturn();
        }
Beispiel #13
0
        //protected virtual void EmitEventCheckMethodForWeaklyReferencedEvents(
        //   CILField eventField,
        //   MethodIL il
        //   )
        //{
        //   il.EmitLoadThisField( eventField )
        //     .EmitCall( WEAK_EVENT_ARRAY_CLEANUP_METHOD )
        //     .EmitLoadNull()
        //     .EmitCeq()
        //     .EmitLoadInt32( 0 )
        //     .EmitCeq()
        //     .EmitReturn();
        //}

        protected virtual void EmitEventInvocationMethodForStronglyReferencedEvents(
            EventModel eventModel,
            CompositeTypeGenerationInfo thisGenerationInfo,
            CILField eventField,
            CILTypeBase eventType,
            CompositeMethodGenerationInfo invokeMethod,
            CILMethod eventMethodToInvoke
            )
        {
            this.EmitEventInvocationMethodCore(
                eventModel,
                thisGenerationInfo,
                eventField,
                eventType,
                invokeMethod,
                eventMethodToInvoke,
                (eventLB, invocationStyle, exceptionType) =>
            {
                if (EventInvocation.INVOKE_DIRECTLY.Equals(invocationStyle))
                {
                    // Invocation method:
                    // private <return-type> Event<idx>Invoke(<args>)
                    // {
                    //    <event-type> evt = this._event<idx>;
                    //    if (evt != null)
                    //    {
                    //       (return) this._event<idx>(<args>);
                    //    } else <if has return type other than void>
                    //    {
                    //       throw new InvalidOperationException("The event " + <event name> + " is not set.");
                    //    }
                    // }
                    this.EmitEventInvocationWithTryCatchIfNeeded(
                        invocationStyle,
                        exceptionType,
                        invokeMethod,
                        eventMethodToInvoke,
                        il => il.EmitLoadLocal(eventLB),
                        false
                        );
                }
                else
                {
                    var il = invokeMethod.IL;
                    //  foreach ( Delegate handler in evt.GetInvocationList() )
                    //  {
                    //    try
                    //    {
                    //       result = handler(<args>);
                    //    }
                    //    catch ( Exception exc )
                    //    {
                    //      if ( exceptions == null )
                    //      {
                    //         exceptions = new LinkedList<Exception>();
                    //      }
                    //      exceptions.AddLast( exc );
                    //    }
                    //  }
                    var handlersB = invokeMethod.GetOrCreateLocal(LB_EVENT_HANDLERS);
                    il
                    .EmitLoadLocal(eventLB)
                    .EmitCall(GET_INVOCATION_LIST_METHOD)
                    .EmitStoreLocal(handlersB)

                    .EmitSimpleForLoop(
                        il2 =>
                    {
                        // Int32 index = 0;
                        var idxB = invokeMethod.GetOrCreateLocal(LB_INDEX);
                        il2
                        .EmitLoadInt32(0)
                        .EmitStoreLocal(idxB);
                        return(idxB);
                    },
                        (il2, idxB, loopBodyStartLabel) =>
                    {
                        // index < list.Length
                        il2
                        .EmitLoadLocal(idxB)
                        .EmitLoadLocal(handlersB)
                        .EmitLoadArrayLength()
                        .EmitNumericConversion(CILTypeCode.UInt32, CILTypeCode.Int32, false)
                        .EmitBranch(BranchType.IF_FIRST_LESSER_THAN_SECOND, loopBodyStartLabel);
                    },
                        E_MethodIL.EmitLeftPlusPlus,
                        (il2, idxB) =>
                    {
                        this.EmitEventInvocationWithTryCatchIfNeeded(
                            invocationStyle,
                            exceptionType,
                            invokeMethod,
                            eventMethodToInvoke,
                            il3 =>
                        {
                            il3
                            .EmitLoadLocal(handlersB)
                            .EmitLoadLocal(idxB)
                            .EmitLoadElement(handlersB.LocalType)
                            .EmitCastToType(handlersB.LocalType.GetElementType(), eventType);
                        },
                            true
                            );
                    }
                        );
                }
            });
        }