public override IElement Interpret(BranchingElement branch, IndividualDecompilationContext context)
{
var condition = CaptureCondition(branch, context);
var targetAsExpression = AsSingleExpression(branch.Target);
var fallbackAsExpression = AsSingleExpression(branch.Fallback);
condition = BooleanSupport.ConvertIfRequired(condition, typeof(bool));
if (targetAsExpression != null && fallbackAsExpression != null)
{
BooleanSupport.ConvertIfRequired(ref targetAsExpression, ref fallbackAsExpression);
return(new ExpressionElement(Expression.Condition(condition, targetAsExpression, fallbackAsExpression)));
}
var ifTrue = branch.Target;
var ifFalse = branch.Fallback;
if (ifTrue.Count == 0)
{
condition = Expression.Not(condition);
ifFalse = branch.Target;
ifTrue = branch.Fallback;
}
return(new IfThenElement(condition, ifTrue, ifFalse));
}
public override ReturnElement Interpret(InstructionElement instruction, IndividualDecompilationContext context)
{
var result = this.returnType != typeof(void)
? context.CapturePreceding()
: null;
result = BooleanSupport.ConvertIfRequired(result, this.returnType);
return(new ReturnElement(result));
}
public override VariableAssignmentElement Interpret(InstructionElement instruction, IndividualDecompilationContext context)
{
var value = context.CapturePreceding();
var index = variableIndexGetters[instruction.OpCode](instruction.Instruction);
var type = this.method.GetTypeOfLocal(index);
value = BooleanSupport.ConvertIfRequired(value, type);
return(new VariableAssignmentElement(index, value));
}
public override MemberAssignmentElement Interpret(InstructionElement instruction, IndividualDecompilationContext context)
{
var field = ((FieldReferenceInstruction)instruction.Instruction).Field;
var value = context.CapturePreceding();
var instance = (Expression)null;
if (!field.IsStatic)
{
instance = context.CapturePreceding();
}
value = BooleanSupport.ConvertIfRequired(value, field.FieldType);
return(new MemberAssignmentElement(instance, field, value));
}
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)
));
}
private Expression CaptureCondition(BranchingElement branch, IndividualDecompilationContext context)
{
var rootOpCodeName = branch.OpCode.Name.SubstringBefore(".");
var isUnary = unary.ContainsKey(rootOpCodeName);
if (isUnary)
{
var operand = context.CapturePreceding();
operand = BooleanSupport.ConvertIfRequired(operand, typeof(bool));
return(unary[rootOpCodeName].Invoke(operand));
}
var right = context.CapturePreceding();
var left = context.CapturePreceding();
return(binary[rootOpCodeName].Invoke(left, right));
}
protected IEnumerable <Expression> CaptureArguments(ParameterInfo[] parameters, MethodBase methodBase, IndividualDecompilationContext context)
{
context.VerifyPrecedingCount(parameters.Length, (actualCount, precedingString) => string.Format(
"Method {0} expects {1} parameters." + Environment.NewLine +
"However, there are only {2} preceding elements: " + Environment.NewLine + "{3}",
methodBase, parameters.Length, actualCount, precedingString
));
var arguments = new List <Expression>();
while (arguments.Count < parameters.Length)
{
arguments.Add(context.CapturePreceding());
}
arguments.Reverse();
for (var i = 0; i < arguments.Count; i++)
{
arguments[i] = BooleanSupport.ConvertIfRequired(arguments[i], parameters[i].ParameterType);
}
return(arguments);
}
