public void EmitGet()
{
if (IsNested)
{
if (this.NestedFieldSymbol != null)
{
EmitHelper.Emit_LoadThis(IL);
EmitSymbolHelper.EmitLoad(IL, this.NestedFieldSymbol);
base.EmitConv();
}
else if (VarSymbol is SymbolDefProperty)
{
if (this.ClassContext.IsStaticClass == false)
{
EmitHelper.Emit_LoadThis(IL);
EmitHelper.LoadField(IL, this.ClassContext.NestedOutFieldSymbol.Field);
}
EmitSymbolHelper.EmitLoad(IL, VarSymbol);
base.EmitConv();
}
else
{
throw new CompileException();
}
}
else
{
if (EmitSymbolHelper.NeedCallThis(VarSymbol))
{
EmitHelper.Emit_LoadThis(IL);
}
EmitSymbolHelper.EmitLoad(IL, VarSymbol);
base.EmitConv();
}
}
public void EmitLoadLocala()
{
//EmitHelper.LoadVara(IL, LocalVarSymbol.VarBuilder);
if (this.ClassContext is ContextNestedClass)
{
FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
EmitHelper.EmitThis(IL, false);
EmitHelper.LoadFielda(IL, fieldBuilder);
}
else if (LocalVarSymbol.IsReplaceToNestedFiled)
{
FieldBuilder fieldBuilder = this.ProcContext.GetNestedClassContext().GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
ZCLocalVar instanceVar = this.ProcContext.NestedInstance;
EmitSymbolHelper.EmitLoad(IL, LocalVarSymbol);
EmitHelper.LoadFielda(IL, fieldBuilder);
}
else
{
//EmitGetLocal();
EmitHelper.LoadVara(IL, LocalVarSymbol.VarBuilder);
}
}
//private void EmitGetNested()
//{
// if (this.NestedFieldSymbol != null)
// {
// EmitHelper.EmitThis(IL, false);
// EmitSymbolHelper.EmitLoad(IL, this.NestedFieldSymbol);
// base.EmitConv();
// }
// else
// {
// throw new CCException();
// }
//}
public override void EmitSet(Exp valueExp)
{
if (this.ClassContext is ContextNestedClass)
{
FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
EmitHelper.EmitThis(IL, false);
EmitValueExp(valueExp);
EmitHelper.StormField(IL, fieldBuilder);
}
else if (LocalVarSymbol.IsReplaceToNestedFiled)
{
ZCClassInfo classType = this.ProcContext.GetNestedClassContext().GetZCompilingType();
FieldBuilder fieldBuilder = classType.SearchDeclaredZField(VarName).FieldBuilder;
ZCLocalVar instanceVar = this.ProcContext.NestedInstance;
EmitSymbolHelper.EmitLoad(IL, instanceVar);
EmitValueExp(valueExp);
EmitHelper.StormField(IL, fieldBuilder);
base.EmitConv();
}
else
{
EmitValueExp(valueExp);
EmitSymbolHelper.EmitStorm(IL, LocalVarSymbol);
}
}
public override void Emit()
{
base.EmitArgsExp(new Exp[] { LeftExp, RightExp }, OpMethod);
EmitHelper.CallDynamic(IL, OpMethod);
EmitSymbolHelper.EmitStorm(IL, TempStormLocalVarSymbol);
EmitSymbolHelper.EmitLoad(IL, TempStormLocalVarSymbol);
base.EmitConv();
}
//private void EmitInitLocal(LocalBuilder lanmbdaLocalBuilder)
//{
// for (int i = 0; i < this.lambdaInfo.BodyZVars.Count; i++)
// {
// ZCLocalVar varSymbol = this.lambdaInfo.BodyZVars[i];
// ZCFieldInfo fieldSymbol = lambdaExp.lambdaBody.Get(varSymbol.ZName);
// if (fieldSymbol == null) throw new CCException();
// EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
// EmitSymbolHelper.EmitLoad(IL, varSymbol);
// EmitSymbolHelper.EmitStorm(IL, fieldSymbol);
// }
//}
private void EmitInitOutField(LocalBuilder lanmbdaLocalBuilder)
{
if (this.ExpContext.ClassContext.IsStatic() == false)
{
ZCFieldInfo fieldSymbol = lambdaExp.lambdaBody.OutClassField;
EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
EmitHelper.EmitThis(IL, false);
EmitSymbolHelper.EmitStorm(IL, fieldSymbol);
}
}
public virtual void EmitSetNestedProperty(Exp valueExp)
{
bool isstatic = GetIsStatic();
MethodInfo setMethod = GetSetMethod();
EmitHelper.EmitThis(IL, false);
EmitSymbolHelper.EmitLoad(IL, LambdaThis);
EmitValueExp(valueExp);
EmitHelper.CallDynamic(IL, setMethod);
}
public override void EmitSet(Exp valueExp)
{
if (this.ClassContext is ContextNestedClass)
{
FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
EmitHelper.EmitThis(IL, false);
EmitValueExp(valueExp);
EmitHelper.StormField(IL, fieldBuilder);
base.EmitConv();
}
else
{
EmitValueExp(valueExp);
EmitSymbolHelper.EmitStorm(IL, ArgSymbol);
}
}
public void EmitGet()
{
if (this.ClassContext is ContextNestedClass)
{
FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
EmitHelper.EmitThis(IL, false);
EmitHelper.LoadField(IL, fieldBuilder);
base.EmitConv();
}
else
{
//Console.WriteLine(ArgSymbol.EmitIndex);
EmitSymbolHelper.EmitLoad(IL, ArgSymbol);
base.EmitConv();
}
}
private void EmitLeft()
{
if (SubjectExp.RetType.IsStruct)
{
if (IsNeedTempLocal())
{
SubjectExp.Emit();
EmitSymbolHelper.EmitStorm(IL, this.tempLocal);
EmitSymbolHelper.EmitLoada(IL, this.tempLocal);
}
else
{
if (SubjectExp is ExpLocalVar)
{
((ExpLocalVar)SubjectExp).EmitLoadLocala();
}
else if (SubjectExp is ExpArg)
{
((ExpArg)SubjectExp).EmitLoadArga();
}
else if (SubjectExp is ExpFieldDef)
{
((ExpFieldDef)SubjectExp).EmitLoadFielda();
}
else if (SubjectExp is ExpFieldSuper)
{
((ExpFieldSuper)SubjectExp).EmitLoadFielda();
}
else if (SubjectExp is ExpUseField)
{
((ExpUseField)SubjectExp).EmitLoadFielda();
}
else
{
SubjectExp.Emit();
}
}
}
else
{
SubjectExp.Emit();
}
}
public override void Emit()
{
lambdaExp.Emit();
LocalBuilder lanmbdaLocalBuilder = IL.DeclareLocal(lambdaExp.NestedClassContext.EmitContext.ClassBuilder);
IL.Emit(OpCodes.Newobj, lambdaExp.NewBuilder);
EmitHelper.StormVar(IL, lanmbdaLocalBuilder);
int i = 0;
if (this.ExpContext.ClassContext.IsStaticClass == false)
{
SymbolDefField fieldSymbol = lambdaExp.FieldSymbols[0];
EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
EmitHelper.EmitThis(IL, false);
IL.Emit(OpCodes.Stfld, fieldSymbol.Field);
i++;
}
for (; i < this.BodySymbolVars.Count; i++)
{
SymbolBase thisSymbol = this.BodySymbolVars[i];
SymbolDefField fieldSymbol = lambdaExp.FieldSymbols[i];
EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
//SymbolInfo inMethodSymbol = symbols.Get(field);
//EmitHelper.EmitSymbolGet(IL, thisSymbol);
if (EmitSymbolHelper.NeedCallThis(thisSymbol))
{
EmitHelper.Emit_LoadThis(IL);
}
EmitSymbolHelper.EmitLoad(IL, thisSymbol);
IL.Emit(OpCodes.Stfld, fieldSymbol.Field);
}
EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
IL.Emit(OpCodes.Ldftn, lambdaExp.ProcBuilder);//.EmitContext.CurrentMethodBuilder);
ConstructorInfo[] constructorInfos = lambdaExp.FnRetType.SharpType.GetConstructors();
IL.Emit(OpCodes.Newobj, constructorInfos[0]);
base.EmitConv();
}
private void EmitInitArg(LocalBuilder lanmbdaLocalBuilder)
{
if (this.ProcContext.ArgList.Count > 0)
{
foreach (var arg in this.ProcContext.ArgList)
{
ZCParamInfo paramSymbol = this.ProcContext.GetParameter(arg);
ZCFieldInfo fieldSymbol = this.ProcContext.GetNestedClassContext().MasterArgDict[arg];
EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
EmitSymbolHelper.EmitLoad(IL, paramSymbol);
EmitSymbolHelper.EmitStorm(IL, fieldSymbol);
}
}
//for (int i = 0; i < this.lambdaInfo.BodyZParams.Count; i++)
//{
// ZCParamInfo paramSymbol = this.lambdaInfo.BodyZParams[i];
// ZCFieldInfo fieldSymbol = lambdaExp.lambdaBody.Get(paramSymbol.ZName);
// EmitHelper.LoadVar(IL, lanmbdaLocalBuilder);
// EmitSymbolHelper.EmitLoad(IL, paramSymbol);
// EmitSymbolHelper.EmitStorm(IL, fieldSymbol);
//}
}
private void EmitSetMember()
{
if (memberSymbol is ZLFieldInfo)
{
EmitSymbolHelper.EmitStorm(IL, (ZLFieldInfo)memberSymbol);
}
else if (memberSymbol is ZCFieldInfo)
{
EmitSymbolHelper.EmitStorm(IL, (ZCFieldInfo)memberSymbol);
}
else if (memberSymbol is ZLPropertyInfo)
{
EmitSymbolHelper.EmitStorm(IL, (ZLPropertyInfo)memberSymbol);
}
else if (memberSymbol is ZCPropertyInfo)
{
EmitSymbolHelper.EmitStorm(IL, (ZCPropertyInfo)memberSymbol);
}
else
{
throw new CCException();
}
}
