public virtual Expression Decompile(IManagedMethod method, IList <Expression> arguments) { var elements = this.disassembler.Disassemble(method) .Select(i => (IElement) new InstructionElement(i)) .ToList(); var context = new DecompilationContext(this, method, i => arguments[i]); try { foreach (var step in this.pipeline.GetSteps()) { step.Apply(elements, context); } } catch (Exception ex) { throw new DecompilationException( "Exception while interpreting " + Environment.NewLine + ElementHelper.ToString(elements, Indent.FourSpaces) + Environment.NewLine + ex.Message, ex ); } return(GetSingleExpression(elements)); }
public virtual IEnumerable<Instruction> Disassemble(IManagedMethod method) { return this.instructionReaderFactory( method.GetBodyByteArray(), method.Context ).ReadAll(); }
public virtual IEnumerable <Instruction> Disassemble(IManagedMethod method) { return(this.instructionReaderFactory( method.GetBodyByteArray(), method.Context ).ReadAll()); }
private static LambdaExpression Decompile(IManagedMethod method) { return(new Decompiler( new TestDisassembler((bytes, context) => new InstructionReader(bytes, context)), new DefaultPipeline() ).Decompile(method)); }
public override IEnumerable<Instruction> Disassemble(IManagedMethod method) { var assembled = method as TestMethod; if (assembled != null) return assembled.GetInstructions(); return base.Disassemble(method); }
public void TestDecompilationResultHasCorrectParameters(IManagedMethod method) { var decompiled = Decompile(method); var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToList(); if (!method.IsStatic) parameterTypes.Insert(0, method.DeclaringType); Assert.AreElementsSame(parameterTypes, decompiled.Parameters.Select(p => p.Type)); }
public virtual LambdaExpression Decompile(IManagedMethod method) { var parameters = method.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToList(); if (!method.IsStatic) parameters.Insert(0, Expression.Parameter(method.DeclaringType, "<this>")); var body = this.Decompile(method, parameters.Cast<Expression>().ToArray()); return Expression.Lambda(body, parameters.ToArray()); }
public override IEnumerable <Instruction> Disassemble(IManagedMethod method) { var assembled = method as TestMethod; if (assembled != null) { return(assembled.GetInstructions()); } return(base.Disassemble(method)); }
private static void ApplyPipeline(IDecompilationPipeline pipeline, IList<IElement> elements, IManagedMethod method) { var parameters = method.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToList(); if (!method.IsStatic) parameters.Insert(0, Expression.Parameter(method.DeclaringType, "<this>")); var context = new DecompilationContext(null, method, i => parameters[i]); foreach (var step in pipeline.GetSteps()) { step.Apply(elements, context); } }
public void TestDecompilationResultHasCorrectParameters(IManagedMethod method) { var decompiled = Decompile(method); var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToList(); if (!method.IsStatic) { parameterTypes.Insert(0, method.DeclaringType); } Assert.AreElementsSame(parameterTypes, decompiled.Parameters.Select(p => p.Type)); }
public void TestNoExceptionsAreThrownWhenDecompiling(IManagedMethod method, IList<Instruction> instructions) { var pipeline = new DefaultPipeline().Without<LambdaInliningVisitor>(); var elements = instructions.Select(i => (IElement)new InstructionElement(i)).ToList(); Assert.DoesNotThrow(() => { try { ApplyPipeline(pipeline, elements, method); } catch (NotSupportedException) { } }); }
public virtual LambdaExpression Decompile(IManagedMethod method) { var parameters = method.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToList(); if (!method.IsStatic) { parameters.Insert(0, Expression.Parameter(method.DeclaringType, "<this>")); } var body = this.Decompile(method, parameters.Cast <Expression>().ToArray()); return(Expression.Lambda(body, parameters.ToArray())); }
public void TestNoExceptionsAreThrownWhenDecompiling(IManagedMethod method, IList <Instruction> instructions) { var pipeline = new DefaultPipeline().Without <LambdaInliningVisitor>(); var elements = instructions.Select(i => (IElement) new InstructionElement(i)).ToList(); Assert.DoesNotThrow(() => { try { ApplyPipeline(pipeline, elements, method); } catch (NotSupportedException) { } }); }
public void TestDecompilesTo(IManagedMethod method, IEnumerable<string> patterns) { var decompiled = Decompile(method); var parameterNames = decompiled.Parameters.Select(p => p.Name).ToArray(); var expected = patterns.Select( p => p.Contains("{0}") ? string.Format(p, parameterNames) : p ).ToList(); if (expected.Count <= 1) { Assert.AreEqual(expected.Single(), ToStringVisitor.ToString(decompiled)); } else { Assert.Contains(expected, ToStringVisitor.ToString(decompiled)); } }
public void TestDecompilesTo(IManagedMethod method, IEnumerable <string> patterns) { var decompiled = Decompile(method); var parameterNames = decompiled.Parameters.Select(p => p.Name).ToArray(); var expected = patterns.Select( p => p.Contains("{0}") ? string.Format(p, parameterNames) : p ).ToList(); if (expected.Count <= 1) { Assert.AreEqual(expected.Single(), ToStringVisitor.ToString(decompiled)); } else { Assert.Contains(expected, ToStringVisitor.ToString(decompiled)); } }
public virtual Expression Decompile(IManagedMethod method, IList<Expression> arguments) { var elements = this.disassembler.Disassemble(method) .Select(i => (IElement)new InstructionElement(i)) .ToList(); var context = new DecompilationContext(this, method, i => arguments[i]); try { foreach (var step in this.pipeline.GetSteps()) { step.Apply(elements, context); } } catch (Exception ex) { throw new DecompilationException( "Exception while interpreting " + Environment.NewLine + ElementHelper.ToString(elements, Indent.FourSpaces) + Environment.NewLine + ex.Message, ex ); } return GetSingleExpression(elements); }
public override void Initialize(DecompilationContext context) { this.method = context.Method; }
public void TestAllInstructionsCanBeDisassembled(IManagedMethod method) { var disassembler = ExpressiveEngine.GetDisassembler(); Assert.DoesNotThrow(() => disassembler.Disassemble(method)); }
public void TestDecompilationResultIsCompilable(IManagedMethod method) { var decompiled = Decompile(method); Assert.DoesNotThrow(() => decompiled.Compile()); }
public DecompilationContext(IDecompiler decompiler, IManagedMethod method, Func <int, Expression> getParameter) { this.Decompiler = decompiler; this.Method = method; this.GetParameter = getParameter; }
public DecompilationContext(IDecompiler decompiler, IManagedMethod method, Func<int, Expression> getParameter) { this.Decompiler = decompiler; this.Method = method; this.GetParameter = getParameter; }
private static void ApplyPipeline(IDecompilationPipeline pipeline, IList <IElement> elements, IManagedMethod method) { var parameters = method.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToList(); if (!method.IsStatic) { parameters.Insert(0, Expression.Parameter(method.DeclaringType, "<this>")); } var context = new DecompilationContext(null, method, i => parameters[i]); foreach (var step in pipeline.GetSteps()) { step.Apply(elements, context); } }
private static LambdaExpression Decompile(IManagedMethod method) { return new Decompiler( new TestDisassembler((bytes, context) => new InstructionReader(bytes, context)), new DefaultPipeline() ).Decompile(method); }