示例#1
0
        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)));
        }
示例#2
0
        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)));
        }
示例#3
0
        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));
        }
示例#4
0
        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));
        }
示例#5
0
 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);
 }
示例#6
0
        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));
        }
示例#7
0
        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));
        }
示例#8
0
        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))
                       ));
        }
示例#9
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);
        }
示例#10
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)
            );
        }
示例#11
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)
                       ));
        }
示例#12
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));
        }
示例#13
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));
        }
示例#14
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return Expression.Constant(
         ((ValueInstruction<string>)instruction).Value
     );
 }
示例#15
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return(context.GetPreceding());
 }
示例#16
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return(Expression.Constant(null));
 }
示例#17
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     var type = ((TypeReferenceInstruction)instruction).Type;
     return Expression.NewArrayBounds(type, context.CapturePreceding());
 }
示例#18
0
        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));
        }
示例#19
0
 public override ExpressionElement Interpret(InstructionElement element, IndividualDecompilationContext context)
 {
     return(new ExpressionElement(this.Interpret(element.Instruction, context)));
 }
示例#20
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     var target = context.CapturePreceding();
     return conversions[instruction.OpCode](target);
 }
示例#21
0
 public override IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context)
 {
     context.CapturePreceding();
     return(null);
 }
示例#22
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return context.GetPreceding();
 }
示例#23
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return Expression.Constant(GetValue(instruction));
 }
示例#24
0
        public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
        {
            var target = context.CapturePreceding();

            return(conversions[instruction.OpCode](target));
        }
示例#25
0
        public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
        {
            var type = ((TypeReferenceInstruction)instruction).Type;

            return(Expression.NewArrayBounds(type, context.CapturePreceding()));
        }
示例#26
0
 public abstract Expression Interpret(Instruction instruction, IndividualDecompilationContext context);
示例#27
0
 IElement IElementInterpretation.Interpret(IElement element, IndividualDecompilationContext context)
 {
     return(this.Interpret((TInputElement)element, context));
 }
示例#28
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     var indexGetter = parameterIndexGetters[instruction.OpCode];
     return this.primaryContext.GetParameter(indexGetter(instruction));
 }
示例#29
0
 public abstract TResultElement Interpret(TInputElement element, IndividualDecompilationContext context);
示例#30
0
        public override IElement Interpret(InstructionElement instruction, IndividualDecompilationContext context)
        {
            var method = ((MethodReferenceInstruction)instruction.Instruction).Method;

            return(IdentifyAndCollectCall(method, context));
        }
示例#31
0
        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));
        }
示例#32
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     var method = ((MethodReferenceInstruction)instruction).Method;
     return new AddressOfExpression(method);
 }
示例#33
0
        public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
        {
            var method = ((MethodReferenceInstruction)instruction).Method;

            return(new AddressOfExpression(method));
        }
示例#34
0
 public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
 {
     return(Expression.Constant(
                ((ValueInstruction <string>)instruction).Value
                ));
 }
示例#35
0
        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);
        }
示例#36
0
        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));
        }
示例#37
0
        public override Expression Interpret(Instruction instruction, IndividualDecompilationContext context)
        {
            var indexGetter = parameterIndexGetters[instruction.OpCode];

            return(this.primaryContext.GetParameter(indexGetter(instruction)));
        }