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