public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
theRebuilder = new AnonymousDelegateRebuilder(context, body);
VisitBlockStatement(body);
theRebuilder.CleanUpVariableCopyAssignments();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement block)
{
this.context = context;
fixer = new SwitchByStringFixer(context.MethodContext.Method.Module.TypeSystem);
Visit(block);
return block;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
MethodDefinition method = context.MethodContext.Method;
if (method.IsGetter || method.IsSetter)
{
PropertyDefinition property;
if (!context.TypeContext.MethodToPropertyMap.TryGetValue(method, out property))
{
throw new Exception("PropertyDefinition not found in method to property map.");
}
if (property.ShouldStaySplit())
{
string methodDefinitionNewName = Constants.JustDecompileGenerated + "_" + method.Name;
context.TypeContext.MethodDefinitionToNameMap.Add(method, methodDefinitionNewName);
FieldDefinition backingField = Utilities.GetCompileGeneratedBackingField(property);
if (backingField != null)
{
string backingFieldNewName = backingField.Name.Replace("<" + property.Name + ">", Constants.JustDecompileGenerated + "_" + property.Name + "_");
if (!context.TypeContext.BackingFieldToNameMap.ContainsKey(backingField))
{
context.TypeContext.BackingFieldToNameMap.Add(backingField, backingFieldNewName);
}
}
}
}
return body;
}
public FilterMethodToBeDecompiled(MethodDefinition method, CatchClause catchClause, DecompilationContext context, BlockStatement block)
{
this.Method = method;
this.CatchClause = catchClause;
this.Context = context;
this.Block = block;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
MethodDefinition method = context.MethodContext.Method;
if (method.Name == "Finalize" && method.IsVirtual)
{
if (body.Statements.Count == 1 && body.Statements[0] is TryStatement)
{
TryStatement tryFinally = body.Statements[0] as TryStatement;
if (tryFinally.Finally != null && tryFinally.Finally.Body.Statements.Count == 1 && tryFinally.Finally.Body.Statements[0] is ExpressionStatement)
{
ExpressionStatement finallyStatementExpressionStatement = tryFinally.Finally.Body.Statements[0] as ExpressionStatement;
if (finallyStatementExpressionStatement.Expression is MethodInvocationExpression)
{
MethodDefinition baseDestructor = (finallyStatementExpressionStatement.Expression as MethodInvocationExpression).MethodExpression.MethodDefinition;
if (baseDestructor != null)
{
if (baseDestructor.Name == "Finalize" && baseDestructor.DeclaringType.FullName == method.DeclaringType.BaseType.FullName)
{
context.MethodContext.IsDestructor = true;
context.MethodContext.DestructorStatements = new BlockStatement() { Statements = tryFinally.Try.Statements };
}
}
}
}
}
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
this.decompiledMethodReturnType = context.MethodContext.Method.ReturnType;
Visit(body);
return body;
}
/// <summary>
/// The entry point for the step.
/// </summary>
/// <param name="context">The decompilation context.</param>
/// <param name="body">The body of the method.</param>
/// <returns>Returns the updated body of the method.</returns>
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
MethodSpecificContext methodContext = context.MethodContext;
foreach (int key in methodContext.Expressions.BlockExpressions.Keys)
{
IList<Expression> expressionList = methodContext.Expressions.BlockExpressions[key];
Code lastInstructionCode = methodContext.ControlFlowGraph.InstructionToBlockMapping[key].Last.OpCode.Code;
bool endsWithConditionalJump = lastInstructionCode == Code.Brtrue || lastInstructionCode == Code.Brtrue_S ||
lastInstructionCode == Code.Brfalse || lastInstructionCode == Code.Brfalse_S;
for (int i = 0; i < expressionList.Count; i++)
{
expressionList[i] = (Expression)Visit(expressionList[i]);
}
if (endsWithConditionalJump)
{
expressionList[expressionList.Count - 1] = (Expression)
FixBranchingExpression(expressionList[expressionList.Count - 1], methodContext.ControlFlowGraph.InstructionToBlockMapping[key].Last);
}
//if (lastInstructionCode == Code.Switch)
//{
// //the type of this expression is needed if the switch instruction causes IrregularSwitchLC
// //so that correct expressions can be produced for case's conditions
// //Expression lastExpression = expressionList[expressionList.Count - 1];
//}
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement block)
{
this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
this.context = context;
BlockStatement newBlock = (BlockStatement)VisitBlockStatement(block);
return newBlock;
}
public Ast.Statements.BlockStatement Process(DecompilationContext context, Ast.Statements.BlockStatement body)
{
this.decompilationContext = context;
this.theCFG = context.MethodContext.ControlFlowGraph;
ProcessTheControlFlowGraph();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
InsertTopLevelParameterAssignments(body);
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.methodContext = context.MethodContext;
Visit(body);
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
this.patternsContext = new CodePatternsContext(body);
body = (BlockStatement)Visit(body);
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.methodContext = context.MethodContext;
ClearState();
this.foreachBody = new BlockStatement();
Visit(body);
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
this.theBody = body;
Visit((ICodeNode)body);
CleanUpUnusedDeclarations();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
methodContext = context.MethodContext;
Visit(body);
body = CallSiteInvocationReplacer.ReplaceInvocations(body, fieldToCallSiteInfoMap, variableToCallSiteInfoMap, statementsToRemove,
methodContext.Method.Module.TypeSystem);
RemoveStatements();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
Visit(body);
if(this.context.MethodContext.CtorInvokeExpression != null)
{
Visit(this.context.MethodContext.CtorInvokeExpression);
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
this.fieldsToRemove = new Dictionary<FieldDefinition, Expression>();
this.variablesToRemove = new Dictionary<VariableReference, Expression>();
this.initializationsToRemove = new Dictionary<VariableReference, Statement>();
BlockStatement result = (BlockStatement)Visit(body);
RemoveInitializations();
return result;
}
public BlockDecompilationPipeline(IEnumerable<IDecompilationStep> steps, DecompilationContext context)
: base(steps)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.Context = context;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
TypeSystem typeSystem = context.MethodContext.Method.Module.TypeSystem;
this.operatorStep = new OperatorStep(this, typeSystem);
this.removePIDStep = new RemovePrivateImplementationDetailsStep(typeSystem);
this.rebuildEventsStep = new RebuildEventsStep(typeSystem);
this.propertyRecognizer = new PropertyRecognizer(typeSystem, context.TypeContext, Language);
this.rebuildAnonymousInitializersStep = new RebuildAnonymousTypesInitializersStep(this, typeSystem);
this.fixSwitchConditionStep = new FixSwitchConditionStep(context);
return (BlockStatement)VisitBlockStatement(body);
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.methodContext = context.MethodContext;
this.originalStatements = body.Statements;
if (Match())
{
body.Statements = asyncStatements;
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.decompilationContext = context;
if (Match(body.Statements))
{
body.Statements = newStatements;
body = (BlockStatement)Visit(body);
RemoveLastIfYieldBreak(body.Statements);
return body;
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
if (!context.MethodContext.Body.ExceptionHandlers.Any(eh => eh.HandlerType == ExceptionHandlerType.Filter))
{
return body;
}
this.context = context;
body = (BlockStatement)Visit(body);
RemoveVariablesUsedOnlyInFilters();
DecompileMethods();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
NotSupportedUnaryOperatorFinder notSupportedUnaryOperatorFinder = new NotSupportedUnaryOperatorFinder();
notSupportedUnaryOperatorFinder.Visit(body);
if (notSupportedUnaryOperatorFinder.IsAddressUnaryOperatorFound)
{
throw new ArgumentException(string.Format("The unary opperator {0} is not supported in VisualBasic", notSupportedUnaryOperatorFinder.FoundUnaryOperator));
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context;
VisitExpressions();
TransformExpressions(new VariableReplacer(variableToAssignExpression));
TransformExpressions(new Dereferencer());
RemoveVariablesFromContext();
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
DependsOnAnalysisVisitor visitor = new DependsOnAnalysisVisitor(context.MethodContext.AnalysisResults.TypesDependingOn, context.MethodContext.AnalysisResults.AmbiguousCastsToObject);
visitor.Visit(body);
if(context.TypeContext.AssignmentData != null)
{
foreach (InitializationAssignment fieldAsssignment in context.TypeContext.AssignmentData.Values)
{
visitor.Visit(fieldAsssignment.AssignmentExpression);
}
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
this.decompiledMethodReturnType = context.MethodContext.Method.ReturnType;
Visit(body);
if (context.MethodContext.CtorInvokeExpression != null)
{
Visit(context.MethodContext.CtorInvokeExpression);
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
MethodDefinition method = context.MethodContext.Method;
if (!method.IsUnsafe && method.HasBody && IsUnsafe(method.Body.Instructions))
{
UnsafeBlockStatement unsafeStatement = new UnsafeBlockStatement(body.Statements);
body.Statements = new StatementCollection();
body.AddStatement(unsafeStatement);
}
return body;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.context = context.MethodContext;
foreach (KeyValuePair<int, IList<Expression>> blockPair in context.MethodContext.Expressions.BlockExpressions)
{
parentExpressions.Clear();
foreach (Expression expr in blockPair.Value)
{
Visit(expr);
}
}
return body;
}
public virtual BlockStatement Process(DecompilationContext context, BlockStatement block)
{
this.methodContext = context.MethodContext;
this.typeContext = context.TypeContext;
//this.suggestedNames.UnionWith(methodContext.UsedNames);
//this.suggestedNames.UnionWith(context.VariableNames);
Preprocess();
VisitBlockStatement(block);
ReplaceDeclarations(block);
//this.methodContext.UsedNames.UnionWith(suggestedNames);
CollectVariableNames();
return block;
}
public Ast.Statements.BlockStatement Process(DecompilationContext context, Ast.Statements.BlockStatement body)
{
this.moveNextMethodContext = context.MethodContext;
this.theCFG = this.moveNextMethodContext.ControlFlowGraph;
moveNextMethodContext.IsMethodBodyChanged = true;
StateMachineUtilities.FixInstructionConnections(theCFG.Blocks);
if (!ProcessCFG())
{
((BaseLanguage)Language).StopPipeline();
}
return body;
}
public static BlockStatement Decompile(this MethodBody body, ILanguage language, out DecompilationContext context, TypeSpecificContext typeContext = null)
{
DecompilationPipeline pipeline;
if (typeContext != null)
{
pipeline = language.CreatePipeline(new DecompilationContext(new MethodSpecificContext(body), typeContext, language));
}
else
{
pipeline = language.CreatePipeline();
}
return RunPipeline(pipeline, language, body, out context);
}
internal static BlockStatement DecompileLambda(this MethodBody body, ILanguage language, DecompilationContext context)
{
MethodDefinition method = null;
if (body != null)
{
method = body.Method;
}
DecompilationPipeline pipeline = language.CreateLambdaPipeline(context);
return RunPipeline(pipeline, language, body, out context);
}
public DecompilationPipeline(IEnumerable <IDecompilationStep> steps, DecompilationContext context)
{
this.Context = context;
this.steps = new List <IDecompilationStep>(steps);
}
static BlockStatement RunPipeline(DecompilationPipeline pipeline, ILanguage language, MethodBody body, out DecompilationContext context)
{
context = pipeline.Run(body, language);
return(pipeline.Body);
}
public static BlockStatement Decompile(this MethodBody body, ILanguage language, out DecompilationContext context, TypeSpecificContext typeContext = null)
{
MethodDefinition method = null;
if (body != null)
{
method = body.Method;
}
DecompilationPipeline pipeline;
if (typeContext != null)
{
pipeline = language.CreatePipeline(method, new DecompilationContext(new MethodSpecificContext(body), typeContext));
}
else
{
pipeline = language.CreatePipeline(method);
}
return(RunPipeline(pipeline, language, body, out context));
}
internal static BlockStatement DecompileAsyncStateMachine(this MethodBody body, DecompilationContext enclosingContext,
out AsyncData asyncData)
{
DecompilationContext decompilationContext;
BlockStatement theBlockStatement = body.DecompileStateMachine(enclosingContext, new RemoveAsyncStateMachineStep(),
(DecompilationContext context) => context.MethodContext.AsyncData, out decompilationContext);
asyncData = decompilationContext.MethodContext.AsyncData;
return theBlockStatement;
}
/// <summary>
/// Decompiles <paramref name="body"/>, using the preset <paramref name="context"/>.
/// </summary>
/// <param name="body">The body of the method, to be decompiled.</param>
/// <param name="language">The language to which is decompiled.</param>
/// <param name="context">The context for the decompilation.</param>
/// <returns>Returns the expression-statement tree, representing the decompiled method.</returns>
public static BlockStatement Decompile(this MethodBody body, ILanguage language, DecompilationContext context)
{
MethodDefinition method = null;
if (body != null)
{
method = body.Method;
}
DecompilationPipeline pipeline = language.CreatePipeline(method, context);
return(RunPipeline(pipeline, language, body, out context));
}
