public void ImplementInCil(CompilerState state, Instruction ins) { var argc = ins.Arguments; if (argc == 0) return; if (ins.JustEffect) { state.EmitIgnoreArguments(argc); } else { state.EmitIgnoreArguments(argc - 1); } }
void ICilCompilerAware.ImplementInCil(CompilerState state, Instruction ins) { state.EmitIgnoreArguments(ins.Arguments); state.Il.Emit(OpCodes.Newobj, _channelCtor); PType.PrexoniteObjectTypeProxy._ImplementInCil(state, typeof (Channel)); state.Il.Emit(OpCodes.Newobj, _newPValue); }
public void Implement(CompilerState state, Instruction ins, CompileTimeValue[] staticArgv, int dynamicArgc) { if (dynamicArgc >= 1) { state.EmitIgnoreArguments(dynamicArgc - 1); } else { staticArgv[0].EmitLoadAsPValue(state); } state.EmitLoadLocal(state.SctxLocal); state.Il.EmitCall(OpCodes.Call, OperationMethod, null); }
public virtual void Implement(CompilerState state, Instruction ins, CompileTimeValue[] staticArgv, int dynamicArgc) { if (dynamicArgc >= 2) { state.EmitIgnoreArguments(dynamicArgc - 2); state.EmitStoreLocal(state.PrimaryTempLocal); state.EmitLoadLocal(state.SctxLocal); state.EmitLoadLocal(state.PrimaryTempLocal); } else if (dynamicArgc == 1) { //we can load the second static arg just where we need it state.EmitLoadLocal(state.SctxLocal); staticArgv[0].EmitLoadAsPValue(state); } else { PValue left; PValue right; if (staticArgv[0].TryGetConstant(out left) && staticArgv[1].TryGetConstant(out right)) { //Both operands are constants (remember: static args can also be references) //=> Apply the operator at compile time. var result = Run(state, new[] {left, right}); switch (result.Type.ToBuiltIn()) { case PType.BuiltIn.Real: state.EmitLoadRealAsPValue((double) result.Value); break; case PType.BuiltIn.Int: state.EmitLoadIntAsPValue((int) result.Value); break; case PType.BuiltIn.String: state.EmitLoadStringAsPValue((string) result.Value); break; case PType.BuiltIn.Null: state.EmitLoadNullAsPValue(); break; case PType.BuiltIn.Bool: state.EmitLoadBoolAsPValue((bool) result.Value); break; default: throw new PrexoniteException( string.Format( "The operation {0} is no implemented correctly. Given {1} and {2} it results in the non-constant {3}", GetType().FullName, left, right, result)); } return; //We've already emitted the result. } else { //Load the first operand now, then proceed like for just one static arg staticArgv[0].EmitLoadAsPValue(state); state.EmitLoadLocal(state.SctxLocal); staticArgv[1].EmitLoadAsPValue(state); } } state.Il.EmitCall(OpCodes.Call, OperationMethod, null); }
public override void Implement(CompilerState state, Instruction ins, CompileTimeValue[] staticArgv, int dynamicArgc) { if(dynamicArgc >= 2) { state.EmitIgnoreArguments(dynamicArgc-2); } else if(dynamicArgc == 1) { staticArgv[0].EmitLoadAsPValue(state); } else { staticArgv[0].EmitLoadAsPValue(state); staticArgv[1].EmitLoadAsPValue(state); } state.EmitLoadLocal(state.SctxLocal); state.Il.EmitCall(System.Reflection.Emit.OpCodes.Call, OperationMethod, null); }
public void ImplementInCil(CompilerState state, Instruction ins) { var argc = ins.Arguments; if (argc > 1) state.EmitIgnoreArguments(argc - 1); state.EmitLoadLocal(state.SctxLocal); if (argc == 0) state.EmitLoadNullAsPValue(); state.EmitCall(_createConstFunction); }
/// <summary> /// Provides a custom compiler routine for emitting CIL byte code for a specific instruction. /// </summary> /// <param name = "state">The compiler state.</param> /// <param name = "ins">The instruction to compile.</param> void ICilCompilerAware.ImplementInCil(CompilerState state, Instruction ins) { var argc = ins.Arguments; if (ins.JustEffect) { state.EmitIgnoreArguments(argc); } else { if (argc > 2) { state.EmitIgnoreArguments(argc - 2); argc = 2; } switch (argc) { case 0: state.EmitLdcI4(0); state.EmitWrapInt(); goto case 1; case 1: state.EmitLoadLocal(state.SctxLocal); state.EmitCall(RunStaticallyNaturalMethod); break; case 2: state.EmitLoadLocal(state.SctxLocal); state.EmitCall(RunStaticallyAnyMethod); break; } } }