protected IElement IdentifyAndCollectCall(MethodBase methodBase, IndividualDecompilationContext context) { var parameters = methodBase.GetParameters(); var captureTarget = !methodBase.IsStatic ? (Func <Expression>)(context.CapturePreceding) : () => null; bool isSetter; var property = GetProperty(methodBase, out isSetter); if (property != null) { if (isSetter) { var value = context.CapturePreceding(); return(new MemberAssignmentElement(captureTarget(), property, value)); } return(new ExpressionElement(Expression.Property(captureTarget(), property))); } var method = methodBase as MethodInfo; if (method == null) { throw new NotImplementedException("Only method and property calls are implemented."); } var arguments = CaptureArguments(parameters, methodBase, context); return(new ExpressionElement(Expression.Call(captureTarget(), method, arguments))); }
public override IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { var constructor = (ConstructorInfo)((MethodReferenceInstruction)instruction.Instruction).Method; var arguments = this.CaptureArguments(constructor.GetParameters(), constructor, context); return(new ExpressionElement(Expression.New(constructor, arguments))); }
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 IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { var constructor = (ConstructorInfo)((MethodReferenceInstruction)instruction.Instruction).Method; var arguments = this.CaptureArguments(constructor.GetParameters(), constructor, context); return new ExpressionElement(Expression.New(constructor, arguments)); }
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 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 Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var field = ((FieldReferenceInstruction)instruction).Field; var instance = !field.IsStatic ? context.CapturePreceding() : null; return(Expression.Field(instance, field)); }
public override ExpressionElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { var indexGetter = variableIndexGetters[instruction.OpCode]; var variableIndex = indexGetter(instruction.Instruction); return(new ExpressionElement( new LocalExpression(variableIndex, this.method.GetTypeOfLocal(variableIndex)) )); }
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); }
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 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)); }
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)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return Expression.Constant( ((ValueInstruction<string>)instruction).Value ); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return(context.GetPreceding()); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return(Expression.Constant(null)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var type = ((TypeReferenceInstruction)instruction).Type; return Expression.NewArrayBounds(type, context.CapturePreceding()); }
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 ExpressionElement Interpret(InstructionElement element, IndividualDecompilationContext context) { return(new ExpressionElement(this.Interpret(element.Instruction, context))); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var target = context.CapturePreceding(); return conversions[instruction.OpCode](target); }
public override IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { context.CapturePreceding(); return(null); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return context.GetPreceding(); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return Expression.Constant(GetValue(instruction)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var target = context.CapturePreceding(); return(conversions[instruction.OpCode](target)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var type = ((TypeReferenceInstruction)instruction).Type; return(Expression.NewArrayBounds(type, context.CapturePreceding())); }
public abstract Expression Interpret(Instruction instruction, IndividualDecompilationContext context);
IElement IElementInterpretation.Interpret(IElement element, IndividualDecompilationContext context) { return(this.Interpret((TInputElement)element, context)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var indexGetter = parameterIndexGetters[instruction.OpCode]; return this.primaryContext.GetParameter(indexGetter(instruction)); }
public abstract TResultElement Interpret(TInputElement element, IndividualDecompilationContext context);
public override IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { var method = ((MethodReferenceInstruction)instruction.Instruction).Method; return(IdentifyAndCollectCall(method, context)); }
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 method = ((MethodReferenceInstruction)instruction).Method; return new AddressOfExpression(method); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var method = ((MethodReferenceInstruction)instruction).Method; return(new AddressOfExpression(method)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { return(Expression.Constant( ((ValueInstruction <string>)instruction).Value )); }
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); }
public override ArrayItemAssignmentElement Interpret(InstructionElement instruction, IndividualDecompilationContext context) { var value = context.CapturePreceding(); var index = context.CapturePreceding(); var array = context.CapturePreceding(); return(new ArrayItemAssignmentElement(array, index, value)); }
public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context) { var indexGetter = parameterIndexGetters[instruction.OpCode]; return(this.primaryContext.GetParameter(indexGetter(instruction))); }