protected void ImplementSetRelation(RelationMember[] relationMembers, FieldInstance[] f_relations) { MethodInstance template_m_setRelation = new MethodInstance(null, typeof(RootCacheValue), typeof(void), "SetRelation", typeof(int), typeof(IObjRef[])); IMethodVisitor mv = VisitMethod(template_m_setRelation); Label l_finish = mv.NewLabel(); for (int relationIndex = 0, size = f_relations.Length; relationIndex < size; relationIndex++) { FieldInstance f_relation = f_relations[relationIndex]; Label l_notEqual = mv.NewLabel(); mv.LoadArg(0); mv.Push(relationIndex); mv.IfCmp(typeof(int), CompareOperator.NE, l_notEqual); mv.PutThisField(f_relation, delegate(IMethodVisitor mg) { mg.LoadArg(1); }); mv.GoTo(l_finish); mv.Mark(l_notEqual); } mv.ThrowException(typeof(ArgumentException), "Given relationIndex not known"); mv.Mark(l_finish); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementGetRelation(RelationMember[] relationMembers, FieldInstance[] f_relations) { MethodInstance template_m_getRelation = new MethodInstance(null, typeof(RootCacheValue), typeof(IObjRef[]), "GetRelation", typeof(int)); IMethodVisitor mv = VisitMethod(template_m_getRelation); if (f_relations.Length > 0) { Label l_default = mv.NewLabel(); Label[] l_relations = new Label[f_relations.Length]; for (int relationIndex = 0, size = l_relations.Length; relationIndex < size; relationIndex++) { l_relations[relationIndex] = mv.NewLabel(); } mv.LoadArg(0); mv.Switch(0, l_relations.Length - 1, l_default, l_relations); for (int relationIndex = 0, size = f_relations.Length; relationIndex < size; relationIndex++) { FieldInstance f_relation = f_relations[relationIndex]; mv.Mark(l_relations[relationIndex]); mv.GetThisField(f_relation); mv.ReturnValue(); } mv.Mark(l_default); } mv.ThrowException(typeof(ArgumentException), "Given relationIndex not known"); mv.PushNull(); mv.ReturnValue(); mv.EndMethod(); }
public virtual void EndMethod() { if (mv != null) { mv.EndMethod(); } }
protected void ImplementToStringMethod(PropertyInstance p_entityEqualsTemplate) { { MethodInstance methodTemplate = new MethodInstance(null, typeof(Object), typeof(String), "ToString"); MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true); if (NewType.GetType(typeof(Object)).Equals(method.Owner) || method.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(methodTemplate); mg.CallThisGetter(p_entityEqualsTemplate); mg.LoadThis(); mg.LoadThis(); mg.InvokeVirtual(entityEquals_toString_Obj); mg.ReturnValue(); mg.EndMethod(); } } { MethodInstance methodTemplate = new MethodInstance(null, typeof(IPrintable), typeof(void), "ToString", typeof(StringBuilder)); MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true); if (method == null || method.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(methodTemplate); mg.CallThisGetter(p_entityEqualsTemplate); mg.LoadThis(); mg.LoadArgs(); mg.InvokeVirtual(entityEquals_toString_Printable); mg.ReturnValue(); mg.EndMethod(); } } }
protected MethodInstance ImplementUsePropertyChangeSupport(PropertyInstance p_propertyChangeTemplate, FieldInstance f_propertyChangeSupport) { MethodInstance m_getPropertyChangeSupport = MethodInstance.FindByTemplate(template_m_usePropertyChangeSupport, true); if (m_getPropertyChangeSupport == null) { // create field that holds propertyChangeSupport f_propertyChangeSupport = ImplementField(f_propertyChangeSupport); IMethodVisitor mg = VisitMethod(template_m_usePropertyChangeSupport); HideFromDebug(mg.Method); Label l_pcsValid = mg.NewLabel(); mg.GetThisField(f_propertyChangeSupport); mg.Dup(); mg.IfNonNull(l_pcsValid); mg.Pop(); // remove 2nd null instance from stack caused by previous dup mg.PutThisField(f_propertyChangeSupport, delegate(IMethodVisitor mg2) { mg.CallThisGetter(p_propertyChangeTemplate); mg.LoadThis(); mg.InvokeVirtual(m_newPropertyChangeSupport); }); mg.GetThisField(f_propertyChangeSupport); mg.Mark(l_pcsValid); mg.ReturnValue(); // return instance already on the stack by both branches mg.EndMethod(); m_getPropertyChangeSupport = mg.Method; } return(m_getPropertyChangeSupport); }
protected void ImplementNotifyPropertyChanged(PropertyInstance p_propertyChangeTemplate, MethodInstance m_getPropertyChangeSupport) { // implement IPropertyChanged foreach (MethodInfo rMethod in typeof(INotifyPropertyChanged).GetMethods()) { MethodInstance existingMethod = MethodInstance.FindByTemplate(rMethod, true); if (existingMethod != null) { continue; } MethodInstance method = new MethodInstance(rMethod); IMethodVisitor mg = VisitMethod(method); mg.CallThisGetter(p_propertyChangeTemplate); // this.propertyChangeSupport mg.CallThisGetter(m_getPropertyChangeSupport); // listener mg.LoadArg(0); if ("add_PropertyChanged".Equals(method.Name)) { // addPropertyChangeListener(propertyChangeSupport, listener) mg.InvokeVirtual(m_addPropertyChangeListener); } else { // removePropertyChangeListener(propertyChangeSupport, listener) mg.InvokeVirtual(m_removePropertyChangeListener); } mg.ReturnValue(); mg.EndMethod(); } }
protected void ImplementCascadeLoadMode() { FieldInstance f_cascadeLoadMode = ImplementField(new FieldInstance(FieldAttributes.Private, "__cascadeLoadMode", typeof(CascadeLoadMode))); ImplementGetter(template_m_getCascadeLoadMode, f_cascadeLoadMode); ImplementSetter(template_m_setCascadeLoadMode, f_cascadeLoadMode); ConstructorInfo[] constructors = State.CurrentType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); for (int a = constructors.Length; a-- > 0;) { ConstructorInstance ci = new ConstructorInstance(constructors[a]); ci = new ConstructorInstance(MethodAttributes.Public, ci.Parameters); IMethodVisitor mv = VisitMethod(ci); mv.LoadThis(); mv.LoadArgs(); mv.InvokeSuperOfCurrentMethod(); mv.PutThisField(f_cascadeLoadMode, delegate(IMethodVisitor mg) { mg.PushEnum(CascadeLoadMode.DEFAULT); }); mv.ReturnValue(); mv.EndMethod(); } }
/** * public boolean hasPendingChanges() { return isToBeUpdated() || isToBeCreated() || isToBeDeleted(); } */ protected void ImplementHasPendingChanges(PropertyInstance p_hasPendingChanges, PropertyInstance p_ToBeUpdated, PropertyInstance p_ToBeCreated, PropertyInstance p_ToBeDeleted) { IMethodVisitor mg = VisitMethod(p_hasPendingChanges.Getter); p_hasPendingChanges = PropertyInstance.FindByTemplate(p_hasPendingChanges, false); p_hasPendingChanges.AddAnnotation(c_ignoreToBeUpdated); p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeCreated.Name); p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeUpdated.Name); p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeDeleted.Name); Label trueLabel = mg.NewLabel(); mg.LoadThis(); mg.InvokeVirtual(p_ToBeUpdated.Getter); mg.IfZCmp(CompareOperator.NE, trueLabel); mg.LoadThis(); mg.InvokeVirtual(p_ToBeCreated.Getter); mg.IfZCmp(CompareOperator.NE, trueLabel); mg.LoadThis(); mg.InvokeVirtual(p_ToBeDeleted.Getter); mg.IfZCmp(CompareOperator.NE, trueLabel); mg.Push(false); mg.ReturnValue(); mg.Mark(trueLabel); mg.Push(true); mg.ReturnValue(); mg.EndMethod(); }
protected void ImplementGetRealType(IPropertyInfo[] property) { IMethodVisitor mv = VisitMethod(template_m_getRealType); mv.Push(property[property.Length - 1].PropertyType); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementCanWrite(IPropertyInfo[] property) { IMethodVisitor mv = VisitMethod(template_m_canWrite); mv.Push(property[property.Length - 1].IsWritable); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementIsToMany(IPropertyInfo[] propertyPath) { IMethodVisitor mv = VisitMethod(template_m_isToMany); mv.Push(ListUtil.IsCollection(propertyPath[propertyPath.Length - 1].PropertyType)); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementGetDeclaringType(IPropertyInfo[] property) { IMethodVisitor mv = VisitMethod(template_m_getDeclaringType); mv.Push(declaringType); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementDefaultConstructor() { IMethodVisitor mv = VisitMethod(ConstructorInstance.defaultConstructor); mv.LoadThis(); mv.InvokeSuperOfCurrentMethod(); mv.ReturnValue(); mv.EndMethod(); }
public virtual MethodInstance ImplementGetter(MethodInstance method, FieldInstance field) { IMethodVisitor mg = VisitMethod(method); mg.GetThisField(field); mg.ReturnValue(); mg.EndMethod(); return(MethodInstance.FindByTemplate(method, false)); }
public void visitEnd() { // AbstractPrivilege.class; MethodInstance template_m_getPrimitivePropertyPrivilege = new MethodInstance(null, typeof(IPrivilege), typeof(IPropertyPrivilege), "GetPrimitivePropertyPrivilege", typeof(int)); MethodInstance template_m_setPrimitivePropertyPrivilege = new MethodInstance(null, MethodAttributes.Family, typeof(void), "SetPrimitivePropertyPrivilege", typeof(int), typeof(IPropertyPrivilege)); MethodInstance template_m_getRelationPropertyPrivilege = new MethodInstance(null, typeof(IPrivilege), typeof(IPropertyPrivilege), "GetRelationPropertyPrivilege", typeof(int)); MethodInstance template_m_setRelationPropertyPrivilege = new MethodInstance(null, MethodAttributes.Family, typeof(void), "SetRelationPropertyPrivilege", typeof(int), typeof(IPropertyPrivilege)); ImplementGetSetPropertyPrivilege(metaData.PrimitiveMembers, template_m_getPrimitivePropertyPrivilege, template_m_setPrimitivePropertyPrivilege); ImplementGetSetPropertyPrivilege(metaData.RelationMembers, template_m_getRelationPropertyPrivilege, template_m_setRelationPropertyPrivilege); { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(bool), "get_CreateAllowed")); mg.Push(create); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(bool), "get_ReadAllowed")); mg.Push(read); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(bool), "get_UpdateAllowed")); mg.Push(update); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(bool), "get_DeleteAllowed")); mg.Push(delete); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(bool), "get_ExecuteAllowed")); mg.Push(execute); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(new MethodInstance(null, typeof(IPrivilege), typeof(IPropertyPrivilege), "GetDefaultPropertyPrivilegeIfValid")); mg.PushNull(); mg.ReturnValue(); mg.EndMethod(); } ImplementConstructor(template_m_setPrimitivePropertyPrivilege, template_m_setRelationPropertyPrivilege); base.VisitEnd(); }
protected void ImplementGetEntityType() { MethodInstance template_m_getEntityType = new MethodInstance(null, typeof(RootCacheValue), typeof(Type), "getEntityType"); IMethodVisitor mv = VisitMethod(template_m_getEntityType); mv.Push(metaData.EntityType); mv.ReturnValue(); mv.EndMethod(); }
protected static void ImplementDefaultDelegatingMethod(IMethodVisitor mg, PropertyInstance p_compositeIdTemplate, PropertyInstance p_idMembers, MethodInstance delegatedMethod) { mg.CallThisGetter(p_compositeIdTemplate); mg.CallThisGetter(p_idMembers); mg.LoadThis(); mg.LoadArgs(); mg.InvokeVirtual(delegatedMethod); mg.ReturnValue(); mg.EndMethod(); }
protected void ImplementSetUninitialized(PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_valueHolderContainerEntry) { { IMethodVisitor mv = VisitMethod(m_template_setUninitialized_Member); mv.CallThisGetter(p_valueHolderContainerEntry); mv.LoadThis(); mv.LoadArgs(); mv.InvokeVirtual(m_vhce_setUninitialized_Member); mv.ReturnValue(); mv.EndMethod(); } }
protected void ImplementGetPrimitive(Member[] primitiveMember, FieldInstance[] f_primitives, FieldInstance[] f_nullFlags) { MethodInstance template_m_getPrimitive = new MethodInstance(null, typeof(RootCacheValue), typeof(Object), "GetPrimitive", typeof(int)); IMethodVisitor mv = VisitMethod(template_m_getPrimitive); if (f_primitives.Length > 0) { Label l_default = mv.NewLabel(); Label[] l_primitives = new Label[f_primitives.Length]; for (int primitiveIndex = 0, size = f_primitives.Length; primitiveIndex < size; primitiveIndex++) { l_primitives[primitiveIndex] = mv.NewLabel(); } mv.LoadArg(0); mv.Switch(0, l_primitives.Length - 1, l_default, l_primitives); for (int primitiveIndex = 0, size = f_primitives.Length; primitiveIndex < size; primitiveIndex++) { FieldInstance f_primitive = f_primitives[primitiveIndex]; FieldInstance f_nullFlag = f_nullFlags[primitiveIndex]; mv.Mark(l_primitives[primitiveIndex]); Label?l_fieldIsNull = null; if (f_nullFlag != null) { l_fieldIsNull = mv.NewLabel(); // only do something if the field is non-null mv.GetThisField(f_nullFlag); mv.IfZCmp(CompareOperator.NE, l_fieldIsNull.Value); } mv.GetThisField(f_primitive); mv.ValueOf(f_primitive.Type.Type); mv.ReturnValue(); if (f_nullFlag != null) { mv.Mark(l_fieldIsNull.Value); mv.PushNull(); } mv.ReturnValue(); } mv.Mark(l_default); } mv.ThrowException(typeof(ArgumentException), "Given relationIndex not known"); mv.PushNull(); mv.ReturnValue(); mv.EndMethod(); }
protected PropertyInstance ImplementTargetCache(PropertyInstance p_valueHolderContainerTemplate) { if (EmbeddedEnhancementHint.HasMemberPath(State.Context)) { PropertyInstance p_rootEntity = EmbeddedTypeVisitor.GetRootEntityProperty(this); PropertyInstance p_targetCache2 = ImplementProperty(p_template_targetCache, delegate(IMethodVisitor mv) { Label l_finish = mv.NewLabel(); mv.CallThisGetter(p_rootEntity); mv.Dup(); mv.IfNull(l_finish); mv.CheckCast(typeof(IValueHolderContainer)); mv.InvokeInterface(p_template_targetCache.Getter); mv.Mark(l_finish); mv.ReturnValue(); }, null); return(p_targetCache2); } ImplementSelfGetter(p_valueHolderContainerTemplate); FieldInstance f_targetCache = ImplementField(new FieldInstance(FieldAttributes.Private, "__targetCache", p_template_targetCache.PropertyType)); PropertyInstance p_targetCache = ImplementProperty(p_template_targetCache, delegate(IMethodVisitor mv) { mv.GetThisField(f_targetCache); mv.ReturnValue(); }, delegate(IMethodVisitor mv) { mv.PutThisField(f_targetCache, delegate(IMethodVisitor mv2) { mv.LoadArg(0); }); mv.ReturnValue(); }); { IMethodVisitor mg = VisitMethod(m_template_getCache); mg.CallThisGetter(p_targetCache); mg.ReturnValue(); mg.EndMethod(); } { IMethodVisitor mg = VisitMethod(m_template_detach); mg.CallThisSetter(p_targetCache, delegate(IMethodVisitor mg2) { mg2.PushNull(); }); mg.ReturnValue(); mg.EndMethod(); } return(p_targetCache); }
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(); }
public MethodInstance ImplementSwitchByIndex(MethodInstance method, String exceptionMessageOnIllegalIndex, int indexSize, ScriptWithIndex script) { IMethodVisitor mv = VisitMethod(method); if (indexSize == 0) { mv.ThrowException(typeof(ArgumentException), exceptionMessageOnIllegalIndex); mv.PushNull(); mv.ReturnValue(); mv.EndMethod(); return(mv.Method); } Label l_default = mv.NewLabel(); Label[] l_fields = new Label[indexSize]; for (int index = 0, size = indexSize; index < size; index++) { l_fields[index] = mv.NewLabel(); } mv.LoadArg(0); mv.VisitTableSwitchInsn(0, l_fields.Length - 1, l_default, l_fields); for (int index = 0, size = l_fields.Length; index < size; index++) { mv.Mark(l_fields[index]); script(mv, index); } mv.Mark(l_default); mv.ThrowException(typeof(ArgumentException), "Given relationIndex not known"); mv.PushNull(); mv.ReturnValue(); mv.EndMethod(); return(mv.Method); }
protected void ImplementGetEntityType(IPropertyInfo[] property) { IMethodVisitor mv = VisitMethod(template_m_getEntityType); Type entityType = this.entityType; IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(entityType, true); if (metaData != null) { entityType = metaData.EntityType; } mv.Push(entityType); mv.ReturnValue(); mv.EndMethod(); }
public virtual MethodInstance ImplementSetter(MethodInstance method, FieldInstance field) { ParamChecker.AssertParamNotNull(method, "method"); ParamChecker.AssertParamNotNull(field, "field"); IMethodVisitor mg = VisitMethod(method); mg.PutThisField(field, delegate(IMethodVisitor mg2) { mg2.LoadArg(0); }); mg.ReturnVoidOrThis(); mg.EndMethod(); return(MethodInstance.FindByTemplate(method, false)); }
protected void ImplementGetBaseType() { MethodInstance getBaseType = MethodInstance.FindByTemplate(template_m_getBaseType, true); if (getBaseType != null) { return; } IBytecodeBehaviorState state = State; IMethodVisitor mg = VisitMethod(template_m_getBaseType); mg.Push(state.OriginalType); mg.ReturnValue(); mg.EndMethod(); }
public virtual PropertyInstance ImplementLazyInitProperty(PropertyInstance property, Script script, params String[] fireThisOnPropertyNames) { FieldInstance field = ImplementField(new FieldInstance(FieldAttributes.Private, "f_" + property.Name, property.PropertyType)); IMethodVisitor mv = VisitMethod(property.Getter); Label returnInstance = mv.NewLabel(); mv.GetThisField(field); mv.IfNonNull(returnInstance); mv.PutThisField(field, script); mv.Mark(returnInstance); mv.GetThisField(field); mv.ReturnValue(); mv.EndMethod(); return(FireThisOnPropertyChange(property, fireThisOnPropertyNames)); }
protected void ImplementConstructor(PropertyInstance p_embeddedMemberTemplate) { HashSet <Member> alreadyHandledFirstMembers = new HashSet <Member>(); List <Script> scripts = new List <Script>(); { Script script = HandleMember(p_embeddedMemberTemplate, metaData.IdMember, alreadyHandledFirstMembers); if (script != null) { scripts.Add(script); } } foreach (Member member in metaData.PrimitiveMembers) { Script script = HandleMember(p_embeddedMemberTemplate, member, alreadyHandledFirstMembers); if (script != null) { scripts.Add(script); } } foreach (RelationMember member in metaData.RelationMembers) { Script script = HandleMember(p_embeddedMemberTemplate, member, alreadyHandledFirstMembers); if (script != null) { scripts.Add(script); } } if (scripts.Count == 0) { return; } OverrideConstructors(delegate(IClassVisitor cv, ConstructorInstance superConstructor) { IMethodVisitor mv = cv.VisitMethod(superConstructor); mv.LoadThis(); mv.LoadArgs(); mv.InvokeSuperOfCurrentMethod(); foreach (Script script in scripts) { script(mv); } mv.ReturnValue(); mv.EndMethod(); }); }
protected void ImplementSetValue(IPropertyInfo[] propertyPath) { IMethodVisitor mv = VisitMethod(template_m_setValue); IPropertyInfo lastProperty = propertyPath[propertyPath.Length - 1]; if (lastProperty is MethodPropertyInfo && ((MethodPropertyInfo)lastProperty).Setter == null) { throw new Exception("Property not writable: " + lastProperty.EntityType.FullName + "." + lastProperty.Name); } mv.LoadArg(0); Type typeOfArgumentOnStack = typeof(Object); for (int a = 0, size = propertyPath.Length - 1; a < size; a++) { typeOfArgumentOnStack = InvokeGetProperty(mv, propertyPath[a], typeOfArgumentOnStack); } if (!lastProperty.DeclaringType.Equals(typeOfArgumentOnStack)) { mv.CheckCast(lastProperty.DeclaringType); } mv.LoadArg(1); Type lastPropertyType = lastProperty.PropertyType; if (lastProperty.PropertyType.IsPrimitive) { Type pType = lastProperty.PropertyType; Label l_valueIsNonNull = mv.NewLabel(); Label l_valueIsValid = mv.NewLabel(); mv.IfNonNull(l_valueIsNonNull); mv.PushNullOrZero(pType); mv.GoTo(l_valueIsValid); mv.Mark(l_valueIsNonNull); mv.LoadArg(1); mv.Unbox(pType); mv.Mark(l_valueIsValid); } else { mv.CheckCast(lastPropertyType); } InvokeSetProperty(mv, lastProperty); mv.ReturnValue(); mv.EndMethod(); }
protected void ImplementHashCodeMethod(PropertyInstance p_entityEqualsTemplate) { MethodInstance methodTemplate = new MethodInstance(null, typeof(Object), typeof(int), "GetHashCode"); MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true); if (NewType.GetType(typeof(Object)).Equals(method.Owner) || method.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(methodTemplate); mg.CallThisGetter(p_entityEqualsTemplate); mg.LoadThis(); mg.LoadArgs(); mg.InvokeVirtual(entityEquals_HashCode); mg.ReturnValue(); mg.EndMethod(); } }
public virtual PropertyInstance ImplementProperty(PropertyInstance property, Script getterScript, Script setterScript) { if (getterScript != null) { IMethodVisitor mv = VisitMethod(property.Getter); getterScript.Invoke(mv); mv.EndMethod(); } if (setterScript != null) { IMethodVisitor mv = VisitMethod(property.Setter); setterScript.Invoke(mv); mv.EndMethod(); } return(PropertyInstance.FindByTemplate(property, false)); }