public override void Emit(IlCompilerContext ctx) { _target.Emit(ctx); _value.Emit(ctx); ctx.Il.Emit(OpCodes.Stfld, _field); ctx.StackDepth -= 2; }
public override void Emit(IlCompilerContext ctx) { _expression.Emit(ctx); ctx.StackDepth--; ctx.Il.Emit(OpCodes.Castclass, _type); ctx.StackDepth++; }
public override void Emit(IlCompilerContext ctx) { var field = ctx.SelfType.GetFields(BindingFlagsEx.All)[Index]; ctx.Il.Emit(OpCodes.Ldarg_0); ctx.Il.Emit(OpCodes.Ldfld, field); ctx.StackDepth++; }
public override void Emit(IlCompilerContext ctx) { var ctor = _type.GetConstructor(new Type[] {}); // ReSharper disable once AssignNullToNotNullAttribute ctx.Il.Emit(OpCodes.Newobj, ctor); ctx.StackDepth++; }
public TDel Compile() { var delegateType = typeof(TDel); var invoke = delegateType.GetMethod("Invoke"); var self = BuildSelf(); var selfType = self?.GetType() ?? typeof(object); var parametersWithSelf = GetParameterTypesWithSelf(invoke, selfType); var returnType = invoke.ReturnType; var method = new DynamicMethod("foo", MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parametersWithSelf, typeof(string).Module, true); var il = method.GetILGenerator(); var context = new IlCompilerContext(il, selfType); //declare local variables foreach (var variable in Variables) { il.DeclareLocal(variable.Type()); } //declare "this" method.DefineParameter(0, ParameterAttributes.None, "this"); //declare custom parameters foreach (var parameter in Parameters) { method.DefineParameter(parameter.ParameterIndex, ParameterAttributes.None, parameter.Name); } //emit il code LazyEmits.ForEach(e => e(context)); //we need to return context.Il.Emit(OpCodes.Ret); // Console.WriteLine(context.Il.ToString()); //if we have a return type, it's OK that there is one item on the stack if (returnType != typeof(void)) { context.StackDepth--; } //if the stack is not aligned, there is some error if (context.StackDepth != 0) { throw new NotSupportedException("Stack error"); } var del = (TDel)(object)method.CreateDelegate(typeof(TDel), self); return(del); }
public override void Emit(IlCompilerContext ctx) { foreach (var arg in _args) { arg.Emit(ctx); ctx.StackDepth--; } ctx.Il.EmitCall(OpCodes.Call, _method, null); if (_method.ReturnType != typeof(void)) { ctx.StackDepth++; } }
public override void Emit(IlCompilerContext ctx) { _target.Emit(ctx); ctx.StackDepth--; foreach (var arg in _args) { arg.Emit(ctx); ctx.StackDepth--; } if (_method.IsVirtual) { ctx.Il.EmitCall(OpCodes.Callvirt, _method, null); } else { ctx.Il.EmitCall(OpCodes.Call, _method, null); } if (_method.ReturnType != typeof(void)) { ctx.StackDepth++; } }
public override void Emit(IlCompilerContext ctx) { _value.Emit(ctx); ctx.Il.Emit(OpCodes.Stloc, _variable.VariableIndex); ctx.StackDepth--; }
public override void Emit(IlCompilerContext ctx) { _target.Emit(ctx); ctx.Il.Emit(OpCodes.Ldfld, _field); //we are still at the same stack size as we consumed the target }
public override void Emit(IlCompilerContext ctx) { ctx.Il.Emit(_value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); ctx.StackDepth++; }
public override void Emit(IlCompilerContext ctx) { _expression.Emit(ctx); ctx.Il.Emit(OpCodes.Unbox_Any, _type); }
public override void Emit(IlCompilerContext ctx) { ctx.Il.Emit(OpCodes.Ldloc, VariableIndex); ctx.StackDepth++; }
public abstract void Emit(IlCompilerContext ctx);
public override void Emit(IlCompilerContext ctx) { ctx.Il.Emit(OpCodes.Ldarg, ParameterIndex); ctx.StackDepth++; }