public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var field = ((FieldReferenceInstruction)instruction).Field;
var instance = !field.IsStatic
? context.CapturePreceding()
: null;
return Expression.Field(instance, field);
}
public TestMethod(string name, Type returnType, IEnumerable<IManagedMethodParameter> parameters, IList<Type> localTypes, Instruction[] instructions)
{
this.name = name;
this.returnType = returnType;
this.parameters = parameters;
this.localTypes = localTypes;
this.instructions = instructions;
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var right = context.CapturePreceding();
var left = context.CapturePreceding();
BooleanSupport.ConvertIfRequired(ref left, ref right);
var condition = conditions[instruction.OpCode.Name.SubstringBefore(".")];
return Expression.Condition(
condition(left, right),
Expression.Constant(1),
Expression.Constant(0)
);
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var singleOrRight = context.CapturePreceding();
var unary = unaryOperators.GetValueOrDefault(instruction.OpCode);
if (unary != null)
return unary(singleOrRight);
var left = context.CapturePreceding();
var binary = binaryOperators[instruction.OpCode];
Adapt(left, ref singleOrRight);
return binary(left, singleOrRight);
}
private object GetValue(Instruction instruction)
{
var valueInstruction = instruction as IValueInstruction;
if (valueInstruction != null)
return valueInstruction.Value;
var parts = instruction.OpCode.Name.Split('.');
if (parts.Length < 3)
throw new InvalidOperationException("Cannot extract value from " + instruction.OpCode + ".");
if (!parts[1].Equals("i4", StringComparison.InvariantCultureIgnoreCase))
throw new NotSupportedException("Cannot extract value from " + instruction.OpCode + ": " + parts[1] + " is not yet supported here.");
var valueString = parts[2];
if (valueString.Equals("M1", StringComparison.InvariantCultureIgnoreCase))
return -1;
return int.Parse(valueString);
}
public override bool CanInterpret(Instruction instruction)
{
return binaryOperators.ContainsKey(instruction.OpCode)
|| unaryOperators.ContainsKey(instruction.OpCode);
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var indexGetter = parameterIndexGetters[instruction.OpCode];
return this.primaryContext.GetParameter(indexGetter(instruction));
}
public override bool CanInterpret(Instruction instruction)
{
return parameterIndexGetters.ContainsKey(instruction.OpCode);
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
return Expression.Constant(
((ValueInstruction<string>)instruction).Value
);
}
public override bool CanInterpret(Instruction instruction)
{
return instruction.OpCode == OpCodes.Ldfld
|| instruction.OpCode == OpCodes.Ldsfld;
}
public InstructionElement(Instruction instruction)
{
this.Instruction = instruction;
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
return Expression.Constant(GetValue(instruction));
}
public override bool CanInterpret(Instruction instruction)
{
return instruction.OpCode.Name.StartsWith(LdcNamePrefix);
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
return context.GetPreceding();
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var target = context.CapturePreceding();
return conversions[instruction.OpCode](target);
}
public override bool CanInterpret(Instruction instruction)
{
return conversions.ContainsKey(instruction.OpCode);
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var method = ((MethodReferenceInstruction)instruction).Method;
return new AddressOfExpression(method);
}
public override bool CanInterpret(Instruction instruction)
{
return instruction.OpCode == OpCodes.Newarr;
}
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
{
var type = ((TypeReferenceInstruction)instruction).Type;
return Expression.NewArrayBounds(type, context.CapturePreceding());
}
public override bool CanInterpret(Instruction instruction)
{
return conditions.Keys.Any(k => instruction.OpCode.Name.StartsWith(k));
}