public virtual void Box(Type unboxedType) { if (mv != null) { mv.Box(unboxedType); } }
protected void ImplementGetNullEquivalentValue(IPropertyInfo[] property) { IMethodVisitor mv = VisitMethod(template_m_getNullEquivalentValue); Type propertyType = property[property.Length - 1].PropertyType; mv.PushNullOrZero(propertyType); if (propertyType.IsPrimitive) { mv.Box(propertyType); } mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementPropertyChangeOnProperty(PropertyInstance propertyInfo, PropertyInstance p_propertyChangeTemplate, MethodInstance m_firePropertyChange, FieldInstance f_propertyChangeSupport) { // add property change detection and notification if (propertyInfo.Getter == null || propertyInfo.Setter == null) { return; } if (InitializeEmbeddedMemberVisitor.IsEmbeddedMember(metaData, propertyInfo.Name)) { return; } PropertyInstance p_getterMethodHandle = ImplementAssignedReadonlyProperty(propertyInfo.Name + "$MethodHandle", new MethodHandleValueResolver(PropertyInfoProvider, propertyInfo.Name)); Type propertyType = propertyInfo.PropertyType.Type; MethodInstance m_hasPropertyChanged = GetApplicableHasPropertyChangedOverload(propertyType); // check value type of last parameter bool isBoxingNeededForHasPropertyChanged = IsBoxingNeededForHasPropertyChangedOverload(m_hasPropertyChanged, propertyType); IMethodVisitor mg = VisitMethod(propertyInfo.Setter); Label l_finish = mg.NewLabel(); Label l_noOldValue = mg.NewLabel(); Label l_noChangeCheck = mg.NewLabel(); LocalVariableInfo loc_oldValue; if (isBoxingNeededForHasPropertyChanged) { loc_oldValue = mg.NewLocal(typeof(Object)); } else { loc_oldValue = mg.NewLocal(propertyType); } LocalVariableInfo loc_valueChanged = mg.NewLocal <bool>(); MethodInstance m_getSuper = EnhancerUtil.GetSuperGetter(propertyInfo); bool relationProperty = m_getSuper.Name.EndsWith(ValueHolderIEC.GetNoInitSuffix()); // initialize flag with false mg.Push(false); mg.StoreLocal(loc_valueChanged); // initialize oldValue with null mg.PushNullOrZero(loc_oldValue.LocalType); mg.StoreLocal(loc_oldValue); if (relationProperty) { // check if a setter call to an UNINITIALIZED relation occured with value null // if it the case there would be no PCE because oldValue & newValue are both null // but we need a PCE in this special case Label l_noSpecialHandling = mg.NewLabel(); FieldInstance f_state = State.GetAlreadyImplementedField(ValueHolderIEC.GetInitializedFieldName(propertyInfo.Name)); mg.GetThisField(f_state); mg.PushEnum(ValueHolderState.INIT); mg.IfCmp(typeof(ValueHolderState), CompareOperator.EQ, l_noSpecialHandling); mg.Push(true); mg.StoreLocal(loc_valueChanged); mg.Mark(l_noSpecialHandling); } // check if value should be checked to decide for a PCE mg.LoadLocal(loc_valueChanged); mg.IfZCmp(CompareOperator.NE, l_noOldValue); // get old field value calling super property getter mg.LoadThis(); mg.InvokeOnExactOwner(m_getSuper); if (isBoxingNeededForHasPropertyChanged) { mg.Box(propertyType); } mg.StoreLocal(loc_oldValue); mg.Mark(l_noOldValue); // set new field value calling super property setter mg.LoadThis(); mg.LoadArg(0); mg.InvokeOnExactOwner(EnhancerUtil.GetSuperSetter(propertyInfo)); mg.PopIfReturnValue(EnhancerUtil.GetSuperSetter(propertyInfo)); // check if value should be checked to decide for a PCE mg.LoadLocal(loc_valueChanged); mg.IfZCmp(CompareOperator.NE, l_noChangeCheck); LocalVariableInfo loc_newValue = null; if (isBoxingNeededForHasPropertyChanged) { loc_newValue = mg.NewLocal(typeof(Object)); // loc_1 Object newValue // Object loc_1 = (Object)value; mg.LoadArg(0); mg.Box(propertyType); mg.StoreLocal(loc_newValue); } mg.CallThisGetter(p_propertyChangeTemplate); // call HasPropertyChanged (static) mg.LoadThis(); // "this" as Object obj mg.Push(propertyInfo.Name); // String propertyName mg.LoadLocal(loc_oldValue); if (loc_newValue != null) { mg.LoadLocal(loc_newValue); } else { mg.LoadArg(0); } mg.InvokeVirtual(m_hasPropertyChanged); //// if (!result) //// { return; } mg.IfZCmp(CompareOperator.EQ, l_finish); mg.Mark(l_noChangeCheck); // call firePropertyChange on this mg.LoadThis(); // propertyChangeSupport mg.GetThisField(f_propertyChangeSupport); // property mg.CallThisGetter(p_getterMethodHandle); // oldValue mg.LoadLocal(loc_oldValue); if (!isBoxingNeededForHasPropertyChanged && propertyType.IsValueType) { // old value has not already been boxed but it is now necessary mg.ValueOf(propertyType); } // newValue if (loc_newValue != null) { mg.LoadLocal(loc_newValue); } else { mg.LoadArg(0); if (propertyType.IsValueType) { mg.ValueOf(propertyType); } } // firePropertyChange(propertyChangeSupport, property, oldValue, newValue) mg.InvokeVirtual(m_firePropertyChange); // return mg.Mark(l_finish); mg.ReturnVoidOrThis(); mg.EndMethod(); }
protected void ImplementGetValueIntern(MethodInstance template_m_getValue, IPropertyInfo[] propertyPath) { IMethodVisitor mv = VisitMethod(template_m_getValue); Type declaringType = propertyPath[0].EntityType; Label l_finish = mv.NewLabel(); mv.LoadArg(0); Type typeOfArgumentOnStack = typeof(Object); for (int a = 0, size = propertyPath.Length - 1; a < size; a++) { typeOfArgumentOnStack = InvokeGetProperty(mv, propertyPath[a], typeOfArgumentOnStack); mv.Dup(); mv.IfNull(l_finish); } IPropertyInfo lastProperty = propertyPath[propertyPath.Length - 1]; typeOfArgumentOnStack = InvokeGetProperty(mv, lastProperty, typeOfArgumentOnStack); if (lastProperty.PropertyType.IsPrimitive) { Type pType = lastProperty.PropertyType; LocalVariableInfo loc_value = mv.NewLocal(pType); mv.StoreLocal(loc_value); mv.LoadLocal(loc_value); Label l_valueIsNonZero = mv.NewLabel(); mv.IfZCmp(pType, CompareOperator.NE, l_valueIsNonZero); if (mv.Method.Parameters.Length == 2) { Label l_nullAllowed = mv.NewLabel(); // check null-equi flag mv.LoadArg(1); mv.IfZCmp(CompareOperator.EQ, l_nullAllowed); mv.PushNullOrZero(pType); if (!mv.Method.ReturnType.Type.IsValueType) { mv.ValueOf(pType); } mv.ReturnValue(); mv.Mark(l_nullAllowed); } mv.PushNullOrZero(mv.Method.ReturnType); mv.ReturnValue(); mv.Mark(l_valueIsNonZero); mv.LoadLocal(loc_value); mv.ValueOf(pType); } else if (lastProperty.PropertyType.IsValueType) { Type pType = lastProperty.PropertyType; MethodInfo m_hasValue = pType.GetMethod("get_HasValue"); if (m_hasValue != null) { LocalVariableInfo loc_value = mv.NewLocal(pType); mv.StoreLocal(loc_value); mv.LoadLocal(loc_value); MethodInfo m_getValue = pType.GetMethod("get_Value"); LocalVariableInfo loc_realValue = mv.NewLocal(m_getValue.ReturnType); Label l_hasNoValue = mv.NewLabel(); mv.InvokeOnExactOwner(m_hasValue); mv.IfZCmp(CompareOperator.EQ, l_hasNoValue); mv.LoadLocal(loc_value); mv.InvokeOnExactOwner(m_getValue); mv.StoreLocal(loc_realValue); mv.LoadLocal(loc_realValue); mv.IfZCmp(CompareOperator.EQ, l_hasNoValue); mv.LoadLocal(loc_realValue); if (!mv.Method.ReturnType.Type.IsValueType) { mv.ValueOf(m_getValue.ReturnType); } mv.ReturnValue(); mv.Mark(l_hasNoValue); if (mv.Method.Parameters.Length == 2) { Label l_nullEquivalentValueAllowed = mv.NewLabel(); // check null-equi flag mv.LoadArg(1); mv.IfZCmp(CompareOperator.NE, l_nullEquivalentValueAllowed); mv.PushNull(); mv.ReturnValue(); mv.Mark(l_nullEquivalentValueAllowed); } mv.PushNullOrZero(m_getValue.ReturnType); if (!mv.Method.ReturnType.Type.IsValueType) { mv.ValueOf(m_getValue.ReturnType); } } else { mv.Box(pType); } } mv.Mark(l_finish); mv.ReturnValue(); mv.EndMethod(); }