protected void AddDecompiledMemberToDecompiledType(CachedDecompiledMember decompiledMember, DecompiledType decompiledType)
{
if (!decompiledType.DecompiledMembers.ContainsKey(decompiledMember.Member.MemberFullName))
{
decompiledType.DecompiledMembers.Add(decompiledMember.Member.MemberFullName, decompiledMember.Member);
}
}
protected void AddGeneratedFilterMethodsToDecompiledType(DecompiledType decompiledType, TypeSpecificContext context, ILanguage language)
{
foreach (GeneratedMethod generatedMethod in context.GeneratedFilterMethods)
{
CachedDecompiledMember member = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(generatedMethod.Method), generatedMethod.Body, generatedMethod.Context));
AddDecompiledMemberToDecompiledType(member, decompiledType);
}
}
protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
{
CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
}
return cachedMember;
}
public void Decompile(out CachedDecompiledMember getMethod, out CachedDecompiledMember setMethod, out bool isAutoImplemented)
{
getMethod = null;
setMethod = null;
isAutoImplemented = false;
if (propertyDef.GetMethod == null || propertyDef.GetMethod.Parameters.Count != 0 || !propertyDef.GetMethod.HasBody ||
propertyDef.OtherMethods.Count != 0)
{
getMethod = DecompileMember(propertyDef.GetMethod);
setMethod = DecompileMember(propertyDef.SetMethod);
isAutoImplemented = false;
}
else if (propertyDef.SetMethod != null)
{
if (propertyDef.SetMethod.Parameters.Count != 1 || !propertyDef.SetMethod.HasBody)
{
getMethod = DecompileMember(propertyDef.GetMethod);
setMethod = DecompileMember(propertyDef.SetMethod);
isAutoImplemented = false;
}
else
{
// Auto-implemented property with getter and setter
isAutoImplemented = DecompileAndCheckForAutoImplementedPropertyMethod(propertyDef.GetMethod, out getMethod, true, CheckGetter) &
DecompileAndCheckForAutoImplementedPropertyMethod(propertyDef.SetMethod, out setMethod, true, CheckSetter);
}
}
else if (!this.language.SupportsGetterOnlyAutoProperties)
{
getMethod = DecompileMember(propertyDef.GetMethod);
setMethod = DecompileMember(propertyDef.SetMethod);
isAutoImplemented = false;
}
else
{
// Getter only auto-implemented property
isAutoImplemented = DecompileAndCheckForAutoImplementedPropertyMethod(propertyDef.GetMethod, out getMethod, true, CheckGetter);
}
}
private void RemoveBaseCtorInvocationStatements(CachedDecompiledMember decompiledMember, DecompiledType decompiledType)
{
MethodSpecificContext methodContext = decompiledMember.Member.Context;
//value types chained constructors?
if (methodContext== null || !methodContext.Method.IsConstructor || methodContext.Method.IsStatic || methodContext.CtorInvokeExpression == null)
{
return;
}
BlockStatement methodBody = decompiledMember.Member.Statement as BlockStatement;
if (methodBody == null) // it might have been an exception
{
return;
}
else if (methodBody.Statements.Count == 1 && methodBody.Statements[0] is UnsafeBlockStatement)
{
methodBody = methodBody.Statements[0] as UnsafeBlockStatement;
}
TypeSpecificContext typeContext = decompiledType.TypeContext;
if (typeContext.FieldInitializationFailed && typeContext.BaseCtorInvocators.Contains(methodContext.Method))
{
methodContext.CtorInvokeExpression = null;
}
else
{
/// all statements before the constructor invocation should be removed
for (int i = 0; i < methodBody.Statements.Count; i++)
{
if (methodBody.Statements[i].CodeNodeType == Ast.CodeNodeType.ExpressionStatement &&
((methodBody.Statements[i] as ExpressionStatement).Expression.CodeNodeType == Ast.CodeNodeType.ThisCtorExpression ||
(methodBody.Statements[i] as ExpressionStatement).Expression.CodeNodeType == Ast.CodeNodeType.BaseCtorExpression))
{
RemoveFirstStatements(methodBody.Statements, i + 1);
return;
}
}
throw new Exception("Constructor invocation not found.");
}
}
public virtual bool IsDecompiledMemberInCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers)
{
bool isDecompiledMemberInCache = decompiledMembersCache.ContainsKey(GetMemberKey(member, language, renameInvalidMembers));
if (isDecompiledMemberInCache)
{
CachedDecompiledMember cachedDecompiledMember = this.GetDecompiledMemberFromCache(member, language, renameInvalidMembers);
foreach (CastExpression cast in cachedDecompiledMember.Member.Context.AnalysisResults.AmbiguousCastsToObject)
{
TypeReference lastResolvedType;
bool? haveOverloadedOperator = Common.Extensions.ResolveToOverloadedEqualityOperator(cast.Expression.ExpressionType, out lastResolvedType);
bool isResolved = haveOverloadedOperator.HasValue;
if (isResolved)
{
this.RemoveDecompiledMemberFromCache(member, language, renameInvalidMembers);
isDecompiledMemberInCache = false;
break;
}
}
}
return(isDecompiledMemberInCache);
}
public virtual void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
decompiledMembersCache.Add(GetMemberKey(member, language, renameInvalidMembers), decompiledMember);
}
public void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
return;
}
protected void DecompileConstructorChain(MethodDefinition method, ILanguage language, DecompiledType decompiledType)
{
if (this.cacheService.IsDecompiledMemberInCache(method, language, this.renameInvalidMembers))
{
///all constructors have already been decompiled.
CachedDecompiledMember decompiledMember = this.cacheService.GetDecompiledMemberFromCache(method, language, this.renameInvalidMembers);
AddDecompiledMemberToDecompiledType(decompiledMember, decompiledType);
AddAssignmentDataToDecompiledType(decompiledMember, decompiledType);
return;
}
if (method.Body == null)
{
CachedDecompiledMember methodCache = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), null, null));
this.cacheService.AddDecompiledMemberToCache(method, language, this.renameInvalidMembers, methodCache);
return;
}
CachedDecompiledMember originalConstructor = DecompileMethod(language, method, decompiledType.TypeContext.ShallowPartialClone());
List<CachedDecompiledMember> allConstructors = new List<CachedDecompiledMember>();
TypeDefinition declaringType = method.DeclaringType;
if (!method.IsStatic)
{
foreach (MethodDefinition constructor in declaringType.Methods)
{
if (!constructor.IsConstructor || constructor.FullName == originalConstructor.Member.MemberFullName || constructor.IsStatic)
{
continue;
}
if (constructor.Body == null)
{
CachedDecompiledMember methodCache = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(constructor), null, null));
allConstructors.Add(methodCache);
}
else
{
allConstructors.Add(DecompileMethod(language, constructor, decompiledType.TypeContext.ShallowPartialClone()));
}
}
allConstructors.Add(originalConstructor);
MergeConstructorsTypeContexts(allConstructors, decompiledType);
foreach (CachedDecompiledMember constructor in allConstructors)
{
if (!(language is IntermediateLanguage))
{
// there are no such statements in IL
RemoveBaseCtorInvocationStatements(constructor, decompiledType);
}
if (constructor.Member.Context == null)
{
var methodDefinition = decompiledType.Type.Methods.First(x => x.FullName == constructor.Member.MemberFullName);
if (!this.cacheService.IsDecompiledMemberInCache(methodDefinition, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(methodDefinition, language, this.renameInvalidMembers, constructor);
}
}
else
{
if (!this.cacheService.IsDecompiledMemberInCache(constructor.Member.Context.Method, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(constructor.Member.Context.Method, language, this.renameInvalidMembers, constructor);
}
}
AddDecompiledMemberToDecompiledType(constructor, decompiledType);
//UpdateTypeContext(decompiledType.TypeContext, constructor);
}
}
}
public virtual void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
DefaultDecompilationCacheService.decompiledMembersCache.Add(this.GetMemberKey(member, language, renameInvalidMembers), decompiledMember);
return;
}
private bool DecompileAndCheckForAutoImplementedPropertyMethod(MethodDefinition method, out CachedDecompiledMember decompiledMember,
bool needDecompiledMember, Func<BlockStatement, bool> checker)
{
decompiledMember = null;
DecompilationContext context;
BlockStatement statements = this.DecompileMethodPartially(method.Body, out context, needDecompiledMember);
if (statements == null && context == null)
{
if (needDecompiledMember)
{
decompiledMember = DecompileMember(method);
}
return false;
}
else if (statements.Statements.Count == 1 && statements.Statements[0].CodeNodeType == CodeNodeType.ExceptionStatement)
{
if (needDecompiledMember)
{
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statements, new MethodSpecificContext(method.Body)));
}
return false;
}
if (checker(statements))
{
if (needDecompiledMember)
{
if (this.propertyDef.ShouldStaySplit())
{
decompiledMember = FinishDecompilationOfMember(method, statements, context);
}
else
{
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statements, context.MethodContext));
}
}
return true;
}
else
{
if (needDecompiledMember)
{
decompiledMember = FinishDecompilationOfMember(method, statements, context);
}
return false;
}
}
public void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
}
private CachedDecompiledMember DecompileMethod(ILanguage language, MethodDefinition method, TypeSpecificContext typeContext)
{
CachedDecompiledMember decompiledMember;
Statement statement;
try
{
DecompilationContext innerContext = null;
statement = method.Body.Decompile(language, out innerContext, typeContext);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statement, innerContext.MethodContext), innerContext.TypeContext);
}
catch (Exception ex)
{
this.ExceptionsWhileDecompiling.Add(method);
BlockStatement blockStatement = new BlockStatement();
statement = new ExceptionStatement(ex, method);
blockStatement.AddStatement(statement);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), blockStatement, new MethodSpecificContext(method.Body)));
}
return decompiledMember;
}
private static void AddAssignmentDataToDecompiledType(CachedDecompiledMember decompiledMember, DecompiledType decompiledType)
{
if (!decompiledType.TypeContext.FieldInitializationFailed)
{
foreach (KeyValuePair<string, InitializationAssignment> pair in decompiledMember.FieldAssignmentData)
{
if (!decompiledType.TypeContext.AssignmentData.ContainsKey(pair.Key))
{
decompiledType.TypeContext.AssignmentData.Add(pair.Key, pair.Value);
}
else if (!decompiledType.TypeContext.AssignmentData[pair.Key].AssignmentExpression.Equals(pair.Value.AssignmentExpression))
{
decompiledType.TypeContext.FieldInitializationFailed = true;
decompiledType.TypeContext.AssignmentData = new Dictionary<string, InitializationAssignment>();
return;
}
}
}
}
private CachedDecompiledMember DecompileMember(MethodDefinition method)
{
CachedDecompiledMember cachedDecompiledMember = null;
if (method != null)
{
if (method.Body == null)
{
cachedDecompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), null, null));
}
else if (this.IsCachingEnabled && this.cacheService.IsDecompiledMemberInCache(method, this.language, this.renameInvalidMembers))
{
return this.cacheService.GetDecompiledMemberFromCache(method, this.language, this.renameInvalidMembers);
}
else
{
MethodSpecificContext methodContext;
BlockStatement block = this.DecompileMethod(method.Body, out methodContext);
cachedDecompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), block, methodContext));
if (this.IsCachingEnabled)
{
this.cacheService.AddDecompiledMemberToCache(method, this.language, this.renameInvalidMembers, cachedDecompiledMember);
}
}
}
return cachedDecompiledMember;
}
public virtual void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
decompiledMembersCache.Add(GetMemberKey(member, language, renameInvalidMembers), decompiledMember);
}
private CachedDecompiledMember FinishDecompilationOfMember(MethodDefinition method, BlockStatement block, DecompilationContext context)
{
if (this.IsCachingEnabled && this.cacheService.IsDecompiledMemberInCache(method, this.language, this.renameInvalidMembers))
{
return this.cacheService.GetDecompiledMemberFromCache(method, this.language, this.renameInvalidMembers);
}
MethodSpecificContext methodContext;
BlockStatement fullyDecompiledBlock = this.FinishDecompilationOfMethod(block, context, out methodContext);
CachedDecompiledMember cachedDecompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), fullyDecompiledBlock, methodContext));
if (this.IsCachingEnabled)
{
this.cacheService.AddDecompiledMemberToCache(method, this.language, this.renameInvalidMembers, cachedDecompiledMember);
}
return cachedDecompiledMember;
}
