public override void Generate(EmitStmtContext context)
{
IL = context.ILout;
MarkSequencePoint(context);
EmitExpContext expContext = new EmitExpContext(context);
var True_Label = IL.DefineLabel();
var False_Label = IL.DefineLabel();
generateList(expContext);
generateCount(context);
genInitIndex(context);
generateCondition(context);
IL.Emit(OpCodes.Brfalse, False_Label);
//定义一个标签，表示从下面开始进入循环体
IL.MarkLabel(True_Label);
generateSet(expContext, ValueExp);
EmitHelper.Inc(IL, indexSymbol.VarBuilder);
generateCondition(context);
IL.Emit(OpCodes.Brtrue, True_Label);
IL.MarkLabel(False_Label);
}
void GenenrateSubject(EmitExpContext context)
{
ILGenerator il = context.ILout;
bool isgen = false;
if ((SubjectExp is VarExp))
{
VarExp varexp = SubjectExp as VarExp;
if (ReflectionUtil.IsStruct(varexp.RetType))
{
if (varexp.VarSymbol is SymbolVar)
{
il.Emit(OpCodes.Ldloca, (varexp.VarSymbol as SymbolVar).VarBuilder);
isgen = true;
}
else if (varexp.VarSymbol is SymbolArg)
{
il.Emit(OpCodes.Ldarga, (varexp.VarSymbol as SymbolArg).ArgIndex);
isgen = true;
}
}
}
if (!isgen)
{
SubjectExp.Generate(context);
}
}
protected void generateList(EmitExpContext context, Exp exp)
{
ILGenerator il = context.ILout;
exp.Generate(context); //everyoneExp.Generate(context);
EmitHelper.StormVar(il, listSymbol.VarBuilder);
}
private void GenerateFloat(EmitExpContext context)
{
ILGenerator il = context.ILout;
var value = float.Parse(LiteralValue);
il.Emit(OpCodes.Ldc_R4, value);
}
public override void Generate(EmitExpContext context)
{
var il = NestedMethodContext.EmitContext.CurrentMethodBuilder.GetILGenerator();
EmitStmtContext stmtContext = new EmitStmtContext(NestedMethodContext.EmitContext);
EmitExpContext expContext = new EmitExpContext(stmtContext);
if (retSymbol != null)
{
retSymbol.VarBuilder = il.DeclareLocal(retSymbol.DimType);
}
//GenerateBodyExpHead(context);
BodyExp.Generate(expContext);
if (retSymbol == null)
{
if (BodyExp.RetType != typeof(void))
{
il.Emit(OpCodes.Pop);
}
}
else
{
EmitHelper.StormVar(il, retSymbol.VarBuilder);
}
if (RetType != typeof(void))
{
il.Emit(OpCodes.Ldloc, retSymbol.VarBuilder);
}
il.Emit(OpCodes.Ret);
generateConstructor(context);
NestedType = NestedClassContext.EmitContext.CurrentTypeBuilder.CreateType();
base.GenerateConv(context);
}
protected void genInitIndex(EmitExpContext context)
{
ILGenerator il = context.ILout;
EmitHelper.LoadInt(il, startIndex);
EmitHelper.StormVar(il, indexSymbol.VarBuilder);
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
//var symbols = this.AnalyExpContext.Symbols;
ClassContext classContext = this.AnalyExpContext.ClassContext;
if (classContext.OutClassField == null)
{
if (!ProcDesc.ExMethod.Method.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
}
else
{
if (!ProcDesc.ExMethod.Method.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
EmitHelper.LoadField(il, classContext.OutClassField.GetField()); //il.Emit(OpCodes.Ldfld);
}
}
EmitHelper.CallDynamic(il, ProcDesc.ExMethod);
base.GenerateConv(context);
}
public void GenerateBody(EmitExpContext expContext)
{
var il = expContext.ILout;
MethodInfo method = PropertySymbol.GetProperty().GetSetMethod();
if (ValueExp != null)
{
EmitHelper.EmitThis(il, IsStatic);
ValueExp.Generate(expContext);
EmitHelper.CallDynamic(il, method, true);
}
else
{
if (newCode == 2)
{
var Constructor = ConstructorDesc.Constructor;
EmitHelper.EmitThis(il, IsStatic);
EmitHelper.NewObj(il, Constructor);
EmitHelper.CallDynamic(il, method, true);
}
else if (newCode == 3)
{
var createMethod = ProcDesc.ExMethod;
EmitHelper.EmitThis(il, IsStatic);
EmitHelper.CallDynamic(il, createMethod);
EmitHelper.CallDynamic(il, createMethod);
}
else if (newCode == 4)
{
EmitHelper.EmitThis(il, IsStatic);
EmitHelper.LoadInt(il, 0);
EmitHelper.CallDynamic(il, method, true);
}
}
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
if (LiteralKind == TokenKind.LiteralString)
{
il.Emit(OpCodes.Ldstr, LiteralValue);
}
else if (LiteralKind == TokenKind.NULL)
{
il.Emit(OpCodes.Ldnull);
}
else if (LiteralKind == TokenKind.LiteralInt)
{
GenerateInt(context);
}
else if (LiteralKind == TokenKind.LiteralFloat)
{
GenerateFloat(context);
}
else if (LiteralKind == TokenKind.True || LiteralKind == TokenKind.False)
{
GenerateBool(context);
}
base.GenerateConv(context);
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
var symbols = this.AnalyExpContext.Symbols;
lambdaExp.Generate(context);
LocalBuilder lanmbdaLocalBuilder = il.DeclareLocal(lambdaExp.NestedClassContext.EmitContext.CurrentTypeBuilder);
//il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Newobj, lambdaExp.NewBuilder);
EmitHelper.StormVar(il, lanmbdaLocalBuilder);
EmitOutClass(context, lanmbdaLocalBuilder);
foreach (var field in lambdaExp.Fields.Keys)
{
EmitHelper.LoadVar(il, lanmbdaLocalBuilder);
SymbolInfo inMethodSymbol = symbols.Get(field);
EmitHelper.EmitSymbolGet(il, inMethodSymbol);
il.Emit(OpCodes.Stfld, (lambdaExp.Fields[field] as SymbolDefField).GetField());
}
EmitHelper.LoadVar(il, lanmbdaLocalBuilder);
il.Emit(OpCodes.Ldftn, lambdaExp.NestedMethodContext.EmitContext.CurrentMethodBuilder);
ConstructorInfo[] constructorInfos = lambdaExp.FnRetType.GetConstructors();
il.Emit(OpCodes.Newobj, constructorInfos[0]);
base.GenerateConv(context);
}
void generateSet(EmitExpContext context, Exp valueExpr)
{
EmitHelper.LoadVar(IL, listSymbol.VarBuilder);
EmitHelper.LoadVar(IL, indexSymbol.VarBuilder);
ValueExp.Generate(context);
EmitHelper.CallDynamic(IL, setMethod, ExProperty.IsSelf);
}
private void GenerateInt(EmitExpContext context)
{
ILGenerator il = context.ILout;
int value = int.Parse(LiteralValue);
EmitHelper.LoadInt(il, value);
}
void generateNormal(EmitStmtContext context)
{
ILGenerator il = context.ILout;
EmitExpContext expContext = new EmitExpContext(context);
(LeftToExp as IGenerateSet).GenerateSet(expContext, RightValueExp);
}
public void GenerateGet(EmitExpContext context)
{
ILGenerator il = context.ILout;
MethodInfo getMethod = ExProperty.Property.GetGetMethod();
GenenrateSubject(context);
EmitHelper.CallDynamic(il, getMethod, ExProperty.IsSelf);
}
void generateList(EmitStmtContext context)
{
ILGenerator il = context.ILout;
EmitExpContext expContext = new EmitExpContext(context);
ListExp.Generate(expContext);
EmitHelper.StormVar(il, listSymbol.VarBuilder);
}
protected void generateCount(EmitExpContext context)
{
ILGenerator il = context.ILout;
EmitHelper.LoadVar(il, listSymbol.VarBuilder);
EmitHelper.CallDynamic(il, getCountMethod);
EmitHelper.StormVar(il, countSymbol.VarBuilder);
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
base.GenerateArgsExp(context, OpMethod.GetParameters(), new Exp[] { LeftExp, RightExp });
EmitHelper.CallDynamic(il, OpMethod, true);
base.GenerateConv(context);
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
GenerateSubject(context);
base.GenerateArgsExp(context, ExpProcDesc, searchedProcDesc); //GenerateArgs(context);
EmitHelper.CallDynamic(il, CallExMethod);
base.GenerateConv(context);
}
void genBody(EmitExpContext context)
{
ILGenerator il = context.ILout;
invokeExp.GenerateSubject(context);
generateElement(context);
invokeExp.GenerateArgs(context);
EmitHelper.CallDynamic(il, invokeExp.CallExMethod);
}
public override void Generate(EmitExpContext context)
{
//ILGenerator il = context.ILout;
foreach (var expr in this.InneExps)
{
expr.Generate(context);
}
base.GenerateConv(context);
}
void generateEveryOne(EmitStmtContext context)
{
ILGenerator il = context.ILout;
EveryOneExp everyoneExp = LeftToExp as EveryOneExp;
EmitExpContext expContext = new EmitExpContext(context);
(LeftToExp as IGenerateSet).GenerateSet(expContext, RightValueExp);
}
protected void generateCondition(EmitExpContext context)
{
ILGenerator il = context.ILout;
EmitHelper.LoadVar(il, indexSymbol.VarBuilder);
EmitHelper.LoadVar(il, countSymbol.VarBuilder);
EmitHelper.CallDynamic(il, compareMethod, true);
EmitHelper.LoadInt(il, 1);
il.Emit(OpCodes.Ceq);
}
public void GenerateSet(EmitExpContext context, Exp valueExpr)
{
ILGenerator il = context.ILout;
MethodInfo setMethod = ExProperty.Property.GetSetMethod();
GenenrateSubject(context);
valueExpr.Generate(context);
EmitHelper.CallDynamic(il, setMethod, ExProperty.IsSelf);
}
protected void generateElement(EmitExpContext context)
{
ILGenerator il = context.ILout;
EmitHelper.LoadVar(il, listSymbol.VarBuilder);
EmitHelper.LoadVar(il, indexSymbol.VarBuilder);
EmitHelper.CallDynamic(il, diMethod);
EmitHelper.StormVar(il, elementSymbol.VarBuilder);
EmitHelper.LoadVar(il, elementSymbol.VarBuilder);
}
public void GenerateGet(EmitExpContext context)
{
ILGenerator il = context.ILout;
MethodInfo getMethod = ExProperty.Property.GetGetMethod();
SubjectExp.Generate(context);
ArgExp.RequireType = getMethod.ReturnType;
ArgExp.Generate(context);
EmitHelper.CallDynamic(il, getMethod, ExProperty.IsSelf);
}
public override void Generate(EmitExpContext context)
{
ILGenerator il = context.ILout;
if (!EmitHelper.EmitSymbolGet(il, (SymbolInfo)memberSymbol))
{
throw new CompileException("DirectMemberExp生成失败");
}
base.GenerateConv(context);
}
protected void GenerateArgsExp(EmitExpContext context, TKTProcDesc expProcDesc, TKTProcDesc searchedProcDesc, int size)
{
for (int i = 0; i < size; i++)
{
var arg = expProcDesc.GetArg(i);
var exp = (arg.Value as Exp);
TKTProcArg procArg = searchedProcDesc.GetArg(i);
exp.RequireType = procArg.ArgType;
exp.Generate(context);
}
}
protected void GenerateArgsExp(EmitExpContext context, ParameterInfo[] paramInfos, Exp[] args)
{
var size = paramInfos.Length;
for (int i = 0; i < size; i++)
{
Exp argExp = args[i];
ParameterInfo parameter = paramInfos[i];
argExp.RequireType = parameter.ParameterType;
argExp.Generate(context);
}
}
public override void Generate(EmitStmtContext context)
{
ILGenerator il = context.ILout;
MarkSequencePoint(context);
EmitExpContext expContext = new EmitExpContext(context);
resultExp.Generate(expContext);
if (resultExp.RetType != typeof(void))
{
il.Emit(OpCodes.Pop);
}
}
public override void Generate(EmitStmtContext context)
{
ILGenerator il = context.ILout;
EmitExpContext expContext = new EmitExpContext(context);
il.MarkLabel(CurrentLabel);
Condition.Generate(expContext);
EmitHelper.LoadInt(il, 1);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brfalse, NextLabel);
Body.Generate(context);
il.Emit(OpCodes.Br, EndLabel);
}
