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();
}
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 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 Type InvokeGetProperty(IMethodVisitor mv, IPropertyInfo property, Type typeOfArgumentOnStack)
{
if (property is MethodPropertyInfo)
{
MethodInfo method = ((MethodPropertyInfo)property).Getter;
MethodInstance mi = new MethodInstance(method);
if (method.DeclaringType.IsInterface)
{
mv.InvokeInterface(mi);
}
else
{
if (!mi.Owner.Equals(typeOfArgumentOnStack))
{
mv.CheckCast(mi.Owner);
}
mv.InvokeVirtual(mi);
typeOfArgumentOnStack = mi.ReturnType.Type;
}
}
else
{
FieldInfo field = ((FieldPropertyInfo)property).BackingField;
FieldInstance fi = new FieldInstance(field);
mv.GetField(fi);
typeOfArgumentOnStack = fi.Type.Type;
}
return(typeOfArgumentOnStack);
}
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);
}
/**
* 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 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();
}
}
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 ImplementGetRealType(IPropertyInfo[] property)
{
IMethodVisitor mv = VisitMethod(template_m_getRealType);
mv.Push(property[property.Length - 1].PropertyType);
mv.ReturnValue();
mv.EndMethod();
}
protected void ImplementDefaultConstructor()
{
IMethodVisitor mv = VisitMethod(ConstructorInstance.defaultConstructor);
mv.LoadThis();
mv.InvokeSuperOfCurrentMethod();
mv.ReturnValue();
mv.EndMethod();
}
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();
}
public virtual MethodInstance ImplementGetter(MethodInstance method, FieldInstance field)
{
IMethodVisitor mg = VisitMethod(method);
mg.GetThisField(field);
mg.ReturnValue();
mg.EndMethod();
return(MethodInstance.FindByTemplate(method, false));
}
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 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 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 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 InvokeSetProperty(IMethodVisitor mv, IPropertyInfo property)
{
if (property is MethodPropertyInfo)
{
MethodInfo method = ((MethodPropertyInfo)property).Setter;
mv.InvokeVirtual(new MethodInstance(method));
}
else
{
FieldInfo field = ((FieldPropertyInfo)property).BackingField;
mv.PutField(new FieldInstance(field));
}
}
//public IMethodVisitor GetMethodVisitor() { return this; }
//public void VisitStatement(DB_Type type, DB_Member member, DB_BreakStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_BlockSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// EnterBlock();
// foreach (var s in statement.List)
// {
// VisitStatement(type, member,s, statement);
// }
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_DoStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_DoStatementSyntax ss = statement as DB_DoStatementSyntax;
// VisitExp(type, member, statement, ss.Condition,null);
// VisitStatement(type, member, ss.Statement,ss);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ExpressionStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Exp, null);
//}
//void VisitDeclareVairable(DB_Type type, DB_Member method, DB_StatementSyntax statement, VariableDeclarationSyntax Declaration)
//{
// foreach (var e in Declaration.Variables)
// {
// AddLocal(e.Identifier, Finder.FindType(Declaration.Type));
// VisitExp(type, method, statement, e.Initializer,null);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ForStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// EnterBlock();
// DB_ForStatementSyntax ss = statement as DB_ForStatementSyntax;
// if (ss.Declaration != null)
// {
// VisitDeclareVairable(type, member, statement, ss.Declaration);
// }
// VisitExp(type, member, statement, ss.Condition,null);
// foreach (var inc in ss.Incrementors)
// VisitExp(type, member, statement, inc,null);
// VisitStatement(type, member, ss.Statement,statement);
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_IfStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_IfStatementSyntax ss = statement as DB_IfStatementSyntax;
// VisitExp(type, member, statement, ss.Condition,null);
// VisitStatement(type, member, ss.Statement,ss);
// if (ss.Else != null)
// {
// VisitStatement(type, member, ss.Else,ss);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_LocalDeclarationStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_LocalDeclarationStatementSyntax ss = statement as DB_LocalDeclarationStatementSyntax;
// VisitDeclareVairable(type, member, statement, ss.Declaration);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ReturnStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_ReturnStatementSyntax ss = statement as DB_ReturnStatementSyntax;
// if (ss.Expression != null)
// {
// VisitExp(type, member, ss, ss.Expression,null);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_SwitchStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Expression,null);
// EnterBlock();
// foreach (var sec in statement.Sections)
// {
// foreach (var l in sec.Labels)
// {
// VisitExp(type, member, statement, l,null);
// }
// foreach (var s in sec.Statements)
// {
// VisitStatement(type, member, s, statement);
// }
// }
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ThrowStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Expression,null);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_TryStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_TryStatementSyntax ss = statement as DB_TryStatementSyntax;
// VisitStatement(type, member, ss.Block,statement);
// foreach (var c in ss.Catches)
// {
// VisitStatement(type, member, c.Block, statement);
// }
// if (ss.Finally != null)
// VisitStatement(type, member, ss.Finally.Block, statement);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_WhileStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Condition,null);
// VisitStatement(type, member, statement.Statement, statement);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.AssignmentExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.BaseExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.BinaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ConstExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.FieldExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.MethodExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
// VisitExp(type, member, statement, exp.Caller,exp);
// List<DB_Type> argTypes = new List<DB_Type>();
// foreach (var a in exp.Args)
// {
// VisitExp(type, member, statement, a,null);
// }
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ObjectCreateExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
// foreach (var a in exp.Args)
// {
// VisitExp(type, member, statement, a, exp);
// }
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ParenthesizedExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.PostfixUnaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.PrefixUnaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ThisExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ThrowExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.IndifierExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
public void VisitStatement(IMethodVisitor visitor, DB_Type type, DB_Member method, DB_StatementSyntax statement, DB_StatementSyntax outer)
{
if (statement is DB_BlockSyntax)
{
visitor.VisitStatement(type, method, statement as DB_BlockSyntax, outer);
}
else if (statement is DB_IfStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_IfStatementSyntax, outer);
}
else if (statement is DB_ForStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ForStatementSyntax, outer);
}
else if (statement is DB_LocalDeclarationStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_LocalDeclarationStatementSyntax, outer);
}
else if (statement is DB_DoStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_DoStatementSyntax, outer);
}
else if (statement is DB_ExpressionStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ExpressionStatementSyntax, outer);
}
else if (statement is DB_SwitchStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_SwitchStatementSyntax, outer);
}
else if (statement is DB_WhileStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_WhileStatementSyntax, outer);
}
else if (statement is DB_TryStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_TryStatementSyntax, outer);
}
else if (statement is DB_ThrowStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ThrowStatementSyntax, outer);
}
else if (statement is DB_ReturnStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ReturnStatementSyntax, outer);
}
else
{
throw new NotSupportedException("不支持的语句 " + statement.GetType().Name);
}
}
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 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 override IMethodVisitor VisitMethod(MethodAttributes access, String name, NewType returnType, params NewType[] parameters)
{
IBytecodeBehaviorState state = State;
if (state != null)
{
MethodInstance method = new MethodInstance(state.NewType, access, returnType, name, parameters);
((BytecodeBehaviorState)state).MethodImplemented(method);
}
IMethodVisitor mv = base.VisitMethod(access, name, returnType, parameters);
mv.VisitAnnotation(typeof(ByVisitor).GetConstructor(new Type[] { typeof(String) }), ExtractCallingVisitor("VisitMethod"));
return(mv);
}
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();
}
