//public static bool CanBuildOnTerrain(BuildableDef entDef, IntVec3 c, Map map, Rot4 rot, Thing thingToIgnore = null, ThingDef stuffDef = null) public static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions, MethodBase method) { LocalVariableInfo posInfo = method.GetMethodBody().LocalVariables.First(lv => lv.LocalType == typeof(IntVec3)); MethodInfo ContainsInfo = AccessTools.Method(typeof(List <TerrainAffordanceDef>), nameof(List <TerrainAffordanceDef> .Contains)); bool firstOnly = true; foreach (CodeInstruction i in instructions) { if (i.Calls(ContainsInfo) && firstOnly) { firstOnly = false; yield return(new CodeInstruction(OpCodes.Ldloc, posInfo.LocalIndex)); //IntVec3 pos yield return(new CodeInstruction(OpCodes.Ldarg_2)); //Map yield return(new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(CanPlaceBlueprint), nameof(TerrainOrBridgesCanDo)))); } else { yield return(i); } } }
public void EmitIncLocalVar(LocalVariableInfo localVariableInfo, IncDecOperators @operator) { switch (@operator) { case IncDecOperators.PostInc: ilGenerator.Emit(OpCodes.Dup); ilGenerator.Emit(OpCodes.Ldc_I4_1); ilGenerator.Emit(OpCodes.Add); ilGenerator.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case IncDecOperators.PostDec: ilGenerator.Emit(OpCodes.Dup); ilGenerator.Emit(OpCodes.Ldc_I4_1); ilGenerator.Emit(OpCodes.Sub); ilGenerator.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case IncDecOperators.PreInc: ilGenerator.Emit(OpCodes.Ldc_I4_1); ilGenerator.Emit(OpCodes.Add); ilGenerator.Emit(OpCodes.Dup); ilGenerator.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case IncDecOperators.PreDec: ilGenerator.Emit(OpCodes.Ldc_I4_1); ilGenerator.Emit(OpCodes.Sub); ilGenerator.Emit(OpCodes.Dup); ilGenerator.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; } }
public ProjectingLocalVariableInfo(LocalVariableInfo variable, Projector projector) : base(variable) { Contract.Requires(null != projector); _projector = projector; }
public void AddIncLocalVar(LocalVariableInfo localVariableInfo, Parser.IncDecOps incOp) { switch (incOp) { case Parser.IncDecOps.PostInc: il.Emit(OpCodes.Dup); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Add); il.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case Parser.IncDecOps.PostDec: il.Emit(OpCodes.Dup); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Sub); il.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case Parser.IncDecOps.PreInc: il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Add); il.Emit(OpCodes.Dup); il.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; case Parser.IncDecOps.PreDec: il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Sub); il.Emit(OpCodes.Dup); il.Emit(OpCodes.Stloc, (LocalBuilder)localVariableInfo); break; } }
void CheckIfZero(CompilerState state, LocalVariableInfo local) { if (state == null) { throw new Exception(); } if (local == null) { throw new Exception(); } if (local.LocalType == typeof(Int32)) { LoadLocalVariable(state, local); state.Generator.Emit(OpCodes.Ldc_I4_0); state.Generator.Emit(OpCodes.Beq, state.ErrorLabel); } if (local.LocalType == typeof(Single)) { LoadLocalVariable(state, local); state.Generator.Emit(OpCodes.Ldc_R4, 0.0f); state.Generator.Emit(OpCodes.Beq, state.ErrorLabel); } }
public static void CacheModificationInternalUpdate(PropertyInstance p_cacheModification, IMethodVisitor mg, Script script) { LocalVariableInfo loc_cacheModification = mg.NewLocal <ICacheModification>(); LocalVariableInfo loc_oldActive = mg.NewLocal <bool>(); // ICacheModification cacheModification = this.cacheModification; mg.CallThisGetter(p_cacheModification); mg.StoreLocal(loc_cacheModification); // boolean oldInternalUpdate = cacheModification.isInternalUpdate(); mg.LoadLocal(loc_cacheModification); mg.InvokeInterface(new MethodInstance(null, typeof(ICacheModification), typeof(bool), "get_InternalUpdate")); mg.StoreLocal(loc_oldActive); // callModificationInternalUpdate(cacheModification, oldInternalUpdate, true) mg.LoadLocal(loc_cacheModification); mg.LoadLocal(loc_oldActive); mg.Push(true); mg.InvokeStatic(m_callCacheModificationInternalUpdate); mg.TryFinally(script, delegate(IMethodVisitor mv2) { // callModificationInternalUpdate(cacheModification, oldInternalUpdate, false) mv2.LoadLocal(loc_cacheModification); mv2.LoadLocal(loc_oldActive); mv2.Push(false); mv2.InvokeStatic(m_callCacheModificationInternalUpdate); }); }
//public override void DrawMouseAttachments() public static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions, MethodBase method, ILGenerator generator) { LocalVariableInfo posInfo = method.GetMethodBody().LocalVariables.First(lv => lv.LocalType == typeof(Vector2)); LocalVariableInfo curYInfo = method.GetMethodBody().LocalVariables.First(lv => lv.LocalType == typeof(float)); FieldInfo StuffInfo = AccessTools.Field(typeof(Designator_Build), "stuffDef"); List <CodeInstruction> instList = instructions.ToList(); for (int i = 0; i < instList.Count - 1; i++) { yield return(instList[i]); } //after the for loop but before the ret call yield return(new CodeInstruction(OpCodes.Ldarg_0)); //Designator_Build yield return(new CodeInstruction(OpCodes.Ldloc_S, posInfo.LocalIndex)); //pos yield return(new CodeInstruction(OpCodes.Ldloc_S, curYInfo.LocalIndex)); //y yield return(new CodeInstruction(OpCodes.Ldarg_0)); //Designator_Build yield return(new CodeInstruction(OpCodes.Ldfld, StuffInfo)); //Designator_Build.stuffDef yield return(new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(DesignatorBuildCostCountsBridges), nameof(DrawBridgeCost)))); //DrawBridgeCost(Designator_Build, pos, curY, stuffDef) yield return(instList[instList.Count - 1]); }
void StoreLocalVariable(CompilerState state, LocalVariableInfo local) { if (state == null) { throw new Exception(); } if (local == null) { throw new Exception(); } switch (local.LocalIndex) { case 0: state.Generator.Emit(OpCodes.Stloc_0); break; case 1: state.Generator.Emit(OpCodes.Stloc_1); break; case 2: state.Generator.Emit(OpCodes.Stloc_2); break; case 3: state.Generator.Emit(OpCodes.Stloc_3); break; default: state.Generator.Emit(OpCodes.Stloc, local.LocalIndex); break; } }
public void ToElementForLocalVariableInfoReturnsTheCorrectElement() { LocalVariableInfo expected = TypeWithAllElements.LocalVariableInfo; LocalVariableInfoElement actual = expected.ToElement(); Assert.Equal(new LocalVariableInfoElement(expected), actual); }
public void LoadLocal(LocalVariableInfo localIndex) { if (!localIndex.LocalType.IsPrimitive && localIndex.LocalType.IsValueType) { gen.Emit(OpCodes.Ldloca, localIndex.LocalIndex); return; } switch (localIndex.LocalIndex) { case 0: gen.Emit(OpCodes.Ldloc_0); break; case 1: gen.Emit(OpCodes.Ldloc_1); break; case 2: gen.Emit(OpCodes.Ldloc_2); break; case 3: gen.Emit(OpCodes.Ldloc_3); break; default: gen.Emit(OpCodes.Ldloc, (LocalBuilder)localIndex); break; } }
public ProjectingLocalVariableInfo(LocalVariableInfo variable, Projector projector) : base(variable) { Debug.Assert(null != projector); _projector = projector; }
public virtual void StoreLocal(LocalVariableInfo localIndex) { switch (localIndex.LocalIndex) { case 0: gen.Emit(OpCodes.Stloc_0); break; case 1: gen.Emit(OpCodes.Stloc_1); break; case 2: gen.Emit(OpCodes.Stloc_2); break; case 3: gen.Emit(OpCodes.Stloc_3); break; default: gen.Emit(OpCodes.Stloc, (LocalBuilder)localIndex); break; } }
internal static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions, MethodBase original) { MethodBase patch = AccessTools.Method(typeof(Patch_OvererlayModesConduitMode_Update), nameof(PatchThermalColor)); //SaveLoadRoot layerTarget; int layerTargetIdx = 12; //Color32 color; int tintColourIdx = 14; bool foundVar = false; LocalVariableInfo layerTargetInfo = original.GetMethodBody().LocalVariables.FirstOrDefault(x => x.LocalIndex == layerTargetIdx); foundVar = layerTargetInfo != default(LocalVariableInfo); if (!foundVar) { Debug.LogError($"[Pressurized] OverlayModes.ConduitMode.Update() Transpiler -> Local variable signatures did not match expected signatures"); } foreach (CodeInstruction code in instructions) { if (foundVar && code.opcode == OpCodes.Stloc_S && (code.operand as LocalVariableInfo)?.LocalIndex == tintColourIdx) { //PatchThermalColor(color, layerTarget) yield return(new CodeInstruction(OpCodes.Ldloc_S, layerTargetIdx)); yield return(new CodeInstruction(OpCodes.Call, patch)); } yield return(code); } }
public virtual void StoreLocal(LocalVariableInfo localIndex) { if (mv != null) { mv.StoreLocal(localIndex); } }
private LocalVariableInfo EmitUnaryOperator(CompilerState state, Node node) { if (state == null) { throw new Exception(); } if (node == null) { throw new Exception(); } var data = node.Token.Data as Tokenizing.OperatorData; if (data == null) { throw new Exception(); } if (node.Children.Count != 1) { throw new Exception(); } if (data.Operator == Operator.Minus) { var value = Emit(state, node.Children[0]); LocalVariableInfo result = state.Generator.DeclareLocal(value.LocalType); LoadLocalVariable(state, value); state.Generator.Emit(OpCodes.Neg); StoreLocalVariable(state, result); return(result); } if (data.Operator == Operator.LogicalNot) { var value = Emit(state, node.Children[0]); LoadLocalVariable(state, value); LocalVariableInfo result = state.Generator.DeclareLocal(typeof(int)); var l1 = state.Generator.DefineLabel(); var l2 = state.Generator.DefineLabel(); state.Generator.Emit(OpCodes.Brtrue, l1); state.Generator.Emit(OpCodes.Ldc_I4_1); state.Generator.Emit(OpCodes.Br, l2); state.Generator.MarkLabel(l1); state.Generator.Emit(OpCodes.Ldc_I4_0); state.Generator.MarkLabel(l2); StoreLocalVariable(state, result); return(result); } throw new Exception(); }
LocalVariableInfo EmitFunction(CompilerState state, Node node) { if (state == null) { throw new Exception(); } if (node == null) { throw new Exception(); } Evaluation.Tokenizing.CustomFunctionData data = node.Token.Data as Evaluation.Tokenizing.CustomFunctionData; if (data == null) { throw new Exception(); } if (data.Type == typeof(Triggers.Const) || data.Type == typeof(Triggers.GetHitVar)) { return(EmitSpecialFunction(state, data.Type, (String)node.Arguments[0])); } List <LocalVariableInfo> functionargs = EmitDescendants(state, node); MethodInfo method = FindCorrectMethod(data.Type, functionargs); ParameterInfo[] parameters = method.GetParameters(); LoadLocalVariable(state, state.FunctionState); state.Generator.Emit(OpCodes.Ldloca, state.ErrorVariable.LocalIndex); for (Int32 i = 0; i != functionargs.Count; ++i) { LocalVariableInfo arg = functionargs[i]; ParameterInfo parameter = parameters[i + 2]; LoadLocalVariable(state, arg); //if (parameter.ParameterType == typeof(Int32) && arg.LocalType == typeof(Single)) state.Generator.Emit(OpCodes.Conv_I4); //if (parameter.ParameterType == typeof(Single) && arg.LocalType == typeof(Int32)) state.Generator.Emit(OpCodes.Conv_R4); } state.Generator.Emit(OpCodes.Call, method); Type returntype = method.ReturnType; if (returntype == typeof(Boolean)) { returntype = typeof(Int32); } LocalVariableInfo result = state.Generator.DeclareLocal(returntype); StoreLocalVariable(state, result); LoadLocalVariable(state, state.ErrorVariable); state.Generator.Emit(OpCodes.Brtrue, state.ErrorLabel); return(result); }
/// <summary> /// Constructs a new instance of the <see cref="LocalVariableInfoElement"/> which represents /// the specified <see cref="System.Reflection.LocalVariableInfo"/>. /// </summary> /// <param name="localVariableInfo">The <see cref="System.Reflection.LocalVariableInfo"/> this /// element represents.</param> public LocalVariableInfoElement(LocalVariableInfo localVariableInfo) { if (localVariableInfo == null) { throw new ArgumentNullException("localVariableInfo"); } this.LocalVariableInfo = localVariableInfo; }
public LocalVariableInfoData Build(LocalVariableInfo localVariable) { return(new LocalVariableInfoData { LocalType = typeInfoDataConverter.Build(localVariable.LocalType), IsPinned = localVariable.IsPinned }); }
/// <summary> /// Converts from an <see cref="LocalVariableInfo"/> to an <see cref="LocalVariableInfoElement"/>. /// </summary> /// <param name="localVariableInfo">The <see cref="LocalVariableInfo"/></param> /// <returns>The <see cref="LocalVariableInfoElement"/></returns> public static LocalVariableInfoElement ToElement(this LocalVariableInfo localVariableInfo) { if (localVariableInfo == null) { throw new ArgumentNullException("localVariableInfo"); } return(new LocalVariableInfoElement(localVariableInfo)); }
LocalVariableInfo EmitSpecialFunction(CompilerState state, Type type, String constant) { if (state == null) { throw new Exception(); } if (type == null) { throw new Exception(); } if (constant == null) { throw new Exception(); } Dictionary <String, MethodInfo> methodmap; if (type == typeof(Triggers.Const)) { methodmap = m_constfunctionmethods; } else if (type == typeof(Triggers.GetHitVar)) { methodmap = m_gethitvarmethods; } else { throw new Exception(); } MethodInfo method; if (methodmap.TryGetValue(constant, out method) == false) { throw new Exception(); } LoadLocalVariable(state, state.FunctionState); state.Generator.Emit(OpCodes.Ldloca, state.ErrorVariable.LocalIndex); state.Generator.Emit(OpCodes.Call, method); Type returntype = method.ReturnType; if (returntype == typeof(Boolean)) { returntype = typeof(Int32); } LocalVariableInfo result = state.Generator.DeclareLocal(returntype); StoreLocalVariable(state, result); LoadLocalVariable(state, state.ErrorVariable); state.Generator.Emit(OpCodes.Brtrue, state.ErrorLabel); return(result); }
LocalVariableInfo EmitStateRedirection(CompilerState state, Node node) { if (state == null) { throw new Exception(); } if (node == null) { throw new Exception(); } Evaluation.Tokenizing.StateRedirectionData data = node.Token.Data as Evaluation.Tokenizing.StateRedirectionData; if (data == null) { throw new Exception(); } if (node.Children.Count < 1) { throw new Exception(); } List <LocalVariableInfo> functionargs = EmitRedirectionDescendants(state, node); MethodInfo method = FindCorrectRedirectionMethod(data.Type, functionargs); ParameterInfo[] parameters = method.GetParameters(); LoadLocalVariable(state, state.FunctionState); state.Generator.Emit(OpCodes.Ldloca, state.ErrorVariable.LocalIndex); for (Int32 i = 0; i != functionargs.Count; ++i) { LocalVariableInfo arg = functionargs[i]; ParameterInfo parameter = parameters[i + 2]; LoadLocalVariable(state, arg); //if (parameter.ParameterType == typeof(Int32) && arg.LocalType == typeof(Single)) state.Generator.Emit(OpCodes.Conv_I4); //if (parameter.ParameterType == typeof(Single) && arg.LocalType == typeof(Int32)) state.Generator.Emit(OpCodes.Conv_R4); } state.Generator.Emit(OpCodes.Call, method); LocalVariableInfo oldstate = state.FunctionState; state.FunctionState = state.Generator.DeclareLocal(typeof(Object)); StoreLocalVariable(state, state.FunctionState); LoadLocalVariable(state, state.ErrorVariable); state.Generator.Emit(OpCodes.Brtrue, state.ErrorLabel); LocalVariableInfo returnvalue = Emit(state, node.Children[node.Children.Count - 1]); state.FunctionState = oldstate; return(returnvalue); }
LocalVariableInfo EmitMethod(CompilerState state, MethodInfo method, List <LocalVariableInfo> args) { if (state == null) { throw new Exception(); } if (method == null) { throw new Exception(); } if (args == null) { throw new Exception(); } ParameterInfo[] parameters = method.GetParameters(); for (Int32 i = 0; i != args.Count; ++i) { LoadLocalVariable(state, args[i]); if (parameters[i].ParameterType == typeof(Single) && args[i].LocalType != typeof(Single)) { state.Generator.Emit(OpCodes.Conv_R4); } if (parameters[i].ParameterType == typeof(Double) && args[i].LocalType != typeof(Double)) { state.Generator.Emit(OpCodes.Conv_R8); } } state.Generator.Emit(OpCodes.Call, method); Type returntype = method.ReturnType; if (returntype == typeof(Boolean)) { returntype = typeof(Int32); } else if (returntype == typeof(Double)) { state.Generator.Emit(OpCodes.Conv_R4); returntype = typeof(Single); } LocalVariableInfo result = state.Generator.DeclareLocal(returntype); StoreLocalVariable(state, result); LoadLocalVariable(state, state.ErrorVariable); state.Generator.Emit(OpCodes.Brtrue, state.ErrorLabel); return(result); }
public override LocalVariableInfo ProjectLocalVariable(LocalVariableInfo value) { if (value == null) { return(null); } Debug.Assert(NeedsProjection(value)); return(new ProjectingLocalVariableInfo(value, this)); }
/// <summary> /// Validates an actual exception handling clause (the cloned version) against an expected one (its source). /// </summary> /// <param name="actualLocalVariable">Local variable to validate.</param> /// <param name="expectedLocalVariable">Local variable with expected info.</param> private static void ValidateLocalVariable(LocalVariableInfo actualLocalVariable, LocalVariableInfo expectedLocalVariable) { Assert.That(actualLocalVariable == null, Is.EqualTo(expectedLocalVariable == null)); if (actualLocalVariable == null) { return; } Assert.That(actualLocalVariable.IsPinned, Is.EqualTo(expectedLocalVariable.IsPinned)); Assert.That(actualLocalVariable.LocalIndex, Is.EqualTo(expectedLocalVariable.LocalIndex)); }
public static uint GetStackCountForLocal(MethodInfo aMethod, LocalVariableInfo aField) { var xSize = SizeOfType(aField.LocalType); var xResult = xSize / 4; if (xSize % 4 != 0) { xResult++; } return(xResult); }
public void LocalVariableInfoIsCorrect() { // Fixture setup var expected = TypeWithLocalVariables.LocalVariable; var sut = new LocalVariableInfoElement(expected); // Exercise system LocalVariableInfo actual = sut.LocalVariableInfo; // Verify outcome Assert.Equal(expected, actual); // Teardown }
/// <summary> /// /// </summary> /// <param name="il"></param> /// <param name="variable"></param> /// <returns></returns> public static ILGenerator Ldloca(this ILGenerator il, LocalVariableInfo variable) { if (variable.LocalIndex > byte.MaxValue) { il.Emit(OpCodes.Ldloca, variable.LocalIndex); } else { il.Emit(OpCodes.Ldloca_S, (byte)variable.LocalIndex); } return(il); }
internal LocalVariable(JavaClassImage classImage, ByteCodeMethodBody body, LocalVariableInfo variableInfo) { _name = new LazyValue <string>(() => classImage.ClassFile.ConstantPool.ResolveString(variableInfo.NameIndex)); _descriptor = new LazyValue <FieldDescriptor>(() => classImage.ResolveFieldDescriptor(variableInfo.DescriptorIndex)); Index = variableInfo.LocalIndex; Start = body.Instructions.GetByOffset(variableInfo.StartOffset); End = body.Instructions.GetByOffset(variableInfo.StartOffset + variableInfo.Length); }
//public static bool CanBuildOnTerrain(BuildableDef entDef, IntVec3 c, Map map, Rot4 rot, Thing thingToIgnore = null, ThingDef stuffDef = null) public static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions, MethodBase method) { LocalVariableInfo posInfo = method.GetMethodBody().LocalVariables.First(lv => lv.LocalType == typeof(IntVec3)); FieldInfo affordancesInfo = AccessTools.Field(typeof(TerrainDef), nameof(TerrainDef.affordances)); bool firstOnly = true; var instList = instructions.ToList(); for (int i = 0; i < instList.Count(); i++) { var inst = instList[i]; if (inst.LoadsField(affordancesInfo) && firstOnly) { firstOnly = false; // // IL_0053: ldarg.2 // map // IL_0054: ldfld class Verse.TerrainGrid Verse.Map::terrainGrid // IL_0059: ldloc.3 // c1 // IL_005a: callvirt instance class Verse.TerrainDef Verse.TerrainGrid::TerrainAt(valuetype Verse.IntVec3) // IL_005f: ldfld class [mscorlib]System.Collections.Generic.List`1<class Verse.TerrainAffordanceDef> Verse.TerrainDef::affordances // IL_0064: ldloc.0 // terrainAffordanceNeed // IL_0065: callvirt instance bool class [mscorlib]System.Collections.Generic.List`1<class Verse.TerrainAffordanceDef>::Contains(!0/*class Verse.TerrainAffordanceDef*/) // IL_006a: brtrue.s IL_0071 //Skip ldfld affordances, load terrainAffordanceNeed i++; yield return(instList[i]); //skip call to Contains i++; //replace with TerrainOrBridgesCanDo (below) yield return(new CodeInstruction(OpCodes.Ldarg_0)); //entDef yield return(new CodeInstruction(OpCodes.Ldloc, posInfo.LocalIndex)); //IntVec3 pos yield return(new CodeInstruction(OpCodes.Ldarg_2)); //Map yield return(new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(CanPlaceBlueprint), nameof(TerrainOrBridgesCanDo)))); //and it'll continue with the brtrue } else { yield return(inst); } } }
public void LoadAddressIntoEvaluationStack(LocalVariableInfo index) { var vreg = SetNewVReg(); vreg.FixedType = new TypeDescription( index.LocalType.MakeByRefType()); var argument = _representation.Vars.LocalVars.First(v => v.Id == index.LocalIndex); var assignment = new RefAssignment { Left = vreg, Right = argument }; AddOperation(assignment); }
public void VisitVariableDefinition(VariableDefinition variable) { var localVar = new LocalVariableInfo("local_" + variable.Index, ClrType.FromDescriptor(variable.VariableType.FullName)); var localVarIndex = variable.Index; //if (!IsStatic) // localVarIndex += 1; //slots[localVarIndex] = localVar; localVariables.Add(localVar); }