//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);
}
